Fix nested type inheritance conversion (#171)

## Summary
- Fixes #137 — when a Java class extends/implements a nested type (e.g.
  `GeneratorFactory.AbstractXmlFeatureGeneratorFactory`), the declaring
  type qualifier was silently dropped, producing invalid/incorrect C#
  (`AbstractXmlFeatureGeneratorFactory` instead of
  `GeneratorFactory.AbstractXmlFeatureGeneratorFactory`).
- Root cause: `TypeHelper.GetSyntaxFromType` only read
  `ClassOrInterfaceType.getNameAsString()`, which returns just the
  simple name. JavaParser exposes the declaring type separately via
  `getScope()`, which was never consulted.
- Fix: after resolving the leaf type syntax, check `getScope()` and,
  if present, recursively resolve it and wrap the result in a
  `QualifiedName`, preserving `Outer.Inner` qualification (valid in
  both Java and C#).

## Test plan
- [x] Added `ConvertNestedTypeInheritanceTests` reproducing the exact
  scenario from #137 (class extending/implementing nested types keeps
  the `GeneratorFactory.` qualifier).
- [x] Added a sanity test confirming plain (non-nested) `extends` is
  unaffected.
- [x] Full test suite passes: `dotnet test` — 337/337 passed.

Co-authored-by: Munishwar kalra <kalramunishwar.com>

Author: Munishwar001

JavaToCSharp.Tests/ConvertNestedTypeInheritanceTests.cs

@@ -0,0 +1,45 @@
+namespace JavaToCSharp.Tests;
+
+public class ConvertNestedTypeInheritanceTests
+{
+    [Fact]
+    public void Extending_Nested_Type_Keeps_Declaring_Type_Qualifier()
+    {
+        const string javaCode = """
+                                package com.example;
+                                public class GeneratorFactory {
+                                    public abstract static class AbstractXmlFeatureGeneratorFactory {
+                                    }
+                                    public interface XmlFeatureGeneratorFactory {
+                                    }
+                                    public class CachedFeatureGeneratorFactory
+                                        extends GeneratorFactory.AbstractXmlFeatureGeneratorFactory
+                                        implements GeneratorFactory.XmlFeatureGeneratorFactory {
+                                    }
+                                }
+                                """;
+
+        var parsed = Convert(javaCode);
+
+        Assert.Contains(
+            "public class CachedFeatureGeneratorFactory : GeneratorFactory.AbstractXmlFeatureGeneratorFactory, GeneratorFactory.XmlFeatureGeneratorFactory",
+            parsed);
+    }
+
+    [Fact]
+    public void Extending_Simple_Type_Is_Unaffected()
+    {
+        const string javaCode = """
+                                package com.example;
+                                public class Square extends Shape {
+                                }
+                                """;
+
+        var parsed = Convert(javaCode);
+
+        Assert.Contains("public class Square : Shape", parsed);
+    }
+
+    private static string Convert(string javaCode)
+        => JavaToCSharpConverter.ConvertText(javaCode, new JavaConversionOptions { IncludeComments = false }) ?? "";
+}

JavaToCSharp/TypeHelper.cs

@@ -171,6 +171,15 @@ public static TypeSyntax GetSyntaxFromType(ClassOrInterfaceType type)
             typeSyntax = SyntaxFactory.ParseTypeName(typeName);
         }
 
+        // Nested types (e.g. `Outer.Inner`) carry their declaring type as a scope, which
+        // getNameAsString() above does not include. Prepend it so the declaring type isn't lost.
+        if (type.getScope().FromOptional<ClassOrInterfaceType>() is { } scope
+            && typeSyntax is SimpleNameSyntax simpleName
+            && GetSyntaxFromType(scope) is NameSyntax scopeName)
+        {
+            return SyntaxFactory.QualifiedName(scopeName, simpleName);
+        }
+
         return typeSyntax;
     }