Local function attributes emit

src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs

@@ -115,9 +115,16 @@ private ImmutableArray<ParameterSymbol> MakeParameters()
             int ordinal = 0;
             var builder = ArrayBuilder<ParameterSymbol>.GetInstance();
             var parameters = this.BaseMethodParameters;
+            var inheritAttributes = this.BaseMethod.SynthesizedMethodsInheritAttributes;
             foreach (var p in parameters)
             {
-                builder.Add(SynthesizedParameterSymbol.Create(this, this.TypeMap.SubstituteType(p.OriginalDefinition.TypeWithAnnotations), ordinal++, p.RefKind, p.Name));
+                builder.Add(SynthesizedParameterSymbol.Create(
+                    this,
+                    this.TypeMap.SubstituteType(p.OriginalDefinition.TypeWithAnnotations),
+                    ordinal++,
+                    p.RefKind,
+                    p.Name,
+                    attributes: inheritAttributes ? p.GetAttributes() : default));
             }
             var extraSynthed = ExtraSynthesizedRefParameters;
             if (!extraSynthed.IsDefaultOrEmpty)
@@ -130,6 +137,20 @@ private ImmutableArray<ParameterSymbol> MakeParameters()
             return builder.ToImmutableAndFree();
         }
 
+        public override ImmutableArray<CSharpAttributeData> GetAttributes()
+        {
+            Debug.Assert(base.GetAttributes().IsEmpty);
+            return BaseMethod.SynthesizedMethodsInheritAttributes
+                ? BaseMethod.GetAttributes()
+                : ImmutableArray<CSharpAttributeData>.Empty;
+        }
+
+        public override ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes()
+        {
+            Debug.Assert(base.GetReturnTypeAttributes().IsEmpty);
+            return BaseMethod.SynthesizedMethodsInheritAttributes ? BaseMethod.GetReturnTypeAttributes() : ImmutableArray<CSharpAttributeData>.Empty;
+        }
+
         public sealed override RefKind RefKind
         {
             get { return this.BaseMethod.RefKind; }

src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs

@@ -329,6 +329,11 @@ internal virtual bool IsExplicitInterfaceImplementation
 
         protected bool IsValidReadOnlyTarget => !IsStatic && ContainingType.IsStructType() && MethodKind != MethodKind.Constructor;
 
+        /// <summary>
+        /// Indicates whether synthesized methods derived from this method should inherit the attributes of this method, its parameters, return type, and type parameters.
+        /// </summary>
+        internal virtual bool SynthesizedMethodsInheritAttributes => false;
+
         /// <summary>
         /// Returns interface methods explicitly implemented by this method.
         /// </summary>

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

@@ -383,6 +383,8 @@ internal override TypeWithAnnotations IteratorElementTypeWithAnnotations
 
         internal override bool IsDeclaredReadOnly => false;
 
+        internal override bool SynthesizedMethodsInheritAttributes => true;
+
         IAttributeTargetSymbol IAttributeTargetSymbol.AttributesOwner => this;
 
         AttributeLocation IAttributeTargetSymbol.AllowedAttributeLocations => AttributeLocation.Method | AttributeLocation.Return;

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

@@ -1054,7 +1054,7 @@ private CustomAttributesBag<CSharpAttributeData> GetAttributesBag(ref CustomAttr
         /// Gets the attributes applied on this symbol.
         /// Returns an empty array if there are no attributes.
         /// </summary>
-        public sealed override ImmutableArray<CSharpAttributeData> GetAttributes()
+        public override ImmutableArray<CSharpAttributeData> GetAttributes()
         {
             return this.GetAttributesBag().Attributes;
         }
@@ -1063,7 +1063,7 @@ public sealed override ImmutableArray<CSharpAttributeData> GetAttributes()
         /// Gets the attributes applied on the return value of this method symbol.
         /// Returns an empty array if there are no attributes.
         /// </summary>
-        public sealed override ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes()
+        public override ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes()
         {
             return this.GetReturnTypeAttributesBag().Attributes;
         }

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

@@ -192,14 +192,15 @@ public static ParameterSymbol Create(
             int ordinal,
             RefKind refKind,
             string name = "",
-            ImmutableArray<CustomModifier> refCustomModifiers = default(ImmutableArray<CustomModifier>))
+            ImmutableArray<CustomModifier> refCustomModifiers = default,
+            ImmutableArray<CSharpAttributeData> attributes = default)
         {
-            if (refCustomModifiers.IsDefaultOrEmpty)
+            if (refCustomModifiers.IsDefaultOrEmpty && attributes.IsDefaultOrEmpty)
             {
                 return new SynthesizedParameterSymbol(container, type, ordinal, refKind, name);
             }
 
-            return new SynthesizedParameterSymbolWithCustomModifiers(container, type, ordinal, refKind, name, refCustomModifiers);
+            return new SynthesizedComplexParameterSymbol(container, type, ordinal, refKind, name, refCustomModifiers.NullToEmpty(), attributes.NullToEmpty());
         }
 
         /// <summary>
@@ -228,26 +229,37 @@ public override ImmutableArray<CustomModifier> RefCustomModifiers
             get { return ImmutableArray<CustomModifier>.Empty; }
         }
 
