From 33c3b2c60d0a2006162a6326db853fe5415439bd Mon Sep 17 00:00:00 2001
From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com>
Date: Mon, 15 Aug 2022 11:21:45 -0700
Subject: [PATCH 1/5] Add MakeGenericMethod tests for static interface methods
 (#2962)

---
 .../DataFlow/MakeGenericDataFlow.cs           | 32 ++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs
index 262e9b3f72b4..9e4df4cbcc51 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs
@@ -351,6 +351,7 @@ public static void Test ()
 
 				TestWithMultipleArgumentsWithRequirements ();
 
+				StaticInterfaceMethods.Test ();
 				NewConstraint.Test ();
 				StructConstraint.Test ();
 				UnmanagedConstraint.Test ();
@@ -631,7 +632,6 @@ static void TestWithRequirementsFromGenericParam<
 					.MakeGenericMethod (typeof (T));
 			}
 
-
 			static void TestWithRequirementsViaRuntimeMethod ()
 			{
 				typeof (MakeGenericMethod).GetRuntimeMethod (nameof (GenericWithRequirements), Type.EmptyTypes)
@@ -750,6 +750,36 @@ static void GenericWithMultipleArgumentsWithRequirements<
 			{
 			}
 
+			class StaticInterfaceMethods
+			{
+				public static void Test ()
+				{
+					KnownType ();
+					UnannotatedGenericParam<int> ();
+					AnnotatedGenericParam<int> ();
+				}
+
+				static MethodInfo KnownType ()
+					=> typeof (IFoo).GetMethod ("Method")
+					.MakeGenericMethod (new Type[] { typeof (int) });
+
+				[ExpectedWarning ("IL2090", "T", "PublicMethods")]
+				static MethodInfo UnannotatedGenericParam<T> ()
+					=> typeof (IFoo).GetMethod ("Method")
+					.MakeGenericMethod (new Type[] { typeof (T) });
+
+				static MethodInfo AnnotatedGenericParam<
+					[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> ()
+					=> typeof (IFoo).GetMethod ("Method")
+					.MakeGenericMethod (new Type[] { typeof (T) });
+
+				interface IFoo
+				{
+					static abstract T Method<
+						[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> ();
+				}
+			}
+
 			class NewConstraint
 			{
 				static void GenericWithNewConstraint<T> () where T : new()

From c710e8af4224a3d0d2975ba5c2b09f0398ee2383 Mon Sep 17 00:00:00 2001
From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com>
Date: Mon, 15 Aug 2022 12:07:47 -0700
Subject: [PATCH 2/5] Add IL Verification to tests (#2960)

Adds an ILVerifier to check that the IL produced by the linker is valid. Unsafe C# produced unverifiable code, so we skip verification when we pass that flag to the compiler. Also, there are a few warnings that are produced by valid C# with new features like static abstract interface methods and ref fields and ref returns.

In the future, it may be nice to add better error messages with the type, method name, and IL offset that produced the error, and perhaps an [ExpectedILVerifyError] attribute instead of filtering all of a type of error, but those are non-trivial to implement and don't occur in many tests (<10), so I haven't done that yet.
---
 eng/Versions.props                            |   1 +
 .../Mono.Linker.Tests.csproj                  |   3 +-
 .../TestCasesRunner/ILVerifier.cs             | 132 ++++++++++++++++++
 .../TestCasesRunner/ResultChecker.cs          |  62 +++++++-
 4 files changed, 194 insertions(+), 4 deletions(-)
 create mode 100644 test/Mono.Linker.Tests/TestCasesRunner/ILVerifier.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index ea29c2eae231..cef1af03cc2b 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -25,6 +25,7 @@
     <MicrosoftNetCompilersToolsetVersion>$(MicrosoftCodeAnalysisVersion)</MicrosoftNetCompilersToolsetVersion>
     <MicrosoftCodeAnalysisCSharpAnalyzerTestingXunitVersion>1.0.1-beta1.*</MicrosoftCodeAnalysisCSharpAnalyzerTestingXunitVersion>
     <MicrosoftCodeAnalysisBannedApiAnalyzersVersion>3.3.2</MicrosoftCodeAnalysisBannedApiAnalyzersVersion>
+    <MicrosoftILVerificationVersion>7.0.0-preview.7.22375.6</MicrosoftILVerificationVersion>
     <!-- This controls the version of the cecil package, or the version of cecil in the project graph
          when we build the cecil submodule. The reference assembly package will depend on this version of cecil.
          Keep this in sync with ProjectInfo.cs in the submodule. -->
diff --git a/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj b/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj
index 4a9ea7e7f2ce..448601a8a643 100644
--- a/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj
+++ b/test/Mono.Linker.Tests/Mono.Linker.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -32,6 +32,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisVersion)" />
+    <PackageReference Include="Microsoft.ILVerification" Version="$(MicrosoftILVerificationVersion)" />
     <PackageReference Include="nunit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <!-- This reference is purely so that the linker can resolve this
diff --git a/test/Mono.Linker.Tests/TestCasesRunner/ILVerifier.cs b/test/Mono.Linker.Tests/TestCasesRunner/ILVerifier.cs
new file mode 100644
index 000000000000..bf935cc22067
--- /dev/null
+++ b/test/Mono.Linker.Tests/TestCasesRunner/ILVerifier.cs
@@ -0,0 +1,132 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.PortableExecutable;
+using System.Runtime.Loader;
+using ILVerify;
+using Mono.Linker.Tests.Extensions;
+
+#nullable enable
+namespace Mono.Linker.Tests.TestCasesRunner
+{
+	class ILVerifier : ILVerify.IResolver
+	{
+		Verifier _verifier;
+		NPath _assemblyFolder;
+		NPath _frameworkFolder;
+		Dictionary<string, PEReader> _assemblyCache;
+		AssemblyLoadContext _alc;
+
+		public IEnumerable<VerificationResult> Results { get; private set; }
+
+		public ILVerifier (NPath assemblyPath)
+		{
+			var assemblyName = assemblyPath.FileNameWithoutExtension;
+			_assemblyFolder = assemblyPath.Parent;
+			_assemblyCache = new Dictionary<string, PEReader> ();
+			_frameworkFolder = typeof (object).Assembly.Location.ToNPath ().Parent;
+			_alc = new AssemblyLoadContext (_assemblyFolder.FileName);
+			LoadAssembly ("mscorlib");
+			LoadAssembly ("System.Private.CoreLib");
+			LoadAssemblyFromPath (assemblyName, assemblyPath);
+
+			_verifier = new ILVerify.Verifier (
+				this,
+				new ILVerify.VerifierOptions {
+					SanityChecks = true,
+					IncludeMetadataTokensInErrorMessages = true
+				});
+			_verifier.SetSystemModuleName (new AssemblyName ("mscorlib"));
+
+			var allResults = _verifier.Verify (Resolve (assemblyName))
+				?? Enumerable.Empty<VerificationResult> ();
+
+			Results = allResults.Where (r => r.Code switch {
+				ILVerify.VerifierError.None
+				// Static interface methods cause this warning
+				or ILVerify.VerifierError.CallAbstract
+				// "Missing callVirt after constrained prefix - static interface methods cause this warning
+				or ILVerify.VerifierError.Constrained
+				// ex. localloc cannot be statically verified by ILVerify
+				or ILVerify.VerifierError.Unverifiable
+				// ref returning a ref local causes this warning but is okay
+				or VerifierError.ReturnPtrToStack
+				// Span indexing with indexer (ex. span[^4]) causes this warning
+				or VerifierError.InitOnly
+				=> false,
+				_ => true
+			});
+		}
+
+		PEReader LoadAssembly (string assemblyName)
+		{
+			if (_assemblyCache.TryGetValue (assemblyName, out PEReader? reader))
+				return reader;
+			var assembly = _alc.LoadFromAssemblyName (new AssemblyName (assemblyName));
+			reader = new PEReader (File.OpenRead (assembly.Location));
+			_assemblyCache.Add (assemblyName, reader);
+			return reader;
+		}
+
+		PEReader LoadAssemblyFromPath (string assemblyName, NPath pathToAssembly)
+		{
+			if (_assemblyCache.TryGetValue (assemblyName, out PEReader? reader))
+				return reader;
+			var assembly = _alc.LoadFromAssemblyPath (pathToAssembly);
+			reader = new PEReader (File.OpenRead (assembly.Location));
+			_assemblyCache.Add (assemblyName, reader);
+			return reader;
+		}
+
+		bool TryLoadAssemblyFromFolder (string assemblyName, NPath folder, [NotNullWhen (true)] out PEReader? peReader)
+		{
+			Assembly? assembly = null;
+			string assemblyPath = Path.Join (folder.ToString (), assemblyName);
+			if (File.Exists (assemblyPath + ".dll"))
+				assembly = _alc.LoadFromAssemblyPath (assemblyPath + ".dll");
+			else if (File.Exists (assemblyPath + ".exe"))
+				assembly = _alc.LoadFromAssemblyPath (assemblyPath + ".exe");
+
+			if (assembly is not null) {
+				peReader = new PEReader (File.OpenRead (assembly.Location));
+				_assemblyCache.Add (assemblyName, peReader);
+				return true;
+			}
+			peReader = null;
+			return false;
+		}
+
+		PEReader? Resolve (string assemblyName)
+		{
+			PEReader? reader;
+			if (_assemblyCache.TryGetValue (assemblyName, out reader)) {
+				return reader;
+			}
+
+			if (TryLoadAssemblyFromFolder (assemblyName, _frameworkFolder, out reader))
+				return reader;
+
+			if (TryLoadAssemblyFromFolder (assemblyName, _assemblyFolder, out reader))
+				return reader;
+
+			return null;
+		}
+
+		PEReader? ILVerify.IResolver.ResolveAssembly (AssemblyName assemblyName)
+			=> Resolve (assemblyName.Name ?? assemblyName.FullName);
+
+		PEReader? ILVerify.IResolver.ResolveModule (AssemblyName referencingModule, string fileName)
+			=> Resolve (Path.GetFileNameWithoutExtension (fileName));
+
+		public string GetErrorMessage (VerificationResult result)
+		{
+			return $"IL Verification error:\n{result.Message}";
+		}
+	}
+}
+#nullable restore
diff --git a/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs b/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs
index bd611721cd60..ccb76575ff41 100644
--- a/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs
+++ b/test/Mono.Linker.Tests/TestCasesRunner/ResultChecker.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -13,6 +14,7 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Extensions;
 using NUnit.Framework;
+using WellKnownType = ILLink.Shared.TypeSystemProxy.WellKnownType;
 
 namespace Mono.Linker.Tests.TestCasesRunner
 {
@@ -47,6 +49,32 @@ public ResultChecker (BaseAssemblyResolver originalsResolver, BaseAssemblyResolv
 			_linkedReaderParameters = linkedReaderParameters;
 		}
 
+		static void VerifyIL (NPath pathToAssembly)
+		{
+			var verifier = new ILVerifier (pathToAssembly);
+			foreach (var result in verifier.Results) {
+				if (result.Code == ILVerify.VerifierError.None)
+					continue;
+				Assert.Fail (verifier.GetErrorMessage (result));
+			}
+		}
+
+		static bool ShouldValidateIL (AssemblyDefinition inputAssembly)
+		{
+			if (HasAttribute (inputAssembly, nameof (SkipPeVerifyAttribute)))
+				return false;
+
+			var caaIsUnsafeFlag = (CustomAttributeArgument caa) =>
+				caa.Type.IsTypeOf (WellKnownType.System_String)
+				&& (string) caa.Value == "/unsafe";
+			var customAttributeHasUnsafeFlag = (CustomAttribute ca) => ca.ConstructorArguments.Any (caaIsUnsafeFlag);
+			if (GetCustomAttributes (inputAssembly, nameof (SetupCompileArgumentAttribute))
+				.Any (customAttributeHasUnsafeFlag))
+				return false;
+
+			return true;
+		}
+
 		public virtual void Check (LinkedTestCaseResult linkResult)
 		{
 			InitializeResolvers (linkResult);
@@ -57,6 +85,9 @@ public virtual void Check (LinkedTestCaseResult linkResult)
 					Assert.IsTrue (linkResult.OutputAssemblyPath.FileExists (), $"The linked output assembly was not found.  Expected at {linkResult.OutputAssemblyPath}");
 					var linked = ResolveLinkedAssembly (linkResult.OutputAssemblyPath.FileNameWithoutExtension);
 
+					if (ShouldValidateIL (original))
+						VerifyIL (linkResult.OutputAssemblyPath);
+
 					InitialChecking (linkResult, original, linked);
 
 					PerformOutputAssemblyChecks (original, linkResult.OutputAssemblyPath.Parent);
@@ -1069,15 +1100,40 @@ bool IsTypeInOtherAssemblyAssertion (CustomAttribute attr)
 		}
 
 		static bool HasAttribute (ICustomAttributeProvider caProvider, string attributeName)
+		{
+			return TryGetCustomAttribute (caProvider, attributeName, out var _);
+		}
+
+#nullable enable
+		static bool TryGetCustomAttribute (ICustomAttributeProvider caProvider, string attributeName, [NotNullWhen (true)] out CustomAttribute? customAttribute)
+		{
+			if (caProvider is AssemblyDefinition assembly && assembly.EntryPoint != null) {
+				customAttribute = assembly.EntryPoint.DeclaringType.CustomAttributes
+					.FirstOrDefault (attr => attr!.AttributeType.Name == attributeName, null);
+				return customAttribute is not null;
+			}
+
+			if (caProvider is TypeDefinition type) {
+				customAttribute = type.CustomAttributes
+					.FirstOrDefault (attr => attr!.AttributeType.Name == attributeName, null);
+				return customAttribute is not null;
+			}
+			customAttribute = null;
+			return false;
+		}
+
+		static IEnumerable<CustomAttribute> GetCustomAttributes (ICustomAttributeProvider caProvider, string attributeName )
 		{
 			if (caProvider is AssemblyDefinition assembly && assembly.EntryPoint != null)
 				return assembly.EntryPoint.DeclaringType.CustomAttributes
-					.Any (attr => attr.AttributeType.Name == attributeName);
+					.Where (attr => attr!.AttributeType.Name == attributeName);
 
 			if (caProvider is TypeDefinition type)
-				return type.CustomAttributes.Any (attr => attr.AttributeType.Name == attributeName);
+				return type.CustomAttributes
+					.Where (attr => attr!.AttributeType.Name == attributeName);
 
-			return false;
+			return Enumerable.Empty<CustomAttribute> ();
 		}
+#nullable restore
 	}
 }

From 6b5bc03dbc6ca0553fac7dd6f36feefe09924bb8 Mon Sep 17 00:00:00 2001
From: Tlakaelel Axayakatl Ceja <tlakaelel.ceja@microsoft.com>
Date: Mon, 15 Aug 2022 13:20:00 -0700
Subject: [PATCH 3/5] Suppress warning in instance fields if the instance
 constructors are annotated with Requires (#2973)

---
 .../RequiresISymbolExtensions.cs                |  9 +++++++++
 .../RequiresCapability/RequiresOnClass.cs       | 17 +++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs b/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs
index f47097cc475d..c4504332e9b9 100644
--- a/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs
+++ b/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs
@@ -72,6 +72,15 @@ private static bool IsInRequiresScope (this ISymbol member, string requiresAttri
 			if (checkAssociatedSymbol && member is IMethodSymbol { AssociatedSymbol: { } associated } && associated.HasAttribute (requiresAttribute))
 				return true;
 
+			// When using instance fields suppress the warning if the constructor has already the Requires annotation
+			if (member is IFieldSymbol field && !field.IsStatic) {
+				foreach (var constructor in field.ContainingType.InstanceConstructors) {
+					if (!constructor.HasAttribute (requiresAttribute))
+						return false;
+				}
+				return true;
+			}
+
 			return false;
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs
index a0ecc2e51a81..44de82e7f7c9 100644
--- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs
+++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs
@@ -25,6 +25,7 @@ public static void Main ()
 			TestRequiresOnBaseButNotOnDerived ();
 			TestRequiresOnDerivedButNotOnBase ();
 			TestRequiresOnBaseAndDerived ();
+			TestInstanceFieldSuppression ();
 			TestSuppressionsOnClass ();
 			TestStaticMethodOnRequiresTypeSuppressedByRequiresOnMethod ();
 			TestStaticConstructorCalls ();
@@ -246,6 +247,22 @@ static void TestInstanceFieldCallDontWarn ()
 			var _ = instance.field;
 		}
 
+		public class ClassWithInstanceFieldWhichInitsDangerousClass
+		{
+			private ClassWithRequires _instanceField = new ClassWithRequires ();
+
+			[RequiresUnreferencedCode ("Calling the constructor is dangerous")]
+			[RequiresDynamicCode ("Calling the constructor is dangerous")]
+			public ClassWithInstanceFieldWhichInitsDangerousClass () { }
+		}
+
+		[ExpectedWarning ("IL2026", "Calling the constructor is dangerous")]
+		[ExpectedWarning ("IL3050", "Calling the constructor is dangerous", ProducedBy = ProducedBy.Analyzer)]
+		static void TestInstanceFieldSuppression ()
+		{
+			_ = new ClassWithInstanceFieldWhichInitsDangerousClass ();
+		}
+
 		[RequiresUnreferencedCode ("Message for --StaticCtorTriggeredByMethodCall2--")]
 		[RequiresDynamicCode ("Message for --StaticCtorTriggeredByMethodCall2--")]
 		class StaticCtorTriggeredByMethodCall2

From 6252a2194dd32911db2c0669fc818555687d5570 Mon Sep 17 00:00:00 2001
From: Jackson Schuster <36744439+jtschuster@users.noreply.github.com>
Date: Mon, 15 Aug 2022 17:39:01 -0700
Subject: [PATCH 4/5] Use HashSet instead of List for _virtual_methods (#2976)

* Use a HashSet instead of List for MarkStep._virtual_methods
---
 src/linker/Linker.Steps/MarkStep.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/linker/Linker.Steps/MarkStep.cs b/src/linker/Linker.Steps/MarkStep.cs
index 66733c12a402..81b4b5909001 100644
--- a/src/linker/Linker.Steps/MarkStep.cs
+++ b/src/linker/Linker.Steps/MarkStep.cs
@@ -59,7 +59,7 @@ protected LinkContext Context {
 		}
 
 		protected Queue<(MethodDefinition, DependencyInfo, MessageOrigin)> _methods;
-		protected List<(MethodDefinition, MarkScopeStack.Scope)> _virtual_methods;
+		protected HashSet<(MethodDefinition, MarkScopeStack.Scope)> _virtual_methods;
 		protected Queue<AttributeProviderPair> _assemblyLevelAttributes;
 		readonly List<AttributeProviderPair> _ivt_attributes;
 		protected Queue<(AttributeProviderPair, DependencyInfo, MarkScopeStack.Scope)> _lateMarkedAttributes;
@@ -224,7 +224,7 @@ internal DynamicallyAccessedMembersTypeHierarchy DynamicallyAccessedMembersTypeH
 		public MarkStep ()
 		{
 			_methods = new Queue<(MethodDefinition, DependencyInfo, MessageOrigin)> ();
-			_virtual_methods = new List<(MethodDefinition, MarkScopeStack.Scope)> ();
+			_virtual_methods = new HashSet<(MethodDefinition, MarkScopeStack.Scope)> ();
 			_assemblyLevelAttributes = new Queue<AttributeProviderPair> ();
 			_ivt_attributes = new List<AttributeProviderPair> ();
 			_lateMarkedAttributes = new Queue<(AttributeProviderPair, DependencyInfo, MarkScopeStack.Scope)> ();
@@ -3352,7 +3352,6 @@ void MarkBaseMethods (MethodDefinition method)
 				if (base_method.DeclaringType.IsInterface && !method.DeclaringType.IsInterface) {
 					// These are all virtual, no need to check IsVirtual before adding to list
 					_virtual_methods.Add ((base_method, ScopeStack.CurrentScope));
-					// _virtual_methods is a list and might have duplicates, but it's mostly just used for override validation, so it shouldn't matter
 					continue;
 				}
 

From 313671b195b1b36d56a8888a9a0e12edaac52c57 Mon Sep 17 00:00:00 2001
From: Sven Boemer <sbomer@gmail.com>
Date: Tue, 23 Aug 2022 15:06:49 -0400
Subject: [PATCH 5/5] Add support for generic attributes (#2980) (#2997)

* Add generic attribute tests
* Update cecil
---
 external/cecil                                |  2 +-
 .../Attributes/GenericAttributes.cs           | 69 +++++++++++++++++++
 2 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 test/Mono.Linker.Tests.Cases/Attributes/GenericAttributes.cs

diff --git a/external/cecil b/external/cecil
index 2cd569a98964..1840b7410d37 160000
--- a/external/cecil
+++ b/external/cecil
@@ -1 +1 @@
-Subproject commit 2cd569a98964629b8fa88284a8b5af8077d5f9de
+Subproject commit 1840b7410d37a613e684b6f9650e39e2d4950bbb
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/GenericAttributes.cs b/test/Mono.Linker.Tests.Cases/Attributes/GenericAttributes.cs
new file mode 100644
index 000000000000..430fbc71417d
--- /dev/null
+++ b/test/Mono.Linker.Tests.Cases/Attributes/GenericAttributes.cs
@@ -0,0 +1,69 @@
+using System;
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Expectations.Metadata;
+
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	class GenericAttributes
+	{
+        static void Main ()
+        {
+            new WithGenericAttribute_OfString ();
+            new WithGenericAttribute_OfInt ();
+            new WithConstrainedGenericAttribute ();
+        }
+
+        [Kept]
+        [KeptAttributeAttribute (typeof (GenericAttribute<string>))]
+        [KeptMember (".ctor()")]
+        [GenericAttribute<string>("t", F = "f", P = "p")]
+        class WithGenericAttribute_OfString {
+        }
+
+        [Kept]
+        [KeptAttributeAttribute (typeof (GenericAttribute<int>))]
+        [KeptMember (".ctor()")]
+        [GenericAttribute<int>(1, F = 2, P = 3)]
+        class WithGenericAttribute_OfInt {
+        }
+
+        [Kept]
+        [KeptAttributeAttribute (typeof (ConstrainedGenericAttribute<DerivedFromConstraintType>))]
+        [KeptMember (".ctor()")]
+        [ConstrainedGenericAttribute<DerivedFromConstraintType>()]
+        class WithConstrainedGenericAttribute {
+        }
+
+        [KeptBaseType (typeof (Attribute))]
+        class GenericAttribute<T> : Attribute {
+            [Kept]
+            public GenericAttribute(T t) {}
+
+            [Kept]
+            public T F;
+
+            [Kept]
+            [KeptBackingField]
+            public T P {
+                get;
+                [Kept]
+                set;
+            }
+        }
+
+        [Kept]
+        class ConstraintType {
+        }
+
+        [KeptBaseType (typeof (ConstraintType))]
+        class DerivedFromConstraintType : ConstraintType {
+        }
+
+        [KeptBaseType (typeof (Attribute))]
+        class ConstrainedGenericAttribute<T> : Attribute
+            where T : ConstraintType {
+            [Kept]
+            public ConstrainedGenericAttribute() {}
+        }
+    }
+}
\ No newline at end of file