Support "type granularity" option

src/ILLink.Tasks/LinkTask.cs

@@ -158,6 +158,13 @@ protected override string GenerateResponseFileCommands ()
 					args.Append (action);
 					args.Append (" ").AppendLine (Quote (assemblyName));
 				}
+
+				string actionflag = assembly.GetMetadata ("actionflag");
+				if ((actionflag != null) && (actionflag.Length > 0)) {
+					args.Append ("-f ");
+					args.Append (actionflag);
+					args.Append (" ").AppendLine (Quote (assemblyName));
+				}
 			}
 
 			if (ReferenceAssemblyPaths != null) {

src/linker/Linker.Steps/MarkStep.cs

@@ -1699,6 +1699,10 @@ void ApplyPreserveInfo (TypeDefinition type)
 		{
 			ApplyPreserveMethods (type);
 
+			if (_context.HasActionFlag(type.Module.Assembly, AssemblyActionFlag.TypeGranularity)) {
+				Annotations.SetPreserve (type, TypePreserve.All);
+			}
+
 			if (!Annotations.TryGetPreserve (type, out TypePreserve preserve))
 				return;
 

src/linker/Linker/AssemblyActionFlag.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Mono.Linker {
+	[Flags]
+	public enum AssemblyActionFlag : int {
+		// If there is any reference to a type, preserve all members in that type
+		TypeGranularity = 1,
+	}
+}

src/linker/Linker/Driver.cs

@@ -309,6 +309,13 @@ public void Run (ILogger customLogger = null)
 						AssemblyAction action = ParseAssemblyAction (GetParam ());
 						context.Actions [GetParam ()] = action;
 						break;
+					case 'f':
+						AssemblyActionFlag newFlag = ParseAssemblyActionFlag (GetParam ());
+						string flagTargetName = GetParam ();
+						context.ActionFlags [flagTargetName] = context.ActionFlags.TryGetValue (flagTargetName, out AssemblyActionFlag existingFlag)
+							? existingFlag | newFlag
+							: newFlag;
+						break;
 					case 't':
 						context.KeepTypeForwarderOnlyAssemblies = true;
 						break;
@@ -535,6 +542,11 @@ AssemblyAction ParseAssemblyAction (string s)
 			return assemblyAction;
 		}
 
+		AssemblyActionFlag ParseAssemblyActionFlag (string s)
+		{
+			return (AssemblyActionFlag)Enum.Parse (typeof (AssemblyActionFlag), s, true);
+		}
+
 		string GetParam ()
 		{
 			if (_queue.Count == 0)
@@ -591,6 +603,8 @@ static void Usage (string msg)
 			Console.WriteLine ("                        addbypassngenused: Same as addbypassngen but unused assemblies are removed");
 			Console.WriteLine ("  -u <action>         Action on the user assemblies. Defaults to 'link'");
 			Console.WriteLine ("  -p <action> <name>  Overrides the default action for an assembly");
+			Console.WriteLine ("  -f <flag> <name>    Adds a linker action flag for an assembly");
+			Console.WriteLine ("                        typegranularity: If there is any reference to a type, preserve the whole type");
 
 			Console.WriteLine ();
 			Console.WriteLine ("Advanced");

src/linker/Linker/LinkContext.cs

@@ -47,6 +47,7 @@ public class LinkContext : IDisposable {
 		AssemblyAction _userAction;
 		Dictionary<string, AssemblyAction> _actions;
 		string _outputDirectory;
+		readonly Dictionary<string, AssemblyActionFlag> _actionFlags;
 		readonly Dictionary<string, string> _parameters;
 		bool _linkSymbols;
 		bool _keepTypeForwarderOnlyAssemblies;
@@ -123,6 +124,10 @@ public System.Collections.IDictionary Actions {
 			get { return _actions; }
 		}
 
+		public IDictionary<string, AssemblyActionFlag> ActionFlags {
+			get { return _actionFlags; }
+		}
+
 		public AssemblyResolver Resolver {
 			get { return _resolver; }
 		}
@@ -178,6 +183,7 @@ public LinkContext (Pipeline pipeline, AssemblyResolver resolver, ReaderParamete
 			_resolver = resolver;
 			_resolver.Context = this;
 			_actions = new Dictionary<string, AssemblyAction> ();
+			_actionFlags = new Dictionary<string, AssemblyActionFlag> ();
 			_parameters = new Dictionary<string, string> ();
 			_readerParameters = readerParameters;
 
@@ -400,6 +406,12 @@ public string GetParameter (string key)
 			return val;
 		}
 
+		public bool HasActionFlag (AssemblyDefinition assembly, AssemblyActionFlag flag)
+		{
+			return ActionFlags.TryGetValue (assembly.Name.Name, out AssemblyActionFlag foundFlags)
+				&& foundFlags.HasFlag (flag);
+		}
+
 		public void Dispose ()
 		{
 			_resolver.Dispose ();

test/Mono.Linker.Tests.Cases/TypeGranularity/UsedTypeKeepsAllMembersWithTypeGranularity.cs

@@ -0,0 +1,34 @@
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Expectations.Metadata;
+using System;
+
+namespace Mono.Linker.Tests.Cases.TypeGranularity
+{
+	[SetupLinkerArgument ("-f", "typegranularity", "test")]
+	static class UsedTypeKeepsAllMembersWithTypeGranularity {
+		public static void Main() {
+			GC.KeepAlive (typeof(ReferencedClass));
+		}
+
+		[KeptMember (".ctor()")]
+		class ReferencedClass {
+			[Kept]
+			[KeptBackingField]
+			public int Prop { [Kept] get; [Kept] set; }
+
+			[Kept]
+			public void SomeMethod() {
+				Console.WriteLine (typeof (KeptNestedClass));
+			}
+
+			[KeptMember (".ctor()")]
+			class KeptNestedClass { }
+
+			// Unkept because nested types are not members. Type-level granularity doesn't
+			// preserve nested classes unless there is a reference to them.
+			class UnkeptNestedClass {
+				public string unkeptField;
+			}
+		}
+	}
+}

test/Mono.Linker.Tests/TestCases/TestDatabase.cs

@@ -91,6 +91,11 @@ public static IEnumerable<TestCaseData> PreserveDependenciesTests ()
 			return NUnitCasesBySuiteName ("PreserveDependencies");
 		}
 
+		public static IEnumerable<TestCaseData> TypeGranularityTests ()
+		{
+			return NUnitCasesBySuiteName ("TypeGranularity");
+		}
+
 		public static IEnumerable<TestCaseData> LibrariesTests ()
 		{
 			return NUnitCasesBySuiteName ("Libraries");

test/Mono.Linker.Tests/TestCases/TestSuites.cs

@@ -103,6 +103,12 @@ public void PreserveDependenciesTests (TestCase testCase)
 			Run (testCase);
 		}
 
+		[TestCaseSource (typeof (TestDatabase), nameof (TestDatabase.TypeGranularityTests))]
+		public void TypeGranularityTests (TestCase testCase)
+		{
+			Run (testCase);
+		}
+
 		[TestCaseSource (typeof (TestDatabase), nameof (TestDatabase.SymbolsTests))]
 		public void SymbolsTests (TestCase testCase)
 		{