Extensions: propagate return-targeted and local function parameter attributes

Julien Couvreur · Julien Couvreur · commit b3ee96636d16 · 2025-08-28T10:52:17.000-07:00
diff --git a/src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs b/src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs
@@ -129,8 +129,9 @@ private ImmutableArray<ParameterSymbol> MakeParameters()
                     p.ExplicitDefaultConstantValue,
                     // the synthesized parameter doesn't need to have the same ref custom modifiers as the base
                     refCustomModifiers: default,
-                    inheritAttributes ? p as SourceComplexParameterSymbolBase : null));
+                    baseParameterForAttributes: inheritAttributes ? p : null));
             }
+
             var extraSynthed = ExtraSynthesizedRefParameters;
             if (!extraSynthed.IsDefaultOrEmpty)
             {
@@ -139,6 +140,7 @@ private ImmutableArray<ParameterSymbol> MakeParameters()
                     builder.Add(SynthesizedParameterSymbol.Create(this, this.TypeMap.SubstituteType(extra), ordinal++, RefKind.Ref));
                 }
             }
+
             return builder.ToImmutableAndFree();
         }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenMethodSymbol.cs
@@ -4,7 +4,6 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -87,6 +86,11 @@ public sealed override ImmutableArray<CSharpAttributeData> GetAttributes()
             return _originalMethod.GetAttributes();
         }
 
+        public override ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes()
+        {
+            return _originalMethod.GetReturnTypeAttributes();
+        }
+
         internal sealed override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()
         {
             return _originalMethod.GetUseSiteInfo();
diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerParameterSymbol.cs
@@ -81,6 +81,7 @@ internal int MethodHashCode()
         internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter;
         internal override bool IsMetadataOut => RefKind == RefKind.Out;
         internal override ConstantValue? ExplicitDefaultConstantValue => null;
+        internal override ConstantValue DefaultValueFromAttributes => ConstantValue.NotAvailable;
         internal override bool IsIDispatchConstant => false;
         internal override bool IsIUnknownConstant => false;
         internal override bool IsCallerFilePath => false;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs
@@ -569,6 +569,8 @@ internal override ConstantValue? ExplicitDefaultConstantValue
             }
         }
 
+        internal override ConstantValue DefaultValueFromAttributes => ConstantValue.NotAvailable;
+
         private ConstantValue? GetDefaultDecimalOrDateTimeValue()
         {
             Debug.Assert(!_handle.IsNil);
diff --git a/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs
@@ -254,6 +254,13 @@ public object? ExplicitDefaultValue
         /// </remarks>
         internal abstract ConstantValue? ExplicitDefaultConstantValue { get; }
 
+        /// <summary>
+        /// Returns the default value from attributes on the parameter,
+        /// for symbols from source or derived from source symbols.
+        /// Returns <see cref="ConstantValue.NotAvailable"/> when not applicable.
+        /// </summary>
+        internal abstract ConstantValue DefaultValueFromAttributes { get; }
+
         /// <summary>
         /// Gets the kind of this symbol.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SignatureOnlyParameterSymbol.cs
@@ -78,6 +78,8 @@ internal override ScopedKind EffectiveScope
 
         internal override ConstantValue ExplicitDefaultConstantValue { get { throw ExceptionUtilities.Unreachable(); } }
 
+        internal override ConstantValue DefaultValueFromAttributes { get { throw ExceptionUtilities.Unreachable(); } }
+
         internal override bool IsIDispatchConstant { get { throw ExceptionUtilities.Unreachable(); } }
 
         internal override bool IsIUnknownConstant { get { throw ExceptionUtilities.Unreachable(); } }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceParameterSymbolBase.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceParameterSymbolBase.cs
@@ -64,8 +64,6 @@ public sealed override AssemblySymbol ContainingAssembly
             get { return _containingSymbol.ContainingAssembly; }
         }
 
-        internal abstract ConstantValue DefaultValueFromAttributes { get; }
-
         internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
         {
             base.AddSynthesizedAttributes(moduleBuilder, ref attributes);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ThisParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ThisParameterSymbol.cs
@@ -25,6 +25,11 @@ internal sealed override ConstantValue? ExplicitDefaultConstantValue
             get { return null; }
         }
 
