Generate an 'out' local variable for unmanaged to managed stubs when the value needs to be marshalled out to unmanaged

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedToNativeVTableMethodGenerator.cs

@@ -220,6 +220,8 @@ public BlockSyntax GenerateStubBody(int index, ImmutableArray<FunctionPointerUnm
                 allStatements.Add(MarshallerHelpers.CreateSetLastPInvokeErrorStatement(LastErrorIdentifier));
             }
 
+            allStatements.AddRange(statements.AssignOut);
+
             // Return
             if (!_marshallers.IsManagedVoidReturn)
                 allStatements.Add(ReturnStatement(IdentifierName(_context.GetIdentifiers(_marshallers.ManagedReturnMarshaller.TypeInfo).managed)));

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ComInterfaceDispatchMarshallerFactory.cs

@@ -34,13 +34,22 @@ public ManagedTypeInfo AsNativeType(TypePositionInfo info) =>
                     IsFunctionPointer: false);
             public IEnumerable<StatementSyntax> Generate(TypePositionInfo info, StubCodeContext context)
             {
+                if (context.CurrentStage == StubCodeContext.Stage.AssignOut)
+                {
+                    var assignOut = this.GeneratePointerAssignOut(info, context);
+                    if (assignOut != null)
+                    {
+                        yield return assignOut;
+                    }
+                    yield break;
+                }
+
                 if (context.CurrentStage != StubCodeContext.Stage.Unmarshal)
                 {
                     yield break;
                 }
 
                 var (managed, native) = context.GetIdentifiers(info);
-
                 // <managed> = ComWrappers.ComInterfaceDispatch.GetInstance<<managedType>>(<native>);
                 yield return ExpressionStatement(
                     AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnmanagedToManagedStubGenerator.cs

@@ -65,8 +65,8 @@ public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke)
                 setupStatements.Add(MarshallerHelpers.Declare(PredefinedType(Token(SyntaxKind.BoolKeyword)), InvokeSucceededIdentifier, initializeToDefault: true));
             }
 
-            setupStatements.AddRange(declarations.Initializations);
             setupStatements.AddRange(declarations.Variables);
+            setupStatements.AddRange(declarations.Initializations);
             setupStatements.AddRange(statements.Setup);
 
             List<StatementSyntax> tryStatements = new();
@@ -94,7 +94,6 @@ public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke)
 
             SyntaxList<CatchClauseSyntax> catchClauses = List(statements.ManagedExceptionCatchClauses);
 
-            finallyStatements.AddRange(statements.Cleanup);
             if (finallyStatements.Count > 0)
             {
                 allStatements.Add(
@@ -110,6 +109,9 @@ public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke)
                 allStatements.AddRange(tryStatements);
             }
 
+            allStatements.AddRange(statements.AssignOut);
+            allStatements.AddRange(statements.Cleanup);
+
             // Return
             if (!_marshallers.IsUnmanagedVoidReturn)
                 allStatements.Add(ReturnStatement(IdentifierName(_context.GetIdentifiers(_marshallers.NativeReturnMarshaller.TypeInfo).native)));

src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/PInvokeStubCodeGenerator.cs

@@ -183,6 +183,8 @@ public BlockSyntax GeneratePInvokeBody(string dllImportName)
                 allStatements.Add(MarshallerHelpers.CreateSetLastPInvokeErrorStatement(LastErrorIdentifier));
             }
 
+            allStatements.AddRange(statements.AssignOut);
+
             // Return
             if (!_marshallers.IsManagedVoidReturn)
                 allStatements.Add(ReturnStatement(IdentifierName(_context.GetIdentifiers(_marshallers.ManagedReturnMarshaller.TypeInfo).managed)));

src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs

@@ -22,6 +22,8 @@ public struct GeneratedStatements
         public ImmutableArray<StatementSyntax> NotifyForSuccessfulInvoke { get; init; }
         public ImmutableArray<StatementSyntax> GuaranteedUnmarshal { get; init; }
         public ImmutableArray<StatementSyntax> Cleanup { get; init; }
+        //public ImmutableArray<StatementSyntax> CleanupNativeOut { get; init; }
+        public ImmutableArray<StatementSyntax> AssignOut { get; init; }
 
         public ImmutableArray<CatchClauseSyntax> ManagedExceptionCatchClauses { get; init; }
 
@@ -39,7 +41,9 @@ public static GeneratedStatements Create(BoundGenerators marshallers, StubCodeCo
                 NotifyForSuccessfulInvoke = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.NotifyForSuccessfulInvoke }),
                 GuaranteedUnmarshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.GuaranteedUnmarshal }),
                 Cleanup = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.Cleanup }),