-        private sealed class SynthesizedParameterSymbolWithCustomModifiers : SynthesizedParameterSymbolBase
+        private sealed class SynthesizedComplexParameterSymbol : SynthesizedParameterSymbolBase
         {
             private readonly ImmutableArray<CustomModifier> _refCustomModifiers;
+            private readonly ImmutableArray<CSharpAttributeData> _attributes;
 
-            public SynthesizedParameterSymbolWithCustomModifiers(
+            public SynthesizedComplexParameterSymbol(
                 MethodSymbol container,
                 TypeWithAnnotations type,
                 int ordinal,
                 RefKind refKind,
                 string name,
-                ImmutableArray<CustomModifier> refCustomModifiers)
+                ImmutableArray<CustomModifier> refCustomModifiers,
+                ImmutableArray<CSharpAttributeData> attributes)
                 : base(container, type, ordinal, refKind, name)
             {
-                _refCustomModifiers = refCustomModifiers.NullToEmpty();
+                Debug.Assert(!refCustomModifiers.IsDefault);
+                Debug.Assert(!attributes.IsDefault);
+
+                _refCustomModifiers = refCustomModifiers;
+                _attributes = attributes;
             }
 
             public override ImmutableArray<CustomModifier> RefCustomModifiers
             {
                 get { return _refCustomModifiers; }
             }
+
+            public override ImmutableArray<CSharpAttributeData> GetAttributes()
+            {
+                return _attributes;
+            }
         }
     }
 }

src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Synthesized.cs

@@ -548,6 +548,48 @@ public override async Task<int> GetIntAsync()
                 AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute", "DebuggerHiddenAttribute" }, GetAttributeNames(attributes));
             });
         }
+
+        [Theory]
+        [MemberData(nameof(OptimizationLevelTheoryData))]
+        [WorkItem(431, "https://github.com/dotnet/roslyn/issues/431")]
+        public void BaseMethodWrapper_DoNotInheritAttributes(OptimizationLevel optimizationLevel)
+        {
+            string source = @"
+using System.Threading.Tasks;
+
+class Attr : System.Attribute { }
+
+class A
+{
+    [Attr]
+    [return: Attr]
+    public virtual async Task<int> GetIntAsync([Attr] int x)
+    {
+        return 42;
+    }
+}
+class B : A
+{
+    public override async Task<int> GetIntAsync(int x)
+    {
+        return await base.GetIntAsync(x);
+    }
+}
+";
+            var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+                .WithOptimizationLevel(optimizationLevel)
+                .WithMetadataImportOptions(MetadataImportOptions.All);
+
+            CompileAndVerify(CreateCompilationWithMscorlib45(source, options: options), symbolValidator: module =>
+            {
+                var baseMethodWrapper = module.GlobalNamespace.GetTypeMember("B").GetMember<MethodSymbol>("<>n__0");
+                AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute", "DebuggerHiddenAttribute" }, GetAttributeNames(baseMethodWrapper.GetAttributes()));
+                Assert.Empty(baseMethodWrapper.GetReturnTypeAttributes());
+
+                var parameter = baseMethodWrapper.Parameters.Single();
+                Assert.Empty(parameter.GetAttributes());
+            });
+        }
         #endregion
 
         #region CompilationRelaxationsAttribute, RuntimeCompatibilityAttribute, DebuggableAttribute