Use the scoped keyword to significantly simplify the caller-allocated-buffer logic for stateful marshallers while also increasing safety/keeping us from shooting ourselves in the foot with lifetimes.

PR feedback

Use the official ScopedKeyword API

Author: jkoritzinsky

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Read.cs

@@ -28,7 +28,10 @@ internal sealed partial class TarHeader
             archiveStream.ReadExactly(buffer);
 
             TarHeader? header = TryReadAttributes(initialFormat, buffer);
-            header?.ProcessDataBlock(archiveStream, copyData);
+            if (header != null)
+            {
+                header.ProcessDataBlock(archiveStream, copyData);
+            }
 
             return header;
         }

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

@@ -15,7 +15,17 @@ namespace Microsoft.Interop
     /// </summary>
     public abstract record ManagedTypeInfo(string FullTypeName, string DiagnosticFormattedName)
     {
-        public TypeSyntax Syntax { get; } = SyntaxFactory.ParseTypeName(FullTypeName);
+        private TypeSyntax? _syntax;
+        public TypeSyntax Syntax => _syntax ??= SyntaxFactory.ParseTypeName(FullTypeName);
+
+        protected ManagedTypeInfo(ManagedTypeInfo original)
+        {
+            FullTypeName = original.FullTypeName;
+            DiagnosticFormattedName = original.DiagnosticFormattedName;
+            // Explicitly don't initialize _syntax here. We want Syntax to be recalculated
+            // from the results of a with-expression, which assigns the new property values
+            // to the result of this constructor.
+        }
 
         public static ManagedTypeInfo CreateTypeInfoForTypeSymbol(ITypeSymbol type)
         {

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

@@ -235,7 +235,7 @@ private IMarshallingGenerator CreateCustomNativeTypeMarshaller(TypePositionInfo
             ICustomTypeMarshallingStrategy marshallingStrategy;
             if (marshallerData.HasState)
             {
-                marshallingStrategy = new StatefulValueMarshalling(marshallerData.MarshallerType.Syntax, marshallerData.NativeType.Syntax, marshallerData.Shape);
+                marshallingStrategy = new StatefulValueMarshalling(marshallerData.MarshallerType, marshallerData.NativeType.Syntax, marshallerData.Shape);
                 if (marshallerData.Shape.HasFlag(MarshallerShape.CallerAllocatedBuffer))
                     marshallingStrategy = new StatefulCallerAllocatedBufferMarshalling(marshallingStrategy, marshallerData.MarshallerType.Syntax, marshallerData.BufferElementType.Syntax);
             }
@@ -283,16 +283,21 @@ private IMarshallingGenerator CreateNativeCollectionMarshaller(
 
             // Insert the unmanaged element type into the marshaller type
             TypeSyntax unmanagedElementType = elementMarshaller.AsNativeType(elementInfo).GetCompatibleGenericTypeParameterSyntax();
-            TypeSyntax marshallerTypeSyntax = marshallerData.MarshallerType.Syntax;
-            marshallerTypeSyntax = ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax(marshallerTypeSyntax, marshalInfo, unmanagedElementType);
+            ManagedTypeInfo marshallerType = marshallerData.MarshallerType;
+            TypeSyntax marshallerTypeSyntax = ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax(marshallerType.Syntax, marshalInfo, unmanagedElementType);
+            marshallerType = marshallerType with
+            {
+                FullTypeName = marshallerTypeSyntax.ToString(),
+                DiagnosticFormattedName = marshallerTypeSyntax.ToString(),
+            };
             TypeSyntax nativeTypeSyntax = ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax(marshallerData.NativeType.Syntax, marshalInfo, unmanagedElementType);
 
             ICustomTypeMarshallingStrategy marshallingStrategy;
             bool elementIsBlittable = elementMarshaller is BlittableMarshaller;
 
             if (marshallerData.HasState)
             {
-                marshallingStrategy = new StatefulValueMarshalling(marshallerTypeSyntax, nativeTypeSyntax, marshallerData.Shape);
+                marshallingStrategy = new StatefulValueMarshalling(marshallerType, nativeTypeSyntax, marshallerData.Shape);
                 if (marshallerData.Shape.HasFlag(MarshallerShape.CallerAllocatedBuffer))
                 {
                     // Check if the buffer element type is actually the unmanaged element type

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

@@ -14,13 +14,13 @@ namespace Microsoft.Interop
     internal sealed class StatefulValueMarshalling : ICustomTypeMarshallingStrategy
     {
         internal const string MarshallerIdentifier = "marshaller";
-        private readonly TypeSyntax _marshallerTypeSyntax;
+        private readonly ManagedTypeInfo _marshallerType;
         private readonly TypeSyntax _nativeTypeSyntax;
         private readonly MarshallerShape _shape;
 
-        public StatefulValueMarshalling(TypeSyntax marshallerTypeSyntax, TypeSyntax nativeTypeSyntax, MarshallerShape shape)
+        public StatefulValueMarshalling(ManagedTypeInfo marshallerType, TypeSyntax nativeTypeSyntax, MarshallerShape shape)
         {
-            _marshallerTypeSyntax = marshallerTypeSyntax;
+            _marshallerType = marshallerType;
             _nativeTypeSyntax = nativeTypeSyntax;
             _shape = shape;
         }
@@ -140,10 +140,23 @@ public IEnumerable<StatementSyntax> GenerateUnmarshalCaptureStatements(TypePosit
         public IEnumerable<StatementSyntax> GenerateSetupStatements(TypePositionInfo info, StubCodeContext context)
         {
             // <marshaller> = new();
-            yield return MarshallerHelpers.Declare(
-                _marshallerTypeSyntax,
+            LocalDeclarationStatementSyntax declaration = MarshallerHelpers.Declare(
+                _marshallerType.Syntax,
                 context.GetAdditionalIdentifier(info, MarshallerIdentifier),
                 ImplicitObjectCreationExpression(ArgumentList(), initializer: null));
+
+            // For byref-like marshaller types, we'll mark them as scoped.
+            // Byref-like types can capture references, so by default the compiler has to worry that
+            // they could enable those references to escape the current stack frame.
+            // In particular, this can interact poorly with the caller-allocated-buffer marshalling
+            // support and make the simple `marshaller.FromManaged(managed, stackalloc X[i])` expression
+            // illegal. Mark the marshaller type as scoped so the compiler knows that it won't escape.
+            if (_marshallerType is ValueTypeInfo { IsByRefLike: true })
+            {
+                declaration = declaration.AddModifiers(Token(SyntaxKind.ScopedKeyword));
+            }
+
+            yield return declaration;
         }
 
         public IEnumerable<StatementSyntax> GeneratePinStatements(TypePositionInfo info, StubCodeContext context)
@@ -218,28 +231,9 @@ public IEnumerable<StatementSyntax> GenerateMarshalStatements(TypePositionInfo i
 
             IEnumerable<StatementSyntax> GenerateCallerAllocatedBufferMarshalStatements()
             {
-                // TODO: Update once we can consume the scoped keword. We should be able to simplify this once we get that API.
-                string stackPtrIdentifier = context.GetAdditionalIdentifier(info, "stackptr");
-                // <bufferElementType>* <managedIdentifier>__stackptr = stackalloc <bufferElementType>[<_bufferSize>];
-                yield return LocalDeclarationStatement(
-                VariableDeclaration(
-                    PointerType(_bufferElementType),
-                    SingletonSeparatedList(
-                        VariableDeclarator(stackPtrIdentifier)
-                            .WithInitializer(EqualsValueClause(
-                                StackAllocArrayCreationExpression(
-                                        ArrayType(
-                                            _bufferElementType,
-                                            SingletonList(ArrayRankSpecifier(SingletonSeparatedList<ExpressionSyntax>(
-                                                MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
-                                                    _marshallerType,
-                                                    IdentifierName(ShapeMemberNames.BufferSize))
-                                            ))))))))));
-
-
                 (string managedIdentifier, _) = context.GetIdentifiers(info);
 
-                // <marshaller>.FromManaged(<managedIdentifier>, new Span<bufferElementType>(<stackPtrIdentifier>, <marshallerType>.BufferSize));
+                // <marshaller>.FromManaged(<managedIdentifier>, stackalloc <bufferElementType>[<marshallerType>.BufferSize]);
                 yield return ExpressionStatement(
                     InvocationExpression(
                         MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
@@ -249,19 +243,13 @@ IEnumerable<StatementSyntax> GenerateCallerAllocatedBufferMarshalStatements()
                             new[]
                             {
                                 Argument(IdentifierName(managedIdentifier)),
-                                Argument(
-                                    ObjectCreationExpression(
-                                        GenericName(Identifier(TypeNames.System_Span),
-                                            TypeArgumentList(SingletonSeparatedList(
-                                                _bufferElementType))))
-                                    .WithArgumentList(
-                                        ArgumentList(SeparatedList(new ArgumentSyntax[]
-                                        {
-                                            Argument(IdentifierName(stackPtrIdentifier)),
-                                            Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
+                                Argument(StackAllocArrayCreationExpression(
+                                        ArrayType(
+                                            _bufferElementType,
+                                            SingletonList(ArrayRankSpecifier(SingletonSeparatedList<ExpressionSyntax>(
+                                                MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                     _marshallerType,
-                                                    IdentifierName(ShapeMemberNames.BufferSize)))
-                                        }))))
+                                                    IdentifierName(ShapeMemberNames.BufferSize))))))))
                             }))));
             }
         }

src/libraries/System.Text.RegularExpressions/gen/UpgradeToGeneratedRegexCodeFixer.cs

@@ -100,7 +100,10 @@ private static async Task<Document> ConvertToSourceGenerator(Document document,
             // Get the parent type declaration so that we can inspect its methods as well as check if we need to add the partial keyword.
             SyntaxNode? typeDeclarationOrCompilationUnit = nodeToFix.Ancestors().OfType<TypeDeclarationSyntax>().FirstOrDefault();
 
-            typeDeclarationOrCompilationUnit ??= await nodeToFix.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+            if (typeDeclarationOrCompilationUnit is null)
+            {
+                typeDeclarationOrCompilationUnit = await nodeToFix.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+            }
 
             // Calculate what name should be used for the generated static partial method
             string methodName = DefaultRegexMethodName;