Extensions: propagate return-targeted and local function parameter attributes

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();
         }
 

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 sealed override ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes()
+        {
+            return _originalMethod.GetReturnTypeAttributes();
+        }
+
         internal sealed override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()
         {
             return _originalMethod.GetUseSiteInfo();

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 => null;
         internal override bool IsIDispatchConstant => false;
         internal override bool IsIUnknownConstant => false;
         internal override bool IsCallerFilePath => false;

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs

@@ -551,7 +551,7 @@ internal override bool HasMetadataConstantValue
             return value;
         }
 
-        internal override ConstantValue? ExplicitDefaultConstantValue
+        internal sealed override ConstantValue? ExplicitDefaultConstantValue
         {
             get
             {
@@ -569,6 +569,8 @@ internal override ConstantValue? ExplicitDefaultConstantValue
             }
         }
 
+        internal sealed override ConstantValue? DefaultValueFromAttributes => null;
+
         private ConstantValue? GetDefaultDecimalOrDateTimeValue()
         {
             Debug.Assert(!_handle.IsNil);

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 null when not applicable.
+        /// </summary>
+        internal abstract ConstantValue? DefaultValueFromAttributes { get; }
+
         /// <summary>
         /// Gets the kind of this symbol.
         /// </summary>

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(); } }

src/Compilers/CSharp/Portable/Symbols/Source/SourceClonedParameterSymbol.cs

@@ -71,7 +71,8 @@ internal override bool IsMetadataOptional
 
         internal sealed override bool UseUpdatedEscapeRules => _originalParam.UseUpdatedEscapeRules;
 
-        internal override ConstantValue ExplicitDefaultConstantValue
+#nullable enable
+        internal override ConstantValue? ExplicitDefaultConstantValue
         {
             get
             {
@@ -80,10 +81,11 @@ internal override ConstantValue ExplicitDefaultConstantValue
             }
         }
 
-        internal override ConstantValue DefaultValueFromAttributes
+        internal override ConstantValue? DefaultValueFromAttributes
         {
             get { return _originalParam.DefaultValueFromAttributes; }
         }
+#nullable disable
 
         #region Forwarded
 

src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs

@@ -36,7 +36,9 @@ private enum ParameterFlags : byte
 
         private ThreeState _lazyHasOptionalAttribute;
         private CustomAttributesBag<CSharpAttributeData> _lazyCustomAttributesBag;
