MobileMarkStep.cs

// Copyright 2011-2013 Xamarin Inc., All rights reserved.
// adapted from MonoTouchMarkStep.cs, itself
// adapted from xtouch/tools/mtouch/Touch.Tuner/ManualMarkStep.cs

using System;
using System.Collections.Generic;
using Mono.Cecil;
using Mono.Linker;
using Mono.Linker.Steps;
using Mono.Tuner;

using Xamarin.Tuner;

namespace Xamarin.Linker.Steps {

	// XML definition files have their limits, i.e. they are good to keep stuff around unconditionnally
	// e.g. we do not want to force all/most Socket code around (non-network apps) because some types have unmanaged representation
	//
	// Generated backend fields inside monomac.dll are also removed if only used (i.e. set to null)
	// inside the Dispose method
	public class MobileMarkStep : MarkStep {

		protected virtual bool DebugBuild { get; set; }

		protected DerivedLinkContext LinkContext {
			get {
				return (DerivedLinkContext) base._context;
			}
		}

		protected AssemblyDefinition GetAssembly (string assemblyName)
		{
			AssemblyDefinition ad;
			_context.TryGetLinkedAssembly (assemblyName, out ad);
			return ad;
		}

		protected TypeDefinition GetType (string assemblyName, string typeName)
		{
			AssemblyDefinition ad = GetAssembly (assemblyName);
			return ad is null ? null : GetType (ad, typeName);
		}

		protected TypeDefinition GetType (AssemblyDefinition assembly, string typeName)
		{
			return assembly.MainModule.GetType (typeName);
		}

		protected override TypeDefinition MarkType (TypeReference reference)
		{
			TypeDefinition type = base.MarkType (GetOriginalType (reference));
			if (type is null)
				return null;

			switch (type.Module.Assembly.Name.Name) {
			case "mscorlib":
				ProcessCorlib (type);
				break;
			case "System":
				ProcessSystem (type);
				break;
			case "System.Core":
				ProcessSystemCore (type);
				break;
			case "System.Data":
				ProcessSystemData (type);
				break;
			case "System.Data.Services.Client":
				ProcessSystemDataServicesClient (type);
				break;
			case "System.Runtime.Serialization":
				ProcessSystemRuntimeSerialization (type);
				break;
			case "System.ServiceModel":
				ProcessSystemServiceModel (type);
				break;
			case "System.Web.Services":
				ProcessSystemWebServices (type);
				break;
			case "System.Xml":
				ProcessSystemXml (type);
				break;
			case "System.Xml.Linq":
				ProcessSystemXmlLinq (type);
				break;
			case "Mono.Security":
				ProcessMonoSecurity (type);
				break;
			case "System.ComponentModel.Composition":
				ProcessSystemComponentModelComposition (type);
				break;
			}

			return type;
		}

		protected override bool MarkMethods (TypeDefinition type)
		{
			// type can be null if we're not linking the assembly where the type reside,
			// e.g. --linkskip=System, in such case GetType returns null and an NRE can occur
			if (type is null)
				return false;
			return base.MarkMethods (type);
		}

		protected void MarkStaticMethods (TypeDefinition type)
		{
			if ((type is null) || !type.HasMethods)
				return;
			foreach (MethodDefinition m in type.Methods) {
				if (m.IsStatic)
					MarkMethod (m);
			}
		}

		protected void MarkConstructors (TypeDefinition type)
		{
			if ((type is null) || !type.HasMethods)
				return;
			foreach (MethodDefinition ctor in type.Methods) {
				if (ctor.IsConstructor)
					MarkMethod (ctor);
			}
		}

		protected IDictionary<string, List<MethodDefinition>> PInvokeModules { get; set; }

		protected override MethodDefinition MarkMethod (MethodReference reference)
		{
			var method = base.MarkMethod (reference);
			if ((method is not null) && !method.HasBody && method.IsPInvokeImpl) {
				// for some C++ stuff HasPInvokeInfo can be true without giving back any info
				PInvokeInfo info = method.PInvokeInfo;
				if (info is not null) {
					var m = info.Module;
					Annotations.Mark (m);
					string name = m.Name;
					if (PInvokeModules is not null && !String.IsNullOrEmpty (name)) {
						List<MethodDefinition> methods;
						if (!PInvokeModules.TryGetValue (name, out methods))
							PInvokeModules.Add (name, methods = new List<MethodDefinition> ());
						methods.Add (method);
					}
				}
			}

			return method;
		}