+        internal override ConstantValue DefaultValueFromAttributes
+        {
+            get { return ConstantValue.NotAvailable; }
+        }
+
         internal sealed override bool IsMetadataOptional
         {
             get { return false; }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs
@@ -476,6 +476,8 @@ string name
 
             internal override bool IsMetadataOut => RefKind == RefKind.Out;
 
+            internal override ConstantValue DefaultValueFromAttributes => ConstantValue.NotAvailable;
+
             public override bool Equals(Symbol obj, TypeCompareKind compareKind)
             {
                 if (obj == (object)this)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedParameterSymbol.cs
@@ -85,8 +85,6 @@ internal override ConstantValue? ExplicitDefaultConstantValue
             get { return null; }
         }
 
-        internal virtual ConstantValue? DefaultValueFromAttributes => null;
-
         internal override bool IsIDispatchConstant
         {
             get { throw ExceptionUtilities.Unreachable(); }
@@ -254,6 +252,8 @@ private SynthesizedParameterSymbol(
 
         internal sealed override bool IsMetadataOut => RefKind == RefKind.Out;
 
+        internal override ConstantValue DefaultValueFromAttributes => ConstantValue.NotAvailable;
+
         public static ParameterSymbol Create(
             Symbol? container,
             TypeWithAnnotations type,
@@ -263,7 +263,7 @@ public static ParameterSymbol Create(
             ScopedKind scope = ScopedKind.None,
             ConstantValue? defaultValue = null,
             ImmutableArray<CustomModifier> refCustomModifiers = default,
-            SourceComplexParameterSymbolBase? baseParameterForAttributes = null,
+            ParameterSymbol? baseParameterForAttributes = null,
             bool isParams = false,
             bool hasUnscopedRefAttribute = false)
         {
@@ -340,7 +340,7 @@ internal sealed class SynthesizedComplexParameterSymbol : SynthesizedParameterSy
         private readonly ImmutableArray<CustomModifier> _refCustomModifiers;
 
         // The parameter containing attributes to inherit into this synthesized parameter, if any.
-        private readonly SourceComplexParameterSymbolBase? _baseParameterForAttributes;
+        private readonly ParameterSymbol? _baseParameterForAttributes;
         private readonly ConstantValue? _defaultValue;
         private readonly bool _isParams;
         private readonly bool _hasUnscopedRefAttribute;
@@ -354,14 +354,15 @@ public SynthesizedComplexParameterSymbol(
             ConstantValue? defaultValue,
             string name,
             ImmutableArray<CustomModifier> refCustomModifiers,
-            SourceComplexParameterSymbolBase? baseParameterForAttributes,
+            ParameterSymbol? baseParameterForAttributes,
             bool isParams,
             bool hasUnscopedRefAttribute)
             : base(container, type, ordinal, refKind, scope, name)
         {
             Debug.Assert(!refCustomModifiers.IsDefault);
             Debug.Assert(isParams || !refCustomModifiers.IsEmpty || baseParameterForAttributes is object || defaultValue is not null || hasUnscopedRefAttribute);
             Debug.Assert(baseParameterForAttributes is null || baseParameterForAttributes.ExplicitDefaultConstantValue == defaultValue);
+            Debug.Assert(baseParameterForAttributes is null || baseParameterForAttributes.RefKind == refKind);
 
             _refCustomModifiers = refCustomModifiers;
             _baseParameterForAttributes = baseParameterForAttributes;
@@ -407,13 +408,13 @@ internal override bool IsCallerMemberName
             get => _baseParameterForAttributes?.IsCallerMemberName ?? false;
         }
 
-        internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter || _baseParameterForAttributes?.GetDecodedWellKnownAttributeData()?.HasInAttribute == true;
+        internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter || _baseParameterForAttributes?.IsMetadataIn == true;
 
-        internal override bool IsMetadataOut => RefKind == RefKind.Out || _baseParameterForAttributes?.GetDecodedWellKnownAttributeData()?.HasOutAttribute == true;
+        internal override bool IsMetadataOut => RefKind == RefKind.Out || _baseParameterForAttributes?.IsMetadataOut == true;
 
-        internal override ConstantValue? ExplicitDefaultConstantValue => _baseParameterForAttributes?.ExplicitDefaultConstantValue ?? _defaultValue;
+        internal override ConstantValue? ExplicitDefaultConstantValue => _defaultValue;
 
-        internal override ConstantValue? DefaultValueFromAttributes => _baseParameterForAttributes?.DefaultValueFromAttributes;
+        internal override ConstantValue DefaultValueFromAttributes => _baseParameterForAttributes?.DefaultValueFromAttributes ?? ConstantValue.NotAvailable;
 
         internal override FlowAnalysisAnnotations FlowAnalysisAnnotations
         {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs
@@ -81,6 +81,11 @@ internal sealed override ConstantValue? ExplicitDefaultConstantValue
             get { return _underlyingParameter.ExplicitDefaultConstantValue; }
         }
 
+        internal override ConstantValue DefaultValueFromAttributes
+        {
+            get { return _underlyingParameter.DefaultValueFromAttributes; }
+        }
+
         public override int Ordinal
         {
             get { return _underlyingParameter.Ordinal; }
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs
@@ -6164,12 +6164,6 @@ static void local([Attr] in State state)
             var param = localFunction.Parameters[0];
             Assert.True(param.IsMetadataIn);
             Assert.False(param.IsMetadataOut);
-
-            // Test a scenario where the baseParameterAttributes has a different RefKind than the synthesized parameter.
-            // We expect the RefKind of the base parameter to be ignored here.
-            var synthesizedParam = SynthesizedParameterSymbol.Create(localFunction, param.TypeWithAnnotations, ordinal: 0, RefKind.Out, param.Name, baseParameterForAttributes: (SourceComplexParameterSymbolBase)param);
-            Assert.False(synthesizedParam.IsMetadataIn);
-            Assert.True(synthesizedParam.IsMetadataOut);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs b/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs
@@ -33845,6 +33845,12 @@ public static class E1
         var comp2 = CreateCompilation(source, references: [libComp.EmitToImageReference()]);
         CompileAndVerify(comp2, expectedOutput: "ran").VerifyDiagnostics();
 
+        source = """
+E1.M(42, 43);
+""";
+        var comp3 = CreateCompilation([source, libSrc, OverloadResolutionPriorityAttributeDefinition]);
+        CompileAndVerify(comp3, expectedOutput: "ran", symbolValidator: verify).VerifyDiagnostics();
+
         static void verify(ModuleSymbol m)
         {
             var implementations = m.ContainingAssembly.GetTypeByMetadataName("E1").GetMembers().OfType<MethodSymbol>().ToArray();
@@ -44226,6 +44232,7 @@ public void ConditionalAttribute_01()
         var src = """
 42.M();
 42.M2();
+E.M(42);
 
 static class E
 {
@@ -44236,7 +44243,7 @@ static class E
     }
 
     [System.Diagnostics.Conditional("DEBUG")]
-    public static void M2(this int i) { System.Console.Write("ran"); }
+    public static void M2(this int i) { System.Console.Write("ran "); }
 }
 """;
         var comp = CreateCompilation(src);
@@ -44248,6 +44255,7 @@ static class E
 
 42.M();
 42.M2();
+E.M(42);
 
 static class E
 {
@@ -44258,12 +44266,12 @@ static class E
     }
 
     [System.Diagnostics.Conditional("DEBUG")]
-    public static void M2(this int i) { System.Console.Write("ran"); }
+    public static void M2(this int i) { System.Console.Write("ran "); }
 }
 """;
         comp = CreateCompilation(src);
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "ran ran");
+        CompileAndVerify(comp, expectedOutput: "ran ran ran");
     }
 
     [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs b/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs

Original file line number	Diff line number	Diff line change
`@@ -129,8 +129,9 @@ private ImmutableArray<ParameterSymbol> MakeParameters()`
`129`	`129`	`p.ExplicitDefaultConstantValue,`
`130`	`130`	`// the synthesized parameter doesn't need to have the same ref custom modifiers as the base`
`131`	`131`	`refCustomModifiers: default,`
`132`		`- inheritAttributes ? p as SourceComplexParameterSymbolBase : null));`
	`132`	`+ baseParameterForAttributes: inheritAttributes ? p : null));`
`133`	`133`	`}`
	`134`	`+`
`134`	`135`	`var extraSynthed = ExtraSynthesizedRefParameters;`
`135`	`136`	`if (!extraSynthed.IsDefaultOrEmpty)`
`136`	`137`	`{`
`@@ -139,6 +140,7 @@ private ImmutableArray<ParameterSymbol> MakeParameters()`
`139`	`140`	`builder.Add(SynthesizedParameterSymbol.Create(this, this.TypeMap.SubstituteType(extra), ordinal++, RefKind.Ref));`
`140`	`141`	`}`
`141`	`142`	`}`
	`143`	`+`
`142`	`144`	`return builder.ToImmutableAndFree();`
`143`	`145`	`}`
`144`	`146`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`
`5`	`5`	`using System.Collections.Immutable;`
`6`	`6`	`using System.Diagnostics;`
`7`		`-using Roslyn.Utilities;`
`8`	`7`
`9`	`8`	`namespace Microsoft.CodeAnalysis.CSharp.Symbols`
`10`	`9`	`{`
`@@ -87,6 +86,11 @@ public sealed override ImmutableArray<CSharpAttributeData> GetAttributes()`
`87`	`86`	`return _originalMethod.GetAttributes();`
`88`	`87`	`}`
`89`	`88`
	`89`	`+ public override ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes()`
	`90`	`+ {`
	`91`	`+ return _originalMethod.GetReturnTypeAttributes();`
	`92`	`+ }`
	`93`	`+`
`90`	`94`	`internal sealed override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()`
`91`	`95`	`{`
`92`	`96`	`return _originalMethod.GetUseSiteInfo();`
Original file line number	Diff line number	Diff line change
`@@ -569,6 +569,8 @@ internal override ConstantValue? ExplicitDefaultConstantValue`
`569`	`569`	`}`
`570`	`570`	`}`
`571`	`571`
	`572`	`+ internal override ConstantValue DefaultValueFromAttributes => ConstantValue.NotAvailable;`
	`573`	`+`
`572`	`574`	`private ConstantValue? GetDefaultDecimalOrDateTimeValue()`
`573`	`575`	`{`
`574`	`576`	`Debug.Assert(!_handle.IsNil);`
Original file line number	Diff line number	Diff line change
`@@ -64,8 +64,6 @@ public sealed override AssemblySymbol ContainingAssembly`
`64`	`64`	`get { return _containingSymbol.ContainingAssembly; }`
`65`	`65`	`}`
`66`	`66`
`67`		`- internal abstract ConstantValue DefaultValueFromAttributes { get; }`
`68`		`-`
`69`	`67`	`internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)`
`70`	`68`	`{`
`71`	`69`	`base.AddSynthesizedAttributes(moduleBuilder, ref attributes);`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,11 @@ internal sealed override ConstantValue? ExplicitDefaultConstantValue`
`25`	`25`	`get { return null; }`
`26`	`26`	`}`
`27`	`27`
	`28`	`+ internal override ConstantValue DefaultValueFromAttributes`
	`29`	`+ {`
	`30`	`+ get { return ConstantValue.NotAvailable; }`
	`31`	`+ }`
	`32`	`+`
`28`	`33`	`internal sealed override bool IsMetadataOptional`
`29`	`34`	`{`
`30`	`35`	`get { return false; }`
Original file line number	Diff line number	Diff line change
`@@ -476,6 +476,8 @@ string name`
`476`	`476`
`477`	`477`	`internal override bool IsMetadataOut => RefKind == RefKind.Out;`
`478`	`478`
	`479`	`+ internal override ConstantValue DefaultValueFromAttributes => ConstantValue.NotAvailable;`
	`480`	`+`
`479`	`481`	`public override bool Equals(Symbol obj, TypeCompareKind compareKind)`
`480`	`482`	`{`
`481`	`483`	`if (obj == (object)this)`