Local function attributes emit

src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/SynthesizedClosureMethod.cs

@@ -15,6 +15,7 @@ namespace Microsoft.CodeAnalysis.CSharp
     internal sealed class SynthesizedClosureMethod : SynthesizedMethodBaseSymbol, ISynthesizedMethodBodyImplementationSymbol
     {
         private readonly MethodSymbol _topLevelMethod;
+        private readonly MethodSymbol _originalMethod;
         private readonly ImmutableArray<NamedTypeSymbol> _structEnvironments;
 
         internal readonly DebugId LambdaId;
@@ -39,6 +40,7 @@ originalMethod is LocalFunctionSymbol
                    MakeDeclarationModifiers(closureKind, originalMethod))
         {
             _topLevelMethod = topLevelMethod;
+            _originalMethod = originalMethod;
             ClosureKind = closureKind;
             LambdaId = lambdaId;
 
@@ -163,6 +165,10 @@ protected override ImmutableArray<TypeSymbol> ExtraSynthesizedRefParameters
         internal override bool IsExpressionBodied => false;
         internal MethodSymbol TopLevelMethod => _topLevelMethod;
 
+        public override ImmutableArray<CSharpAttributeData> GetAttributes() => _originalMethod.GetAttributes();
+
+        public override ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes() => _originalMethod.GetReturnTypeAttributes();
+
         internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)
         {
             // Syntax offset of a syntax node contained in a lambda body is calculated by the containing top-level method.

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

@@ -117,7 +117,13 @@ private ImmutableArray<ParameterSymbol> MakeParameters()
             var parameters = this.BaseMethodParameters;
             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: p.GetAttributes()));
             }
             var extraSynthed = ExtraSynthesizedRefParameters;
             if (!extraSynthed.IsDefaultOrEmpty)

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 SynthesizedParameterSymbolWithCustomModifiers(container, type, ordinal, refKind, name, refCustomModifiers, attributes.NullToEmpty());
         }
 
         /// <summary>
@@ -231,23 +232,31 @@ public override ImmutableArray<CustomModifier> RefCustomModifiers
         private sealed class SynthesizedParameterSymbolWithCustomModifiers : SynthesizedParameterSymbolBase
         {
             private readonly ImmutableArray<CustomModifier> _refCustomModifiers;
+            private readonly ImmutableArray<CSharpAttributeData> _attributes;
 
             public SynthesizedParameterSymbolWithCustomModifiers(
                 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();
+                _attributes = attributes;
             }
 
             public override ImmutableArray<CustomModifier> RefCustomModifiers
             {
                 get { return _refCustomModifiers; }
             }
+
+            public override ImmutableArray<CSharpAttributeData> GetAttributes()
+            {
+                return _attributes;
+            }
         }
     }
 }

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenLocalFunctionTests.cs

@@ -5156,6 +5156,234 @@ .locals init (Program.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
 ");
         }
 