		protected override void MarkCustomAttribute (CustomAttribute ca)
		{
			base.MarkCustomAttribute (ca);

			if (ca.HasConstructorArguments) {
				PreserveTypeConverters (ca);
				if (DebugBuild)
					PreserveDebuggerAttributes (ca);
			}
		}

		void PreserveTypeConverters (CustomAttribute ca)
		{
			if (!ca.Constructor.DeclaringType.Is ("System.ComponentModel", "TypeConverterAttribute"))
				return;

			var type = (ca.ConstructorArguments [0].Value as TypeReference);
			// note: it could be a string (valid or not) and we do not support that since it's too late
			// to add new assemblies into the pipeline
			if (type is not null)
				MarkDefaultConstructor (type.Resolve ());
		}

		void PreserveDebuggerAttributes (CustomAttribute ca)
		{
			if (!ca.AttributeType.Is ("System.Diagnostics", "DebuggerTypeProxyAttribute"))
				return;

			// preserve the type of the proxy for better debugging
			var arg = ca.ConstructorArguments [0];
			var type = arg.Type;
			if (!type.Is ("System", "Type"))
				return;

			var tr = (arg.Value as TypeReference);
			if (tr is null)
				return;

			var td = tr.Resolve ();
			// the debugger will instantiate the ctor (signature based on the type)
			MarkConstructors (td);
			// and will query its properties (getters), so they must be preserved
			// anything else will be marked when the linker process the code
			if (!td.HasProperties)
				return;
			foreach (var p in td.Properties) {
				MarkProperty (p);
				MarkMethod (p.GetMethod);
			}
		}

		// let product filters what get's included to help preserve extraneous serialization members
		// e.g. ensure we don't keep stuff that triggers DRM checks
		protected virtual IMetadataTokenProvider FilterExtraSerializationMembers (IMetadataTokenProvider provider)
		{
			return provider;
		}

		// in the cases where tracking the type is not possible (or easy), e.g. instances kept in a collection
		void MarkMetadata (IMetadataTokenProvider tp)
		{
			var provider = FilterExtraSerializationMembers (tp);
			if (provider is null)
				return;

			TypeReference tr = (provider as TypeReference);
			if (tr is not null) {
				MarkType (tr);
				return;
			}
			MethodReference mr = (provider as MethodReference);
			if (mr is not null) {
				MarkMethod (mr);
				return;
			}
			PropertyDefinition pd = (provider as PropertyDefinition);
			if (pd is not null) {
				MarkProperty (pd);
				if (pd.GetMethod is not null)
					MarkMethod (pd.GetMethod);
				if (pd.SetMethod is not null)
					MarkMethod (pd.SetMethod);
				return;
			}
			FieldReference fr = (provider as FieldReference);
			if (fr is not null) {
				MarkField (fr);
				return;
			}
			EventDefinition ed = (provider as EventDefinition);
			if (ed is not null) {
				MarkEvent (ed);
				return;
			}
			throw new NotImplementedException (provider.ToString ());
		}

		// FIXME: we could be more precise (per field) but that would require a lot more maintenance for a very small gain

		void ProcessCorlib (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Runtime.CompilerServices":
				switch (type.Name) {
				case "AsyncTaskMethodBuilder":
				case "AsyncTaskMethodBuilder`1":
					if (DebugBuild) {
						MarkNamedMethod (type, "SetNotificationForWaitCompletion");
						MarkNamedMethod (type, "get_ObjectIdForDebugger");
					}
					break;
				}
				break;
			case "System.Threading.Tasks":
				switch (type.Name) {
				case "Task":
					if (DebugBuild)
						MarkNamedMethod (type, "NotifyDebuggerOfWaitCompletion");
					break;
				}
				break;
			case "System.Security.Cryptography":
				switch (type.Name) {
				case "Aes":
#if MONOTOUCH
					// Aes uses Activator.Create to be able to instantiate types from System.Core
					TypeDefinition aes = GetType ("System.Core", "System.Security.Cryptography.AesManaged");
					MarkMethods (aes);
#else
					// for historical reasons monotouch.dll shipped AesManaged and XA used (mono default's) CSP
					TypeDefinition aes = GetType ("System.Core", "System.Security.Cryptography.AesCryptoServiceProvider");
					MarkMethods (aes);
#endif
					break;
				}
				break;
			}
		}