-                ManagedExceptionCatchClauses = GenerateCatchClauseForManagedException(marshallers, context)
+                //CleanupNativeOut = GenerateStatementsForStubContext(marshallers, new MarshalToLocalContext(context with { CurrentStage = StubCodeContext.Stage.Cleanup })),
+                ManagedExceptionCatchClauses = GenerateCatchClauseForManagedException(marshallers, context),
+                AssignOut = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.AssignOut })
             };
         }
         public static GeneratedStatements Create(BoundGenerators marshallers, StubCodeContext context, ExpressionSyntax expressionToInvoke)
@@ -71,7 +75,26 @@ private static ImmutableArray<StatementSyntax> GenerateStatementsForStubContext(
             ImmutableArray<StatementSyntax>.Builder statementsToUpdate = ImmutableArray.CreateBuilder<StatementSyntax>();
             foreach (BoundGenerator marshaller in marshallers.SignatureMarshallers)
             {
-                statementsToUpdate.AddRange(marshaller.Generator.Generate(marshaller.TypeInfo, context));
+                StubCodeContext localContext = context;
+                if (context.CurrentStage is StubCodeContext.Stage.Marshal or StubCodeContext.Stage.AssignOut
+                    && MarshallerHelpers.MarshalsOutToLocal(marshaller.TypeInfo, context))
+                {
+                    localContext = new MarshalToLocalContext(context);
+                }
+                // Right now, MarshalsOutToLocal is the only way we determine if we assign out, so we can return early here for perf
+                if (context.CurrentStage is StubCodeContext.Stage.AssignOut)
+                {
+                    if (!MarshallerHelpers.MarshalsOutToLocal(marshaller.TypeInfo, context))
+                        continue;
+                    else
+                        localContext = new AssignOutContext(context, marshaller.Generator.AsParameter(marshaller.TypeInfo, context).Identifier.ToString());
+                }
+                if (context is MarshalToLocalContext && context.CurrentStage == StubCodeContext.Stage.Cleanup)
+                {
+                    if (!MarshallerHelpers.MarshalsOutToLocal(marshaller.TypeInfo, context))
+                        continue;
+                }
+                statementsToUpdate.AddRange(marshaller.Generator.Generate(marshaller.TypeInfo, localContext));
             }
 
             if (statementsToUpdate.Count > 0)
@@ -164,6 +187,11 @@ private static ImmutableArray<CatchClauseSyntax> GenerateCatchClauseForManagedEx
             catchClauseBuilder.AddRange(
                 managedExceptionMarshaller.Generator.Generate(
                     managedExceptionMarshaller.TypeInfo, context with { CurrentStage = StubCodeContext.Stage.PinnedMarshal }));
+            catchClauseBuilder.AddRange(GenerateStatementsForStubContext(marshallers, new MarshalToLocalContext(context with { CurrentStage = StubCodeContext.Stage.Cleanup })));
+            if (!marshallers.IsUnmanagedVoidReturn)
+            {
+                catchClauseBuilder.Add(ReturnStatement(IdentifierName(context.GetIdentifiers(marshallers.NativeReturnMarshaller.TypeInfo).native)));
+            }
             return ImmutableArray.Create(
                 CatchClause(
                     CatchDeclaration(ParseTypeName(TypeNames.System_Exception), Identifier(managed)),
@@ -185,6 +213,7 @@ private static SyntaxTriviaList GenerateStageTrivia(StubCodeContext.Stage stage)
                 StubCodeContext.Stage.Cleanup => "Perform required cleanup.",
                 StubCodeContext.Stage.NotifyForSuccessfulInvoke => "Keep alive any managed objects that need to stay alive across the call.",
                 StubCodeContext.Stage.GuaranteedUnmarshal => "Convert native data to managed data even in the case of an exception during the non-cleanup phases.",
+                StubCodeContext.Stage.AssignOut => "Assign to parameters",
                 _ => throw new ArgumentOutOfRangeException(nameof(stage))
             };
 

src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ICustomTypeMarshallingStrategyExtensions.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Microsoft.Interop
+{
+    internal static class ICustomTypeMarshallingStrategyExtensions
+    {
+        public static IEnumerable<ExpressionStatementSyntax> GenerateDefaultAssignOutStatement(this ICustomTypeMarshallingStrategy _, TypePositionInfo info, AssignOutContext context)
+        {
+            if (MarshallerHelpers.MarshalsOutToLocal(info, context))
+            {
+                var (_, native) = context.GetIdentifiers(info);
+                return ImmutableArray.Create(MarshallerHelpers.GenerateAssignmentToPointerValue(context.ParameterIdentifier, native));
+            }
+            return ImmutableArray<ExpressionStatementSyntax>.Empty;
+        }
+    }
+}

src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AssignOutContext.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Interop
+{
+    public sealed record AssignOutContext : StubCodeContext
+    {
+        internal StubCodeContext InnerContext { get; init; }
+        public string ParameterIdentifier { get; init; }
+
+        internal AssignOutContext(StubCodeContext inner, string parameterIdentifier)
+        {
+            InnerContext = inner;
+            Debug.Assert(inner.CurrentStage == Stage.AssignOut);
+            CurrentStage = Stage.AssignOut;
+            Direction = inner.Direction;
+            ParentContext = inner.ParentContext;
+            ParameterIdentifier = parameterIdentifier;
+        }
+
+        public override (TargetFramework framework, Version version) GetTargetFramework() => InnerContext.GetTargetFramework();
+
+        public override bool SingleFrameSpansNativeContext => InnerContext.SingleFrameSpansNativeContext;
+
+        public override bool AdditionalTemporaryStateLivesAcrossStages => InnerContext.AdditionalTemporaryStateLivesAcrossStages;
+
+        public override (string managed, string native) GetIdentifiers(TypePositionInfo info)
+            => (InnerContext.GetIdentifiers(info).managed, InnerContext.GetAdditionalIdentifier(info, "out"));
+
+        public override string GetAdditionalIdentifier(TypePositionInfo info, string name) => InnerContext.GetAdditionalIdentifier(info, name);
+    }
+}

src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorFactory.cs

@@ -278,20 +278,20 @@ private ResolvedGenerator CreateCustomNativeTypeMarshaller(TypePositionInfo info
 
                 FreeStrategy freeStrategy = GetFreeStrategy(info, context);
 
-                if (freeStrategy == FreeStrategy.FreeOriginal)
-                {
-                    marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy);
-                }
+                //if (freeStrategy == FreeStrategy.FreeOriginal)
+                //{
+                //    marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy);
+                //}
 
                 if (freeStrategy != FreeStrategy.NoFree && marshallerData.Shape.HasFlag(MarshallerShape.Free))
                 {
                     marshallingStrategy = new StatelessFreeMarshalling(marshallingStrategy, marshallerData.MarshallerType.Syntax);
                 }
 
-                if (freeStrategy == FreeStrategy.FreeOriginal)
-                {
-                    marshallingStrategy = new CleanupOwnedOriginalValueMarshalling(marshallingStrategy);
-                }
+                //if (freeStrategy == FreeStrategy.FreeOriginal)
+                //{
+                //    marshallingStrategy = new CleanupOwnedOriginalValueMarshalling(marshallingStrategy);
+                //}
             }
 
             IMarshallingGenerator marshallingGenerator = new CustomTypeMarshallingGenerator(marshallingStrategy, ByValueMarshalKindSupportDescriptor.Default, marshallerData.Shape.HasFlag(MarshallerShape.StatelessPinnableReference));
@@ -371,19 +371,19 @@ private ResolvedGenerator CreateNativeCollectionMarshaller(
 
                 var freeStrategy = GetFreeStrategy(info, context);
                 IElementsMarshallingCollectionSource collectionSource = new StatefulLinearCollectionSource();
-                ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementInfo, elementMarshaller, unmanagedElementType, collectionSource);
+                ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementInfo, elementMarshaller, unmanagedElementType, collectionSource, nativeType.Syntax, true);
 
