AssemblyExports correction for ctor with initializer-compatible param

src/TypeShim.Generator.Tests/TypeScript/TypescriptAssemblyExportsRendererTests.cs

@@ -902,4 +902,57 @@ export interface AssemblyExports{
 
         """.Replace("{{tsArrayType}}", tsArrayType));
     }
+
+    [Test]
+    public void TypeScriptInteropInterfaceRenderer_Constructor_WithUserClassWithRequiredPropertyParameterType_HasManagedObjectOrObjectType()
+    {
+        SyntaxTree userClass = CSharpSyntaxTree.ParseText("""
+            using System;
+            using System.Threading.Tasks;
+            namespace N1;
+            [TSExport]
+            public class UserClass
+            {
+                public int Id { get; init; }
+            }
+        """);
+
+        SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText("""
+            using System;
+            using System.Threading.Tasks;
+            namespace N1;
+            [TSExport]
+            public class C1(UserClass uc)
+            {
+                public void DoStuff(UserClass u) {}
+            }
+        """);
+
+        SymbolExtractor symbolExtractor = new([CSharpFileInfo.Create(syntaxTree), CSharpFileInfo.Create(userClass)], TestFixture.TargetingPackRefDir);
+        List<INamedTypeSymbol> exportedClasses = [.. symbolExtractor.ExtractAllExportedSymbols()];
+        Assert.That(exportedClasses, Has.Count.EqualTo(2));
+        INamedTypeSymbol classSymbol = exportedClasses[0];
+        INamedTypeSymbol userClassSymbol = exportedClasses[1];
+
+        InteropTypeInfoCache typeCache = new();
+        ClassInfo classInfo = new ClassInfoBuilder(classSymbol, typeCache).Build();
+        ClassInfo userClassInfo = new ClassInfoBuilder(userClassSymbol, typeCache).Build();
+
+        ModuleHierarchyInfo hierarchyInfo = ModuleHierarchyInfo.FromClasses([classInfo]); //deliberate omit userClassInfo to reduce noise in baseline
+        RenderContext renderCtx = new(null, [classInfo, userClassInfo], RenderOptions.TypeScript);
+        new TypescriptAssemblyExportsRenderer(hierarchyInfo, renderCtx).Render();
+
+        AssertEx.EqualOrDiff(renderCtx.ToString(), """
+// TypeShim generated TypeScript module exports interface
+export interface AssemblyExports{
+  N1: {
+    C1Interop: {
+      ctor(uc: ManagedObject | object): ManagedObject;
+      DoStuff(instance: ManagedObject, u: ManagedObject | object): void;
+    };
+  };
+}
+
+""");
+    }
 }

src/TypeShim.Generator/CSharp/CSharpTypeConversionRenderer.cs

@@ -58,7 +58,7 @@ private DeferredExpressionRenderer RenderTypeDownConversion(InteropTypeInfo type
     internal DeferredExpressionRenderer RenderReturnTypeConversion(InteropTypeInfo returnType, DeferredExpressionRenderer valueExpressionRenderer)
     {
         if (!returnType.RequiresTypeConversion)
-            return valueExpressionRenderer; // DeferredExpressionRenderer.From(() => _ctx.Append(valueExpression));
+            return valueExpressionRenderer;
 
         if (returnType is { IsTaskType: true, TypeArgument.RequiresTypeConversion: true }) // Handle Task<T>
         {

src/TypeShim.Generator/Parsing/ConstructorInfo.cs

@@ -19,16 +19,4 @@ internal MethodParameterInfo[] GetParametersIncludingInitializerObject()
         }
         return Parameters;
     }
-
-    internal ConstructorInfo WithInteropTypeInfo()
-    {
-        return new ConstructorInfo()
-        {
-            Name = Name,
-            Parameters = [.. Parameters.Select(p => p.WithInteropTypeInfo())],
-            InitializerObject = InitializerObject?.WithInteropTypeInfo(),
-            MemberInitializers = [.. MemberInitializers.Select(p => p.WithInteropTypeInfo())],
-            Type = Type.AsInteropTypeInfo(),
-        };
-    }
 }

src/TypeShim.Generator/Parsing/MethodInfo.cs

@@ -23,18 +23,6 @@ public MethodInfo WithoutInstanceParameter()
         };
     }
 
-    public MethodInfo WithInteropTypeInfo()
-    {
-        return new MethodInfo
-        {
-            IsStatic = this.IsStatic,
-            Name = this.Name,
-            Parameters = [.. this.Parameters.Select(p => p.WithInteropTypeInfo())],
-            ReturnType = this.ReturnType.AsInteropTypeInfo(),
-            Comment = this.Comment,
-        };
-    }
-
     internal bool MatchesDisposeSignature()
     {
         return Name == "Dispose" && !Parameters.Any(p => !p.IsInjectedInstanceParameter) && ReturnType.ManagedType == KnownManagedType.Void;

src/TypeShim.Generator/Parsing/MethodParameterInfo.cs

@@ -5,14 +5,4 @@ internal class MethodParameterInfo
     internal required string Name { get; init; }
     internal required bool IsInjectedInstanceParameter { get; init; }
     internal required InteropTypeInfo Type { get; init; }
-
-    internal MethodParameterInfo WithInteropTypeInfo()
-    {
-        return new MethodParameterInfo
-        {
-            Name = this.Name,
-            IsInjectedInstanceParameter = this.IsInjectedInstanceParameter,
-            Type = Type.AsInteropTypeInfo(),
-        };
-    }
 }

src/TypeShim.Generator/Parsing/PropertyInfo.cs

@@ -13,19 +13,4 @@ internal sealed class PropertyInfo
     internal required MethodInfo? InitMethod { get; init; }
 
     internal required CommentInfo? Comment { get; init; }
-
-    public PropertyInfo WithInteropTypeInfo()
-    {
-        return new PropertyInfo
-        {
-            Name = this.Name,
-            IsStatic = this.IsStatic,
-            IsRequired = this.IsRequired,
-            Type = this.Type.AsInteropTypeInfo(),
-            GetMethod = this.GetMethod.WithInteropTypeInfo(),
-            SetMethod = this.SetMethod?.WithInteropTypeInfo(),
-            InitMethod = this.InitMethod?.WithInteropTypeInfo(),
-            Comment = this.Comment,
-        };
-    }
 }

src/TypeShim.Generator/Typescript/TypeScriptMethodRenderer.cs

@@ -120,7 +120,7 @@ private void RenderParameterList(IEnumerable<MethodParameterInfo> parameterInfos
             ctx.Append(parameterInfo.Name).Append(": ");
 
             bool isDelegate = parameterInfo.Type.IsDelegateType() || (parameterInfo.Type.IsNullableType && parameterInfo.Type.TypeArgument!.IsDelegateType());
-            TypeShimSymbolType returnSymbolType = parameterInfo.Type is { RequiresTypeConversion: true, SupportsTypeConversion: true } && !isDelegate
+            TypeShimSymbolType returnSymbolType = !isDelegate && parameterInfo.Type is { RequiresTypeConversion: true, SupportsTypeConversion: true }
                 ? TypeShimSymbolType.ProxyInitializerUnion
                 : TypeShimSymbolType.None;
             TypeScriptSymbolNameRenderer.Render(parameterInfo.Type, ctx, returnSymbolType, parameterSymbolType: TypeShimSymbolType.Proxy, interop: false);

src/TypeShim.Generator/Typescript/TypescriptAssemblyExportsRenderer.cs

@@ -46,7 +46,6 @@ private void RenderClassInteropMethods(ClassInfo classInfo)
     {
         if (classInfo.Constructor is ConstructorInfo constructorInfo)
         {
-            constructorInfo = constructorInfo.WithInteropTypeInfo();
             RenderInteropMethodSignature(constructorInfo.Name, constructorInfo.GetParametersIncludingInitializerObject(), constructorInfo.Type);
         }
         foreach (MethodInfo methodInfo in GetAllMethods(classInfo))