		void ProcessSystem (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.ComponentModel":
				switch (type.Name) {
				case "TypeDescriptor":
					// DefaultConverters are created using Activator.CreateInstance
					// keep in sync with ReflectTypeDescriptionProvider.cs
					MarkMethods (GetType ("System", "System.ComponentModel.BooleanConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.ByteConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.SByteConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.CharConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.DoubleConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.StringConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.Int32Converter"));
					MarkMethods (GetType ("System", "System.ComponentModel.Int16Converter"));
					MarkMethods (GetType ("System", "System.ComponentModel.Int64Converter"));
					MarkMethods (GetType ("System", "System.ComponentModel.SingleConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.UInt16Converter"));
					MarkMethods (GetType ("System", "System.ComponentModel.UInt32Converter"));
					MarkMethods (GetType ("System", "System.ComponentModel.UInt64Converter"));
					MarkMethods (GetType ("System", "System.ComponentModel.TypeConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.CultureInfoConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.DateTimeConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.DateTimeOffsetConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.DecimalConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.TimeSpanConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.GuidConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.ArrayConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.CollectionConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.EnumConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.ReferenceConverter"));
					MarkMethods (GetType ("System", "System.ComponentModel.NullableConverter"));
					// special case - it's not in the Hashtable from the above file (but needed)
					MarkMethods (GetType ("System", "System.ComponentModel.ComponentConverter"));
					break;
				}
				break;
			case "System.Diagnostics":
				switch (type.Name) {
				// see mono/metadata/process.c
				case "FileVersionInfo":
				case "ProcessModule":
					// fields are initialized by the runtime, if the type is here then all (instance) fields must be present
					MarkFields (type, false);
					break;
				}
				break;
			case "System.Net.Sockets":
				switch (type.Name) {
				case "IPAddress":
					// mono/metadata/socket-io.c directly access 'm_Address' and 'm_Numbers'
					MarkFields (type, false);
					break;
				case "IPv6MulticastOption":
					// mono/metadata/socket-io.c directly access 'group' and 'ifIndex' private instance fields
					MarkFields (type, false);
					break;
				case "LingerOption":
					// mono/metadata/socket-io.c directly access 'enabled' and 'seconds' private instance fields
					MarkFields (type, false);
					break;
				case "MulticastOption":
					// mono/metadata/socket-io.c directly access 'group' and 'local' private instance fields
					MarkFields (type, false);
					break;
				case "Socket":
					// mono/metadata/socket-io.c directly access 'ipv4Supported', 'ipv6Supported' (static) and 'socket' (instance)
					MarkFields (type, true);
					break;
				case "SocketAddress":
					// mono/metadata/socket-io.c directly access 'data'
					MarkFields (type, false);
					break;
				}
				break;
			case "":
				if (!type.IsNested)
					break;

				switch (type.Name) {
				case "SocketAsyncResult":
					// mono/metadata/socket-io.h defines this structure (MonoSocketAsyncResult) for the runtime usage
					MarkFields (type, false);
					break;
				case "ProcessAsyncReader":
					// mono/metadata/socket-io.h defines this structure (MonoSocketAsyncResult) for the runtime usage
					MarkFields (type, false);
					break;
				}
				break;
			}
		}

		void ProcessSystemCore (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Linq":
				switch (type.Name) {
				case "Queryable":
					// reflection is used and the generic version might not be used elsewhere in the app, ref: #37563
					TypeDefinition enumquery = GetType ("System.Core", "System.Linq.EnumerableQuery`1");
					MarkConstructors (enumquery);
					// corefx/src/System.Linq.Queryable/src/System/Linq/EnumerableRewriter.cs relies on reflection
					// and assume that <quote>All static methods with arguments on Queryable have equivalents on Enumerable.</quote>
					// ref: https://github.com/xamarin/xamarin-macios/issues/6346
					TypeDefinition enumerable = GetType ("System.Core", "System.Linq.Enumerable");
					MarkStaticMethods (enumerable);
					break;
				}
				break;
			case "System.Linq.Expressions":
				switch (type.Name) {
				case "Expression`1":
					// internal Expression (Expression body, ReadOnlyCollection<ParameterExpression> parameters)
					// is called thru reflection by Expression.CreateExpressionOf and since it does a 
					// `typeof(Expression<>)` we have our clue to include the (lone) .ctor - ref bug #14863
					MarkConstructors (type);
					break;
				}
				break;
			}
		}

		void ProcessSystemData (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Data.SqlTypes":
				switch (type.Name) {
				case "SqlXml":
					// TODO: Needed only if CreateSqlReaderDelegate is used
					TypeDefinition xml_reader = GetType ("System.Xml", "System.Xml.XmlReader");
					MarkNamedMethod (xml_reader, "CreateSqlReader");
					break;
				}
				break;
			}
		}

		void ProcessSystemDataServicesClient (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Data.Services.Client":
				switch (type.Name) {
				case "TypeSystem":
					// the .cctor does a bunch of reflection on String, DateTime and Math members
					// some stuff on Microsoft.VisualBasic too but we do not ship that
					TypeDefinition string_td = GetType ("mscorlib", "System.String");
					MarkNamedMethod (string_td, "Contains");
					MarkNamedMethod (string_td, "EndsWith");
					MarkNamedMethod (string_td, "StartsWith");
					MarkNamedMethod (string_td, "IndexOf");
					MarkNamedMethod (string_td, "Replace");
					MarkNamedMethod (string_td, "Substring");
					MarkNamedMethod (string_td, "ToLower");
					MarkNamedMethod (string_td, "ToUpper");
					MarkNamedMethod (string_td, "Trim");
					MarkNamedMethod (string_td, "Concat");
					MarkNamedMethod (string_td, "get_Length");
					TypeDefinition datetime_td = GetType ("mscorlib", "System.DateTime");
					MarkNamedMethod (datetime_td, "get_Day");
					MarkNamedMethod (datetime_td, "get_Hour");
					MarkNamedMethod (datetime_td, "get_Month");
					MarkNamedMethod (datetime_td, "get_Minute");
					MarkNamedMethod (datetime_td, "get_Second");
					MarkNamedMethod (datetime_td, "get_Year");
					TypeDefinition math_td = GetType ("mscorlib", "System.Math");
					MarkNamedMethod (math_td, "Round");
					MarkNamedMethod (math_td, "Floor");
					MarkNamedMethod (math_td, "Ceiling");
					break;
				}
				break;
			}
		}

		bool system_runtime_serialization = false;

		void ProcessSystemRuntimeSerialization (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Runtime.Serialization.Json":
				switch (type.Name) {
				case "JsonSerializationWriter":
					// note: "Item" (indexer) is also used thru reflection but you can't create an app without it
					TypeDefinition dic = GetType ("mscorlib", "System.Collections.Generic.Dictionary`2");
					MarkNamedMethod (dic, "get_Keys");
					break;
				case "JsonFormatWriterInterpreter":
					TypeDefinition jwd = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.Json.JsonWriterDelegator");
					MarkMethods (jwd);
					break;
				}
				break;
			case "System.Runtime.Serialization":
				// MS referencesource use reflection to call the required methods to serialize each PrimitiveDataContract subclasses
				// this goes thru XmlFormatGeneratorStatics and it's a better candidate (than PrimitiveDataContract) as there are other callers
				switch (type.Name) {
				case "XmlFormatGeneratorStatics":
					TypeDefinition xwd = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlWriterDelegator");
					MarkMethods (xwd);
					TypeDefinition xoswc = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlObjectSerializerWriteContext");
					MarkMethods (xoswc);
					TypeDefinition xosrc = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlObjectSerializerReadContext");
					MarkMethods (xosrc);
					TypeDefinition xrd = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlReaderDelegator");
					MarkMethods (xrd);
					break;
				case "CollectionDataContract":
					// ensure the nested type, DictionaryEnumerator and GenericDictionaryEnumerator`2, can be created thru reflection
					foreach (var nt in type.NestedTypes)
						MarkConstructors (nt);
					break;
				}

				if (system_runtime_serialization)
					break;
				system_runtime_serialization = true;
				// if we're keeping this assembly and use the Serialization namespace inside user code then we
				// must bring the all the members decorated with [Data[Contract|Member]] attributes from the SDK
				var members = LinkContext.DataContract;
				foreach (var member in members)
					MarkMetadata (member);
				members.Clear ();
				break;
			}
		}

		void ProcessSystemServiceModel (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.ServiceModel.MonoInternal":
				switch (type.Name) {
				case "ClientRuntimeChannel":
					TypeDefinition nop = GetType ("System.ServiceModel", "System.ServiceModel.Channels.IChannelFactory`1");
					MarkNamedMethod (nop, "CreateChannel");
					break;
				}
				break;
			}
		}

		bool system_web_services_description = false;

		void ProcessSystemWebServices (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Web.Services.Description":
				if (system_web_services_description)
					break;
				system_web_services_description = true;
				// that's an all-or-nothing proposition: the whole hand will be taken if you point a finger at it
				foreach (var t in type.Module.Assembly.MainModule.Types) {
					if (t.Namespace != "System.Web.Services.Description")
						continue;
					MarkMethods (GetType ("System.Web.Services", t.FullName));
				}
				break;
			}
		}

		bool system_xml_serialization = false;

		void ProcessSystemXml (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Xml.Xsl":
				switch (type.Name) {
				case "XslCompiledTransform":
					TypeDefinition nop = GetType ("System.Xml", "System.Xml.Xsl.NoOperationDebugger");
					// only available on the mobile profile
					if (nop is not null) {
						MarkNamedMethod (nop, "OnCompile");
						MarkNamedMethod (nop, "OnExecute");
					}
					break;
				}
				break;
			case "System.Xml.Serialization":
				if (system_xml_serialization)
					break;
				switch (type.Name) {
				case "XmlIgnoreAttribute":
					break;
				default:
					// if we're keeping this assembly and use the Serialization namespace inside user code
					// then we must bring the all the members decorated with [Xml*] attributes from the SDK
					system_xml_serialization = true;
					var members = LinkContext.XmlSerialization;
					foreach (var member in members)
						MarkMetadata (member);
					members.Clear ();
					break;
				}
				break;
			}
		}

		void ProcessSystemXmlLinq (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.Xml.Linq":
				switch (type.Name) {
				case "XElement":
					// The addition of [XmlTypeConvertor ("ConvertForAssignment")] means the linker must keep the
					// ConvertForAssignment method around
					MarkNamedMethod (type, "ConvertForAssignment");
					break;
				}
				break;
			}
		}

		void ProcessMonoSecurity (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "Mono.Security.Protocol.Tls":
				switch (type.Name) {
				case "SslClientStream":
					MarkNamedMethod (type, "get_SelectedClientCertificate");
					break;
				case "SslStreamBase":
					MarkNamedMethod (type, "get_ServerCertificate");
					break;
				}
				break;
			}
		}

		void ProcessSystemComponentModelComposition (TypeDefinition type)
		{
			switch (type.Namespace) {
			case "System.ComponentModel.Composition":
				switch (type.Name) {
				case "ExportServices":
					MarkNamedMethod (type, "CreateStronglyTypedLazyOfT");
					MarkNamedMethod (type, "CreateStronglyTypedLazyOfTM");
					MarkNamedMethod (type, "CreateSemiStronglyTypedLazy");
					break;
				}
				break;
			case "System.ComponentModel.Composition.ReflectionModel":
				switch (type.Name) {
				case "ExportFactoryCreator":
					MarkNamedMethod (type, "CreateStronglyTypedExportFactoryOfT");
					MarkNamedMethod (type, "CreateStronglyTypedExportFactoryOfTM");
					break;
				}
				break;
			}
		}
	}
}