-                if (freeStrategy == FreeStrategy.FreeOriginal)
-                {
-                    marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy);
-                }
+                //if (freeStrategy == FreeStrategy.FreeOriginal)
+                //{
+                //    marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy);
+                //}
 
-                marshallingStrategy = new StatefulLinearCollectionMarshalling(marshallingStrategy, marshallerData.Shape, numElementsExpression, elementsMarshalling, freeStrategy != FreeStrategy.NoFree);
+                marshallingStrategy = new StatefulLinearCollectionMarshalling(marshallingStrategy, marshallerData.Shape, numElementsExpression, elementsMarshalling, freeStrategy is not FreeStrategy.NoFree or FreeStrategy.FreeTemp);
 
-                if (freeStrategy == FreeStrategy.FreeOriginal)
-                {
-                    marshallingStrategy = new CleanupOwnedOriginalValueMarshalling(marshallingStrategy);
-                }
+                //if (freeStrategy == FreeStrategy.FreeOriginal)
+                //{
+                //    marshallingStrategy = new CleanupOwnedOriginalValueMarshalling(marshallingStrategy);
+                //}
 
                 if (marshallerData.Shape.HasFlag(MarshallerShape.Free))
                 {
@@ -397,14 +397,14 @@ private ResolvedGenerator CreateNativeCollectionMarshaller(
                 var freeStrategy = GetFreeStrategy(info, context);
 
                 IElementsMarshallingCollectionSource collectionSource = new StatelessLinearCollectionSource(marshallerTypeSyntax);
-                if (freeStrategy == FreeStrategy.FreeOriginal)
-                {
-                    marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy);
-                }
+                //if (freeStrategy == FreeStrategy.FreeOriginal)
+                //{
+                //    marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy);
+                //}
 
-                ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementInfo, elementMarshaller, unmanagedElementType, collectionSource);
+                ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementInfo, elementMarshaller, unmanagedElementType, collectionSource, nativeType.Syntax, false);
 