-        protected ConstantValue _lazyDefaultSyntaxValue;
+#nullable enable
+        protected ConstantValue? _lazyDefaultSyntaxValue;
+#nullable disable
 
         protected SourceComplexParameterSymbolBase(
             Symbol owner,
@@ -88,7 +90,8 @@ protected SourceComplexParameterSymbolBase(
 
         public override bool IsDiscard => false;
 
-        internal sealed override ConstantValue ExplicitDefaultConstantValue
+#nullable enable
+        internal sealed override ConstantValue? ExplicitDefaultConstantValue
         {
             get
             {
@@ -106,14 +109,15 @@ internal sealed override ConstantValue ExplicitDefaultConstantValue
             }
         }
 
-        internal sealed override ConstantValue DefaultValueFromAttributes
+        internal sealed override ConstantValue? DefaultValueFromAttributes
         {
             get
             {
                 ParameterEarlyWellKnownAttributeData data = GetEarlyDecodedWellKnownAttributeData();
-                return (data != null && data.DefaultParameterValue != ConstantValue.Unset) ? data.DefaultParameterValue : ConstantValue.NotAvailable;
+                return (data != null && data.DefaultParameterValue != ConstantValue.Unset) ? data.DefaultParameterValue : null;
             }
         }
+#nullable disable
 
         internal sealed override bool IsIDispatchConstant
             => GetDecodedWellKnownAttributeData()?.HasIDispatchConstantAttribute == true;
@@ -240,7 +244,7 @@ internal sealed override ScopedKind EffectiveScope
             return parameterEqualsValue;
         }
 
-        private ConstantValue DefaultSyntaxValue
+        private ConstantValue? DefaultSyntaxValue
         {
             get
             {
@@ -264,6 +268,8 @@ private ConstantValue DefaultSyntaxValue
                         {
                             NullableWalker.AnalyzeIfNeeded(binder, parameterEqualsValue, valueSyntax, diagnostics.DiagnosticBag);
                         }
+
+                        Debug.Assert(_lazyDefaultSyntaxValue is not null);
                         if (!_lazyDefaultSyntaxValue.IsBad)
                         {
                             VerifyParamDefaultValueMatchesAttributeIfAny(_lazyDefaultSyntaxValue, parameterEqualsValue.Value.Syntax, diagnostics);
@@ -358,21 +364,21 @@ private void NullableAnalyzeParameterDefaultValueFromAttributes()
 
         // This method *must not* depend on attributes on the parameter symbol.
         // Otherwise we will have cycles when binding usage of attributes whose constructors have optional parameters
-        private ConstantValue MakeDefaultExpression(BindingDiagnosticBag diagnostics, out Binder? binder, out BoundParameterEqualsValue? parameterEqualsValue)
+        private ConstantValue? MakeDefaultExpression(BindingDiagnosticBag diagnostics, out Binder? binder, out BoundParameterEqualsValue? parameterEqualsValue)
         {
             binder = null;
             parameterEqualsValue = null;
 
             var parameterSyntax = this.ParameterSyntax;
             if (parameterSyntax == null)
             {
-                return ConstantValue.NotAvailable;
+                return null;
             }
 
             var defaultSyntax = parameterSyntax.Default;
             if (defaultSyntax == null)
             {
-                return ConstantValue.NotAvailable;
+                return null;
             }
 
             MessageID.IDS_FeatureOptionalParameter.CheckFeatureAvailability(diagnostics, defaultSyntax.EqualsToken);

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);

src/Compilers/CSharp/Portable/Symbols/Source/SourceSimpleParameterSymbol.cs

@@ -157,9 +157,9 @@ internal override CustomAttributesBag<CSharpAttributeData> GetAttributesBag()
             return CustomAttributesBag<CSharpAttributeData>.Empty;
         }
 
-        internal override ConstantValue DefaultValueFromAttributes
+        internal override ConstantValue? DefaultValueFromAttributes
         {
-            get { return ConstantValue.NotAvailable; }
+            get { return null; }
         }
 
         internal override ScopedKind EffectiveScope => CalculateEffectiveScopeIgnoringAttributes();

src/Compilers/CSharp/Portable/Symbols/Source/ThisParameterSymbol.cs

@@ -25,6 +25,11 @@ internal sealed override ConstantValue? ExplicitDefaultConstantValue
             get { return null; }
         }
 
+        internal sealed override ConstantValue? DefaultValueFromAttributes
+        {
+            get { return null; }
+        }
+
         internal sealed override bool IsMetadataOptional
         {
             get { return false; }

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs

@@ -476,6 +476,10 @@ string name
 
             internal override bool IsMetadataOut => RefKind == RefKind.Out;
 
+#nullable enable
+            internal override ConstantValue? DefaultValueFromAttributes => null;
+#nullable disable
+
             public override bool Equals(Symbol obj, TypeCompareKind compareKind)
             {
                 if (obj == (object)this)

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 => null;
+
         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
         {

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs

@@ -81,6 +81,11 @@ internal sealed override ConstantValue? ExplicitDefaultConstantValue
             get { return _underlyingParameter.ExplicitDefaultConstantValue; }
         }
 
+        internal sealed override ConstantValue? DefaultValueFromAttributes
+        {
+            get { return _underlyingParameter.DefaultValueFromAttributes; }
+        }
+
         public override int Ordinal
         {
             get { return _underlyingParameter.Ordinal; }