[mono-api-tools] Make the tools work as libraries (#9793)

Right now, the set of mono-api-tools only works as console apps. This PR will make them work as normal dlls so they can be consumed by other apps and libraries. They will still work as .exes, so nothing visibly changes for existing users.

The motivation for this is for some build process or third party tool to take an assembly and generate an .xml doc from it. Since the writer is in-memory, the tool can then parse the .xml and do whatever it needs to. The same goes for the diff tools - if the diff happens in-memory, then the tool can process it without having to save and then load from the file system.

## Libraries
 - [x] mono-api-info -> `Mono.ApiTools.ApiInfo`
 - [x] mono-api-diff -> `Mono.ApiTools.ApiDiff`
 - [x] mono-api-html -> `Mono.ApiTools.ApiDiffFormatted`

## Major changes
 - the existing `Driver` classes are now just thin wrappers to parse the args and pass it on to the generators
 - the "options" are now abstracted into config classes to avoid methods with numerous parameters
 - the APIs have new support for reading assembly and info `Stream`s instead of just file paths
 - added compiler flags to control the namespace and type visibility to make the library APIs nicer
 - added compiler flag to remove the `Driver` class and `Mono.Options` dependencies
 - the mono-api-info tool has some more options to allow it to run on libraries, and ignore dependencies that it cannot find - this makes it easier to use so that the entire dependency chain does not have to be loaded just to output the current assembly API

## Compiler defines
 - `EXCLUDE_DRIVER` will remove the console entry point and remove the dependency of Mono.Options
 - `USE_MONO_API_TOOLS_NAMESPACE` will switch the namespace to `Mono.ApiTools` so that libraries can have a nice API
 - `USE_INTERNAL_VISIBILITY` will make any non-essential, `public` APIs turn `internal`

## Review points
 - are there any variables/fields that are still static?
 - are there any exposed types/members that need to be hidden?
 - are the new names for the APIs and config classes OK?
 - are my whitespaces according to the guidelines?
 - did I go horribly wrong?

Author: mattleibow

mcs/tools/corcompare/AssemblyResolver.cs

@@ -32,19 +32,22 @@
 
 using Mono.Cecil;
 
-namespace GuiCompare {
+namespace Mono.ApiTools {
 
-	public class AssemblyResolver : DefaultAssemblyResolver {
+	class AssemblyResolver : DefaultAssemblyResolver {
 
 		public AssemblyDefinition ResolveFile (string file)
 		{
-			return ProcessFile (file);
+			AddSearchDirectory (Path.GetDirectoryName (file));
+			var assembly = AssemblyDefinition.ReadAssembly (file, new ReaderParameters { AssemblyResolver = this, InMemory = true });
+			RegisterAssembly (assembly);
+
+			return assembly;
 		}
 
-		AssemblyDefinition ProcessFile (string file)
+		public AssemblyDefinition ResolveStream (Stream stream)
 		{
-			AddSearchDirectory (Path.GetDirectoryName (file));
-			var assembly = AssemblyDefinition.ReadAssembly (file, new ReaderParameters { AssemblyResolver = this, InMemory = true });
+			var assembly = AssemblyDefinition.ReadAssembly (stream, new ReaderParameters { AssemblyResolver = this, InMemory = true });
 			RegisterAssembly (assembly);
 
 			return assembly;

mcs/tools/corcompare/Util.cs

@@ -3,32 +3,57 @@
 using System.Text;
 using Mono.Cecil;
 
-using GuiCompare;
+namespace Mono.ApiTools {
 
-namespace CorCompare {
+	class TypeHelper {
 
-	static class TypeHelper {
+		public TypeHelper (bool ignoreResolutionErrors, bool ignoreInheritedInterfaces)
+		{
+			IgnoreResolutionErrors = ignoreResolutionErrors;
+			IgnoreInheritedInterfaces = ignoreInheritedInterfaces;
+		}
+
+		public bool IgnoreResolutionErrors { get; }
+
+		public bool IgnoreInheritedInterfaces { get; }
 
-		public static AssemblyResolver Resolver = new AssemblyResolver ();
+		public AssemblyResolver Resolver { get; } = new AssemblyResolver();
 
-		internal static bool IsPublic (TypeReference typeref)
+		internal bool TryResolve (CustomAttribute attribute)
+		{
+			if (attribute == null)
+				throw new ArgumentNullException (nameof (attribute));
+
+			try {
+				var has = attribute.HasProperties;
+				return true;
+			} catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
+				return false;
+			}
+		}
+
+		internal bool IsPublic (TypeReference typeref)
 		{
 			if (typeref == null)
 				throw new ArgumentNullException ("typeref");
 
-			TypeDefinition td = typeref.Resolve ();
-			if (td == null)
-				return false;
+			try {
+				var td = typeref.Resolve ();
+				if (td == null)
+					return false;
 
-			return td.IsPublic;
+				return td.IsPublic || (td.IsNestedPublic && IsPublic (td.DeclaringType));
+			} catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
+				return true;
+			}
 		}
 
-		internal static bool IsDelegate (TypeReference typeref)
+		internal bool IsDelegate (TypeReference typeref)
 		{
 			return IsDerivedFrom (typeref, "System.MulticastDelegate");
 		}
 
-		internal static bool IsDerivedFrom (TypeReference type, string derivedFrom)
+		internal bool IsDerivedFrom (TypeReference type, string derivedFrom)
 		{
 			bool first = true;
 			foreach (var def in WalkHierarchy (type)) {
@@ -44,52 +69,71 @@ internal static bool IsDerivedFrom (TypeReference type, string derivedFrom)
 			return false;
 		}
 
-		internal static IEnumerable<TypeDefinition> WalkHierarchy (TypeReference type)
+		internal IEnumerable<TypeDefinition> WalkHierarchy (TypeReference type)
 		{
 			for (var def = type.Resolve (); def != null; def = GetBaseType (def))
 				yield return def;
 		}
 
-		internal static IEnumerable<TypeReference> GetInterfaces (TypeReference type)
+		internal IEnumerable<TypeReference> GetInterfaces (TypeReference type)
 		{
 			var ifaces = new Dictionary<string, TypeReference> ();
 
-			foreach (var def in WalkHierarchy (type))
+			foreach (var def in WalkHierarchy (type)) {
 				foreach (var iface in def.Interfaces)
 					ifaces [iface.InterfaceType.FullName] = iface.InterfaceType;
+				if (IgnoreInheritedInterfaces)
+					break;
+			}
 
 			return ifaces.Values;
 		}
 
-		internal static TypeDefinition GetBaseType (TypeDefinition child)
+		internal TypeDefinition GetBaseType (TypeDefinition child)
 		{
 			if (child.BaseType == null)
 				return null;
 
-			return child.BaseType.Resolve ();
+			try {
+				return child.BaseType.Resolve ();
+			} catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
+				return null;
+			}
+		}
+
+		internal MethodDefinition GetMethod (MethodReference method)
+		{
+			if (method == null)
+				throw new ArgumentNullException (nameof (method));
+
+			try {
+				return method.Resolve ();
+			} catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
+				return null;
+			}
 		}
 
-		internal static bool IsPublic (CustomAttribute att)
+		internal bool IsPublic (CustomAttribute att)
 		{
 			return IsPublic (att.AttributeType);
 		}
 
-		internal static string GetFullName (CustomAttribute att)
+		internal string GetFullName (CustomAttribute att)
 		{
 			return att.AttributeType.FullName;
 		}
 
-		internal static TypeDefinition GetTypeDefinition (CustomAttribute att)
+		internal TypeDefinition GetTypeDefinition (CustomAttribute att)
 		{
 			return att.AttributeType.Resolve ();
 		}
 
-		static bool IsOverride (MethodDefinition method)
+		bool IsOverride (MethodDefinition method)
 		{
 			return method.IsVirtual && !method.IsNewSlot;
 		}
 
-		public static MethodDefinition GetBaseMethodInTypeHierarchy (MethodDefinition method)
+		public MethodDefinition GetBaseMethodInTypeHierarchy (MethodDefinition method)
 		{
 			if (!IsOverride (method))
 				return method;
@@ -106,7 +150,7 @@ public static MethodDefinition GetBaseMethodInTypeHierarchy (MethodDefinition me
 			return method;
 		}
 
-		static MethodDefinition TryMatchMethod (TypeDefinition type, MethodDefinition method)
+		MethodDefinition TryMatchMethod (TypeDefinition type, MethodDefinition method)
 		{
 			if (!type.HasMethods)
 				return null;
@@ -118,7 +162,7 @@ static MethodDefinition TryMatchMethod (TypeDefinition type, MethodDefinition me
 			return null;
 		}
 
-		static bool MethodMatch (MethodDefinition candidate, MethodDefinition method)
+		bool MethodMatch (MethodDefinition candidate, MethodDefinition method)
 		{
 			if (!candidate.IsVirtual)
 				return false;
@@ -139,15 +183,15 @@ static bool MethodMatch (MethodDefinition candidate, MethodDefinition method)
 			return true;
 		}
 
-		public static bool TypeMatch (IModifierType a, IModifierType b)
+		public bool TypeMatch (IModifierType a, IModifierType b)
 		{
 			if (!TypeMatch (a.ModifierType, b.ModifierType))
 				return false;
 
 			return TypeMatch (a.ElementType, b.ElementType);
 		}
 
-		public static bool TypeMatch (TypeSpecification a, TypeSpecification b)
+		public bool TypeMatch (TypeSpecification a, TypeSpecification b)
 		{
 			if (a is GenericInstanceType)
 				return TypeMatch ((GenericInstanceType) a, (GenericInstanceType) b);
@@ -158,7 +202,7 @@ public static bool TypeMatch (TypeSpecification a, TypeSpecification b)
 			return TypeMatch (a.ElementType, b.ElementType);
 		}
 
-		public static bool TypeMatch (GenericInstanceType a, GenericInstanceType b)
+		public bool TypeMatch (GenericInstanceType a, GenericInstanceType b)
 		{
 			if (!TypeMatch (a.ElementType, b.ElementType))
 				return false;
@@ -176,7 +220,7 @@ public static bool TypeMatch (GenericInstanceType a, GenericInstanceType b)
 			return true;
 		}
 
-		public static bool TypeMatch (TypeReference a, TypeReference b)
+		public bool TypeMatch (TypeReference a, TypeReference b)
 		{
 			if (a is GenericParameter)
 				return true;

mcs/tools/corcompare/WellFormedXmlWriter.cs

@@ -11,9 +11,9 @@
 using System.Collections;
 using System.Xml;
 
-namespace CorCompare {
+namespace Mono.ApiTools {
 
-	public class WellFormedXmlWriter : DefaultXmlWriter
+	class WellFormedXmlWriter : DefaultXmlWriter
 	{
 		public static bool IsInvalid (int ch)
 		{
@@ -110,7 +110,7 @@ public override void WriteChars (char [] text, int idx, int length)
 
 	}
 
-	public class DefaultXmlWriter : XmlWriter
+	class DefaultXmlWriter : XmlWriter
 	{
 		XmlWriter writer;