+        [Fact]
+        public void LocalFunctionAttribute()
+        {
+            var source = @"
+class A : System.Attribute { }
+
+class C
+{
+    public void M()
+    {
+        [A]
+        void local1()
+        {
+        }
+
+        [return: A]
+        void local2()
+        {
+        }
+
+        void local3([A] int i)
+        {
+        }
+
+        void local4<[A] T>()
+        {
+        }
+    }
+}
+";
+            CompileAndVerify(
+                source,
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All),
+                parseOptions: TestOptions.RegularPreview,
+                symbolValidator: validate);
+
+            void validate(ModuleSymbol module)
+            {
+                var cClass = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
+                var aAttribute = module.GlobalNamespace.GetMember<NamedTypeSymbol>("A");
+
+                var localFn1 = cClass.GetMethod("<M>g__local1|0_0");
+                var attrs1 = localFn1.GetAttributes();
+                Assert.Equal(
+                    expected: new[]
+                    {
+                        module.CorLibrary().GetTypeByMetadataName("System.Runtime.CompilerServices.CompilerGeneratedAttribute"),
+                        aAttribute
+                    },
+                    actual: attrs1.Select(a => a.AttributeClass));
+
+                var localFn2 = cClass.GetMethod("<M>g__local2|0_1");
+                var attrs2 = localFn2.GetReturnTypeAttributes();
+                Assert.Equal(aAttribute, attrs2.Single().AttributeClass);
+
+                var localFn3 = cClass.GetMethod("<M>g__local3|0_2");
+                var attrs3 = localFn3.GetParameters().Single().GetAttributes();
+                Assert.Equal(aAttribute, attrs3.Single().AttributeClass);
+
+                var localFn4 = cClass.GetMethod("<M>g__local4|0_3");
+                var attrs4 = localFn4.TypeParameters.Single().GetAttributes();
+                Assert.Equal(aAttribute, attrs4.Single().AttributeClass);
+            }
+        }
+
+        [Fact]
+        public void LocalFunctionAttribute_Complex()
+        {
+            var source = @"
+class A1 : System.Attribute { }
+class A2 : System.Attribute { internal A2(int i, string s) { } }
+class A3 : System.Attribute { internal A3(params int[] values) { } }
+
+class C
+{
+    public void M()
+    {
+        [A1, A2(1, ""hello"")]
+        [A3(1, 2, 3, 4, 5)]
+        void local1()
+        {
+        }
+    }
+}
+";
+            CompileAndVerify(
+                source,
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All),
+                parseOptions: TestOptions.RegularPreview,
+                symbolValidator: validate);
+
+            void validate(ModuleSymbol module)
+            {
+                var cClass = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
+                var attr1 = module.GlobalNamespace.GetMember<NamedTypeSymbol>("A1");
+                var attr2 = module.GlobalNamespace.GetMember<NamedTypeSymbol>("A2");
+                var attr3 = module.GlobalNamespace.GetMember<NamedTypeSymbol>("A3");
+
+                var localFn1 = cClass.GetMethod("<M>g__local1|0_0");
+                var attrs = localFn1.GetAttributes();
+                Assert.Equal(
+                    expected: new[]
+                    {
+                        module.CorLibrary().GetTypeByMetadataName("System.Runtime.CompilerServices.CompilerGeneratedAttribute"),
+                        attr1,
+                        attr2,
+                        attr3
+                    },
+                    actual: attrs.Select(a => a.AttributeClass));
+
+                Assert.Empty(attrs[0].ConstructorArguments);
+                Assert.Empty(attrs[1].ConstructorArguments);
+                Assert.Equal(new object[] { 1, "hello" }, attrs[2].ConstructorArguments.Select(a => a.Value));
+
+                var attr3Args = attrs[3].ConstructorArguments.Single().Values;
+                Assert.Equal(new object[] { 1, 2, 3, 4, 5 }, attr3Args.Select(a => a.Value));
+            }
+        }
+
+        [Fact]
+        public void LocalFunctionAttributeArgument()
+        {
+            var source = @"
+class A : System.Attribute { internal A(int i) { } }
+
+class C
+{
+    public void M()
+    {
+        [A(42)]
+        void local1()
+        {
+        }
+    }
+}
+";
+            var verifier = CompileAndVerify(
+                source,
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All),
+                parseOptions: TestOptions.RegularPreview,
+                symbolValidator: validate);
+
+            void validate(ModuleSymbol module)
+            {
+                var cClass = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C");
+                var aAttribute = module.GlobalNamespace.GetMember<NamedTypeSymbol>("A");
+
+                var localFn1 = cClass.GetMethod("<M>g__local1|0_0");
+                var attrs1 = localFn1.GetAttributes();
+                Assert.Equal(
+                    expected: new[]
+                    {
+                        module.CorLibrary().GetTypeByMetadataName("System.Runtime.CompilerServices.CompilerGeneratedAttribute"),
+                        aAttribute
+                    },
+                    actual: attrs1.Select(a => a.AttributeClass));
+
+                var arg = attrs1[1].ConstructorArguments.Single();
+                Assert.Equal(42, arg.Value);
+            }
+        }
+
+        [ConditionalFact(typeof(DesktopOnly))]
+        public void LocalFunctionAttribute_TypeIL()
+        {
+            var source = @"
+class A : System.Attribute { internal A(int i) { } }
+
+class C
+{
+    public void M()
+    {
+        [A(42)]
+        void local1()
+        {
+        }
+    }
+}
+";
+            var verifier = CompileAndVerify(
+                source,
+                options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All),
+                parseOptions: TestOptions.RegularPreview);
+
+            verifier.VerifyTypeIL("C", @"
+    .class private auto ansi beforefieldinit C
+    	extends [mscorlib]System.Object
+    {
+    	// Methods
+    	.method public hidebysig 
+    		instance void M () cil managed 
+    	{
+    		// Method begins at RVA 0x205a
+    		// Code size 3 (0x3)
+    		.maxstack 8
+    		IL_0000: nop
+    		IL_0001: nop
+    		IL_0002: ret
+    	} // end of method C::M
+    	.method public hidebysig specialname rtspecialname 
+    		instance void .ctor () cil managed 
+    	{
+    		// Method begins at RVA 0x205e
+    		// Code size 8 (0x8)
+    		.maxstack 8
+    		IL_0000: ldarg.0
+    		IL_0001: call instance void [mscorlib]System.Object::.ctor()
+    		IL_0006: nop
+    		IL_0007: ret
+    	} // end of method C::.ctor
+    	.method assembly hidebysig static 
+    		void '<M>g__local1|0_0' () cil managed 
+    	{
+    		.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = (
+    			01 00 00 00
+    		)
+    		.custom instance void A::.ctor(int32) = (
+    			01 00 2a 00 00 00 00 00
+    		)
+    		// Method begins at RVA 0x2067
+    		// Code size 2 (0x2)
+    		.maxstack 8
+    		IL_0000: nop
+    		IL_0001: ret
+    	} // end of method C::'<M>g__local1|0_0'
+    } // end of class C");
+        }
+
         internal CompilationVerifier VerifyOutput(string source, string output, CSharpCompilationOptions options, Verification verify = Verification.Passes)
         {
             var comp = CreateCompilationWithMscorlib45AndCSharp(source, options: options);