Extensions: round-trip attributes on type parameters

Julien Couvreur · Julien Couvreur · commit 368c5b3d0843 · 2025-08-25T15:09:14.000-07:00
diff --git a/docs/contributing/Compiler Test Plan.md b/docs/contributing/Compiler Test Plan.md
@@ -129,6 +129,7 @@ This document provides guidance for thinking about language interactions and tes
 - COM interop
 - modopt and modreq
 - CompilerFeatureRequiredAttribute
+- CompilerLoweringPreserveAttribute
 - ref assemblies
 - extern alias
 - UnmanagedCallersOnly
diff --git a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/SynthesizedClosureMethod.cs b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/SynthesizedClosureMethod.cs
@@ -60,6 +60,7 @@ internal SynthesizedClosureMethod(
                     typeMap = lambdaFrame.TypeMap.WithAlphaRename(
                         TypeMap.ConcatMethodTypeParameters(originalMethod, stopAt: lambdaFrame.OriginalContainingMethodOpt),
                         this,
+                        propagateAttributes: false,
                         out typeParameters);
                     break;
                 case ClosureKind.ThisOnly: // all type parameters on method
@@ -68,6 +69,7 @@ internal SynthesizedClosureMethod(
                     typeMap = TypeMap.Empty.WithAlphaRename(
                         TypeMap.ConcatMethodTypeParameters(originalMethod, stopAt: null),
                         this,
+                        propagateAttributes: false,
                         out typeParameters);
                     break;
                 default:
diff --git a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
@@ -442,7 +442,7 @@ internal BaseMethodWrapperSymbol(NamedTypeSymbol containingType, MethodSymbol me
                 }
                 else
                 {
-                    typeMap = typeMap.WithAlphaRename(methodBeingWrapped, this, out typeParameters);
+                    typeMap = typeMap.WithAlphaRename(methodBeingWrapped, this, propagateAttributes: false, out typeParameters);
                 }
 
                 AssignTypeMapAndTypeParameters(typeMap, typeParameters);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenLambdaOrLocalFunctionSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenLambdaOrLocalFunctionSymbol.cs
@@ -13,7 +13,7 @@ internal sealed class RewrittenLambdaOrLocalFunctionSymbol : RewrittenMethodSymb
         private readonly RewrittenMethodSymbol _containingMethod;
 
         public RewrittenLambdaOrLocalFunctionSymbol(MethodSymbol lambdaOrLocalFunctionSymbol, RewrittenMethodSymbol containingMethod)
-            : base(lambdaOrLocalFunctionSymbol, containingMethod.TypeMap, lambdaOrLocalFunctionSymbol.TypeParameters)
+            : base(lambdaOrLocalFunctionSymbol, containingMethod.TypeMap, lambdaOrLocalFunctionSymbol.TypeParameters, propagateTypeParameterAttributes: false)
         {
             Debug.Assert(lambdaOrLocalFunctionSymbol.AssociatedSymbol is null);
             Debug.Assert(lambdaOrLocalFunctionSymbol.TryGetThisParameter(out var thisParameter) && thisParameter is null);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenMethodSymbol.cs
@@ -15,14 +15,13 @@ internal abstract class RewrittenMethodSymbol : WrappedMethodSymbol
         private readonly ImmutableArray<TypeParameterSymbol> _typeParameters;
         private ImmutableArray<ParameterSymbol> _lazyParameters;
 
-        protected RewrittenMethodSymbol(MethodSymbol originalMethod, TypeMap typeMap, ImmutableArray<TypeParameterSymbol> typeParametersToAlphaRename)
+        protected RewrittenMethodSymbol(MethodSymbol originalMethod, TypeMap typeMap, ImmutableArray<TypeParameterSymbol> typeParametersToAlphaRename, bool propagateTypeParameterAttributes)
         {
             Debug.Assert(originalMethod.IsDefinition);
             Debug.Assert(originalMethod.ExplicitInterfaceImplementations.IsEmpty);
 
             _originalMethod = originalMethod;
-            // Tracked by https://github.com/dotnet/roslyn/issues/78963 : Are we creating type parameters with the right emit behavior? Attributes, etc.
-            _typeMap = typeMap.WithAlphaRename(typeParametersToAlphaRename, this, out _typeParameters);
+            _typeMap = typeMap.WithAlphaRename(typeParametersToAlphaRename, this, propagateAttributes: propagateTypeParameterAttributes, out _typeParameters);
         }
 
         public TypeMap TypeMap => _typeMap;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs
@@ -19,13 +19,10 @@ internal sealed class SourceExtensionImplementationMethodSymbol : RewrittenMetho
         private StrongBox<byte?>? lazyNullableContext;
 
         public SourceExtensionImplementationMethodSymbol(MethodSymbol sourceMethod)
-            : base(sourceMethod, TypeMap.Empty, sourceMethod.ContainingType.TypeParameters.Concat(sourceMethod.TypeParameters))
+            : base(sourceMethod, TypeMap.Empty, sourceMethod.ContainingType.TypeParameters.Concat(sourceMethod.TypeParameters), propagateTypeParameterAttributes: true)
         {
             Debug.Assert(sourceMethod.GetIsNewExtensionMember());
             Debug.Assert(sourceMethod.IsStatic || sourceMethod.ContainingType.ExtensionParameter is not null);
-
-            // Tracked by https://github.com/dotnet/roslyn/issues/78963 : Are we creating type parameters with the right emit behavior? Attributes, etc.
-            //            Also, they should be IsImplicitlyDeclared
         }
 
         public override int Arity => TypeParameters.Length;
diff --git a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
@@ -97,7 +97,7 @@ private ReducedExtensionMethodSymbol(MethodSymbol reducedFrom)
             Debug.Assert(reducedFrom.ParameterCount > 0);
 
             _reducedFrom = reducedFrom;
-            _typeMap = TypeMap.Empty.WithAlphaRename(reducedFrom, this, out _typeParameters);
+            _typeMap = TypeMap.Empty.WithAlphaRename(reducedFrom, this, propagateAttributes: false, out _typeParameters);
             _typeArguments = _typeMap.SubstituteTypes(reducedFrom.TypeArgumentsWithAnnotations);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/SubstitutedMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SubstitutedMethodSymbol.cs
@@ -109,7 +109,7 @@ private void EnsureMapAndTypeParameters()
             Debug.Assert(ReferenceEquals(_constructedFrom, this));
 
             // We're creating a new unconstructed Method from another; alpha-rename type parameters.
-            var newMap = _inputMap.WithAlphaRename(this.OriginalDefinition, this, out typeParameters);
+            var newMap = _inputMap.WithAlphaRename(this.OriginalDefinition, this, propagateAttributes: false, out typeParameters);
 
             var prevMap = Interlocked.CompareExchange(ref _lazyMap, newMap, null);
             if (prevMap != null)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedContainer.cs
@@ -29,7 +29,7 @@ protected SynthesizedContainer(string name, ImmutableArray<TypeParameterSymbol>
             Debug.Assert(name != null);
             Name = name;
             _constructedFromTypeParameters = typeParametersToAlphaRename;
-            TypeMap = TypeMap.Empty.WithAlphaRename(typeParametersToAlphaRename, this, out _typeParameters);
+            TypeMap = TypeMap.Empty.WithAlphaRename(typeParametersToAlphaRename, this, propagateAttributes: false, out _typeParameters);
         }
 
         protected SynthesizedContainer(string name)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedImplementationMethod.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedImplementationMethod.cs
@@ -43,7 +43,7 @@ public SynthesizedImplementationMethod(
 
             // alpha-rename to get the implementation's type parameters
             var typeMap = interfaceMethod.ContainingType.TypeSubstitution ?? TypeMap.Empty;
-            typeMap.WithAlphaRename(interfaceMethod, this, out _typeParameters);
+            typeMap.WithAlphaRename(interfaceMethod, this, propagateAttributes: false, out _typeParameters);
 
             _interfaceMethod = interfaceMethod.ConstructIfGeneric(TypeArgumentsWithAnnotations);
             _parameters = SynthesizedParameterSymbol.DeriveParameters(_interfaceMethod, this);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedSubstitutedTypeParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedSubstitutedTypeParameterSymbol.cs
@@ -16,13 +16,21 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
     /// </summary>
     internal sealed class SynthesizedSubstitutedTypeParameterSymbol : SubstitutedTypeParameterSymbol
     {
-        public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal)
+        /// <summary>
+        /// Indicates whether the synthesized type parameter should keep the original attributes by default
+        /// (ie. when the attribute definition doesn't have CompilerLoweringPreserveAttribute)
+        /// </summary>
+        private readonly bool _propagateAttributes;
+
+        public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal, bool propagateAttributes)
             : base(owner, map, substitutedFrom, ordinal)
         {
             Debug.Assert(this.TypeParameterKind == (ContainingSymbol is MethodSymbol ? TypeParameterKind.Method :
                                                    (ContainingSymbol is NamedTypeSymbol ? TypeParameterKind.Type :
                                                    TypeParameterKind.Cref)),
                          $"Container is {ContainingSymbol?.Kind}, TypeParameterKind is {this.TypeParameterKind}");
+
+            _propagateAttributes = propagateAttributes;
         }
 
         public override bool IsImplicitlyDeclared
@@ -38,13 +46,20 @@ internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, r
                 _underlyingTypeParameter.OriginalDefinition is SourceMethodTypeParameterSymbol definition &&
                 ContainingSymbol.ContainingModule == definition.ContainingModule)
             {
-                foreach (CSharpAttributeData attr in definition.GetAttributes())
+                if (!_propagateAttributes)
                 {
-                    if (attr.AttributeClass is { HasCompilerLoweringPreserveAttribute: true })
+                    foreach (CSharpAttributeData attr in definition.GetAttributes())
                     {
-                        AddSynthesizedAttribute(ref attributes, attr);
+                        if (attr.AttributeClass is { HasCompilerLoweringPreserveAttribute: true })
+                        {
+                            AddSynthesizedAttribute(ref attributes, attr);
+                        }
                     }
                 }
+                else
+                {
+                    Debug.Assert(false);
+                }
             }
 
             base.AddSynthesizedAttributes(moduleBuilder, ref attributes);
@@ -57,6 +72,11 @@ _underlyingTypeParameter.OriginalDefinition is SourceMethodTypeParameterSymbol d
 
         public override ImmutableArray<CSharpAttributeData> GetAttributes()
         {
+            if (_propagateAttributes)
+            {
+                return _underlyingTypeParameter.GetAttributes();
+            }
+
             if (ContainingSymbol is SynthesizedMethodBaseSymbol { InheritsBaseMethodAttributes: true })
             {
                 return _underlyingTypeParameter.GetAttributes();
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeMap.cs b/src/Compilers/CSharp/Portable/Symbols/TypeMap.cs
@@ -99,7 +99,7 @@ public static TypeMap Empty
             }
         }
 
-        internal TypeMap WithAlphaRename(ImmutableArray<TypeParameterSymbol> oldTypeParameters, Symbol newOwner, out ImmutableArray<TypeParameterSymbol> newTypeParameters)
+        internal TypeMap WithAlphaRename(ImmutableArray<TypeParameterSymbol> oldTypeParameters, Symbol newOwner, bool propagateAttributes, out ImmutableArray<TypeParameterSymbol> newTypeParameters)
         {
             if (oldTypeParameters.Length == 0)
             {
@@ -124,7 +124,7 @@ internal TypeMap WithAlphaRename(ImmutableArray<TypeParameterSymbol> oldTypePara
             foreach (var tp in oldTypeParameters)
             {
                 var newTp = synthesized ?
-                    new SynthesizedSubstitutedTypeParameterSymbol(newOwner, result, tp, ordinal) :
+                    new SynthesizedSubstitutedTypeParameterSymbol(newOwner, result, tp, ordinal, propagateAttributes) :
                     new SubstitutedTypeParameterSymbol(newOwner, result, tp, ordinal);
                 result.Mapping.Add(tp, TypeWithAnnotations.Create(newTp));
                 newTypeParametersBuilder.Add(newTp);
@@ -138,13 +138,13 @@ internal TypeMap WithAlphaRename(ImmutableArray<TypeParameterSymbol> oldTypePara
         internal TypeMap WithAlphaRename(NamedTypeSymbol oldOwner, NamedTypeSymbol newOwner, out ImmutableArray<TypeParameterSymbol> newTypeParameters)
         {
             Debug.Assert(TypeSymbol.Equals(oldOwner.ConstructedFrom, oldOwner, TypeCompareKind.ConsiderEverything2));
-            return WithAlphaRename(oldOwner.OriginalDefinition.TypeParameters, newOwner, out newTypeParameters);
+            return WithAlphaRename(oldOwner.OriginalDefinition.TypeParameters, newOwner, propagateAttributes: false, out newTypeParameters);
         }
 
-        internal TypeMap WithAlphaRename(MethodSymbol oldOwner, Symbol newOwner, out ImmutableArray<TypeParameterSymbol> newTypeParameters)
+        internal TypeMap WithAlphaRename(MethodSymbol oldOwner, Symbol newOwner, bool propagateAttributes, out ImmutableArray<TypeParameterSymbol> newTypeParameters)
         {
             Debug.Assert(oldOwner.ConstructedFrom == oldOwner);
-            return WithAlphaRename(oldOwner.OriginalDefinition.TypeParameters, newOwner, out newTypeParameters);
+            return WithAlphaRename(oldOwner.OriginalDefinition.TypeParameters, newOwner, propagateAttributes: propagateAttributes, out newTypeParameters);
         }
 
         internal static ImmutableArray<TypeParameterSymbol> ConcatMethodTypeParameters(MethodSymbol oldOwner, MethodSymbol stopAt)
diff --git a/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs b/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EECompilationContextMethod.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EECompilationContextMethod.cs

Original file line number	Diff line number	Diff line change
`@@ -442,7 +442,7 @@ internal BaseMethodWrapperSymbol(NamedTypeSymbol containingType, MethodSymbol me`
`442`	`442`	`}`
`443`	`443`	`else`
`444`	`444`	`{`
`445`		`- typeMap = typeMap.WithAlphaRename(methodBeingWrapped, this, out typeParameters);`
	`445`	`+ typeMap = typeMap.WithAlphaRename(methodBeingWrapped, this, propagateAttributes: false, out typeParameters);`
`446`	`446`	`}`
`447`	`447`
`448`	`448`	`AssignTypeMapAndTypeParameters(typeMap, typeParameters);`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ internal sealed class RewrittenLambdaOrLocalFunctionSymbol : RewrittenMethodSymb`
`13`	`13`	`private readonly RewrittenMethodSymbol _containingMethod;`
`14`	`14`
`15`	`15`	`public RewrittenLambdaOrLocalFunctionSymbol(MethodSymbol lambdaOrLocalFunctionSymbol, RewrittenMethodSymbol containingMethod)`
`16`		`- : base(lambdaOrLocalFunctionSymbol, containingMethod.TypeMap, lambdaOrLocalFunctionSymbol.TypeParameters)`
	`16`	`+ : base(lambdaOrLocalFunctionSymbol, containingMethod.TypeMap, lambdaOrLocalFunctionSymbol.TypeParameters, propagateTypeParameterAttributes: false)`
`17`	`17`	`{`
`18`	`18`	`Debug.Assert(lambdaOrLocalFunctionSymbol.AssociatedSymbol is null);`
`19`	`19`	`Debug.Assert(lambdaOrLocalFunctionSymbol.TryGetThisParameter(out var thisParameter) && thisParameter is null);`
Original file line number	Diff line number	Diff line change
`@@ -15,14 +15,13 @@ internal abstract class RewrittenMethodSymbol : WrappedMethodSymbol`
`15`	`15`	`private readonly ImmutableArray<TypeParameterSymbol> _typeParameters;`
`16`	`16`	`private ImmutableArray<ParameterSymbol> _lazyParameters;`
`17`	`17`
`18`		`- protected RewrittenMethodSymbol(MethodSymbol originalMethod, TypeMap typeMap, ImmutableArray<TypeParameterSymbol> typeParametersToAlphaRename)`
	`18`	`+ protected RewrittenMethodSymbol(MethodSymbol originalMethod, TypeMap typeMap, ImmutableArray<TypeParameterSymbol> typeParametersToAlphaRename, bool propagateTypeParameterAttributes)`
`19`	`19`	`{`
`20`	`20`	`Debug.Assert(originalMethod.IsDefinition);`
`21`	`21`	`Debug.Assert(originalMethod.ExplicitInterfaceImplementations.IsEmpty);`
`22`	`22`
`23`	`23`	`_originalMethod = originalMethod;`
`24`		`- // Tracked by https://github.com/dotnet/roslyn/issues/78963 : Are we creating type parameters with the right emit behavior? Attributes, etc.`
`25`		`- _typeMap = typeMap.WithAlphaRename(typeParametersToAlphaRename, this, out _typeParameters);`
	`24`	`+ _typeMap = typeMap.WithAlphaRename(typeParametersToAlphaRename, this, propagateAttributes: propagateTypeParameterAttributes, out _typeParameters);`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`public TypeMap TypeMap => _typeMap;`
Original file line number	Diff line number	Diff line change
`@@ -19,13 +19,10 @@ internal sealed class SourceExtensionImplementationMethodSymbol : RewrittenMetho`
`19`	`19`	`private StrongBox<byte?>? lazyNullableContext;`
`20`	`20`
`21`	`21`	`public SourceExtensionImplementationMethodSymbol(MethodSymbol sourceMethod)`
`22`		`- : base(sourceMethod, TypeMap.Empty, sourceMethod.ContainingType.TypeParameters.Concat(sourceMethod.TypeParameters))`
	`22`	`+ : base(sourceMethod, TypeMap.Empty, sourceMethod.ContainingType.TypeParameters.Concat(sourceMethod.TypeParameters), propagateTypeParameterAttributes: true)`
`23`	`23`	`{`
`24`	`24`	`Debug.Assert(sourceMethod.GetIsNewExtensionMember());`
`25`	`25`	`Debug.Assert(sourceMethod.IsStatic \|\| sourceMethod.ContainingType.ExtensionParameter is not null);`
`26`		`-`
`27`		`- // Tracked by https://github.com/dotnet/roslyn/issues/78963 : Are we creating type parameters with the right emit behavior? Attributes, etc.`
`28`		`- // Also, they should be IsImplicitlyDeclared`
`29`	`26`	`}`
`30`	`27`
`31`	`28`	`public override int Arity => TypeParameters.Length;`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ private ReducedExtensionMethodSymbol(MethodSymbol reducedFrom)`
`97`	`97`	`Debug.Assert(reducedFrom.ParameterCount > 0);`
`98`	`98`
`99`	`99`	`_reducedFrom = reducedFrom;`
`100`		`- _typeMap = TypeMap.Empty.WithAlphaRename(reducedFrom, this, out _typeParameters);`
	`100`	`+ _typeMap = TypeMap.Empty.WithAlphaRename(reducedFrom, this, propagateAttributes: false, out _typeParameters);`
`101`	`101`	`_typeArguments = _typeMap.SubstituteTypes(reducedFrom.TypeArgumentsWithAnnotations);`
`102`	`102`	`}`
`103`	`103`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ protected SynthesizedContainer(string name, ImmutableArray<TypeParameterSymbol>`
`29`	`29`	`Debug.Assert(name != null);`
`30`	`30`	`Name = name;`
`31`	`31`	`_constructedFromTypeParameters = typeParametersToAlphaRename;`
`32`		`- TypeMap = TypeMap.Empty.WithAlphaRename(typeParametersToAlphaRename, this, out _typeParameters);`
	`32`	`+ TypeMap = TypeMap.Empty.WithAlphaRename(typeParametersToAlphaRename, this, propagateAttributes: false, out _typeParameters);`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`protected SynthesizedContainer(string name)`