-                marshallingStrategy = new StatelessLinearCollectionMarshalling(marshallingStrategy, elementsMarshalling, nativeType, marshallerData.Shape, numElementsExpression, freeStrategy != FreeStrategy.NoFree);
+                marshallingStrategy = new StatelessLinearCollectionMarshalling(marshallingStrategy, elementsMarshalling, nativeType, marshallerData.Shape, numElementsExpression, !(freeStrategy is FreeStrategy.NoFree or FreeStrategy.FreeTemp));
 
                 if (marshallerData.Shape.HasFlag(MarshallerShape.CallerAllocatedBuffer))
                 {
@@ -420,10 +420,10 @@ private ResolvedGenerator CreateNativeCollectionMarshaller(
                     marshallingStrategy = new StatelessFreeMarshalling(marshallingStrategy, marshallerTypeSyntax);
                 }
 
-                if (freeStrategy == FreeStrategy.FreeOriginal)
-                {
-                    marshallingStrategy = new CleanupOwnedOriginalValueMarshalling(marshallingStrategy);
-                }
+                //if (freeStrategy == FreeStrategy.FreeOriginal)
+                //{
+                //    marshallingStrategy = new CleanupOwnedOriginalValueMarshalling(marshallingStrategy);
+                //}
             }
 
             ByValueMarshalKindSupportDescriptor byValueMarshalKindSupport;
@@ -467,7 +467,8 @@ private enum FreeStrategy
             /// <summary>
             /// Do not free the unmanaged value, we don't own it.
             /// </summary>
-            NoFree
+            NoFree,
+            FreeTemp
         }
 
         private static FreeStrategy GetFreeStrategy(TypePositionInfo info, StubCodeContext context)
@@ -491,12 +492,16 @@ private static FreeStrategy GetFreeStrategy(TypePositionInfo info, StubCodeConte
             {
                 return FreeStrategy.FreeOriginal;
             }
+            if (MarshallerHelpers.MarshalsOutToLocal(info, context))
+            {
+                return FreeStrategy.FreeTemp;
+            }
 
             // In an unmanaged-to-managed stub, we don't take ownership of the value when it isn't passed by 'ref'.
             return FreeStrategy.NoFree;
         }
 
-        private static ElementsMarshalling CreateElementsMarshalling(CustomTypeMarshallerData marshallerData, TypePositionInfo elementInfo, IMarshallingGenerator elementMarshaller, TypeSyntax unmanagedElementType, IElementsMarshallingCollectionSource collectionSource)
+        private static ElementsMarshalling CreateElementsMarshalling(CustomTypeMarshallerData marshallerData, TypePositionInfo elementInfo, IMarshallingGenerator elementMarshaller, TypeSyntax unmanagedElementType, IElementsMarshallingCollectionSource collectionSource, TypeSyntax parameterPointedToType, bool isStateful)
         {
             ElementsMarshalling elementsMarshalling;
 
@@ -507,7 +512,7 @@ private static ElementsMarshalling CreateElementsMarshalling(CustomTypeMarshalle
             }
             else
             {
-                elementsMarshalling = new NonBlittableElementsMarshalling(unmanagedElementType, elementMarshaller, elementInfo, collectionSource);
+                elementsMarshalling = new NonBlittableElementsMarshalling(unmanagedElementType, elementMarshaller, elementInfo, collectionSource, parameterPointedToType, isStateful);
             }
 
             return elementsMarshalling;

src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshaller.cs

@@ -91,6 +91,10 @@ public IEnumerable<StatementSyntax> Generate(TypePositionInfo info, StubCodeCont
                                 IdentifierName(nativeIdentifier)));
                     }
                     break;
+                case StubCodeContext.Stage.AssignOut:
+                    if (this.GeneratePointerAssignOut(info, context) is { } assignOut)
+                        yield return assignOut;
+                    break;
                 default:
                     break;
             }

src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BoolMarshaller.cs

@@ -92,6 +92,10 @@ public IEnumerable<StatementSyntax> Generate(TypePositionInfo info, StubCodeCont
                                     LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(comparand)))));
                     }
                     break;
+                case StubCodeContext.Stage.AssignOut:
+                    if (this.GeneratePointerAssignOut(info, context) is { } assignOut)
+                        yield return assignOut;
+                    break;
                 default:
                     break;
             }