[Java.Interop.Tools.*] IMetadataResolver not TypeDefinitionCache (#842)

Context: b81cfbb
Context: dotnet/android#5748
Context: dotnet/android#5748 (comment)
Commit b81cfbb introduced `TypeDefinitionCache`, which caches
`TypeReference.Resolve()` invocations so as to speed things up.
Enter dotnet/android#5748: we want to adopt some linker API
changes, and mono/linker's [`LinkContext` API][0] *also* has a
`TypeDefinition` cache construct.
Consequently, to "fully embrace" the new `LinkContext` API changes,
*large portions* of `Java.Interop.Tools.Cecil.dll` are copied so that
`LinkContext`'s caching can be used instead of `TypeDefinitionCache`'s
caching, because mono/linker doesn't use Java.Interop, and thus
can't use `TypeDefinitionCache`.
Clean this up and split the difference: "duplicate" the APIs in
`Java.Interop.Tools.Cecil.dll`,
`Java.Interop.Tools.JavaCallableWrappers.dll`, and
`src/Java.Interop.Tools.TypeNameMappings` so that instead of
optionally using `TypeDefinitionCache`, we instead permit the use
of the [`Mono.Cecil.IMetadataResolver` interface][1], which is a
"superset" of `TypeDefinitionCache` functionality.
Update `TypeDefinitionCache` to implement the `IMetadataResolver`
interface, implementing `IMetadataResolver.Resolve()` so that
previous caching functionality is preserved.
This *should* result in no breakage of existing xamarin-android code,
while allowing for a reasonable integration point between
`Java.Interop.Tools.Cecil.dll` and mono/linker, by way of
`IMetadataResolver`.
[0]: https://github.com/mono/linker/blob/30f2498c2a3de1f7e236d5793f5f1aca6e5ba456/src/linker/Linker/LinkContext.cs
[1]: https://github.com/mono/cecil/blob/e069cd8d25d5b61b0e28fe65e75959c20af7aa80/Mono.Cecil/MetadataResolver.cs#L22-L26

Author: jonpryor

src/Java.Interop.Tools.Cecil/Java.Interop.Tools.Cecil/MethodDefinitionRocks.cs

@@ -11,19 +11,22 @@ public static class MethodDefinitionRocks
 {
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod)=>
-GetBaseDefinition(method,cache:null);
+GetBaseDefinition(method,resolver:null);
 
-publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod,TypeDefinitionCache?cache)
+publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod,TypeDefinitionCache?cache)=>
+GetBaseDefinition(method,(IMetadataResolver?)cache);
+
+publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod,IMetadataResolver?resolver)
 {
 if(method.IsStatic||method.IsNewSlot||!method.IsVirtual)
 returnmethod;
 
-foreach(varbaseTypeinmethod.DeclaringType.GetBaseTypes(cache)){
+foreach(varbaseTypeinmethod.DeclaringType.GetBaseTypes(resolver)){
 foreach(varminbaseType.Methods){
 if(!m.IsConstructor&&
 m.Name==method.Name&&
 (m.IsVirtual||m.IsAbstract)&&
-AreParametersCompatibleWith(m.Parameters,method.Parameters,cache)){
+AreParametersCompatibleWith(m.Parameters,method.Parameters,resolver)){
 returnm;
 }
 }
@@ -33,14 +36,17 @@ public static MethodDefinition GetBaseDefinition (this MethodDefinition method,
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit)=>
-GetOverriddenMethods(method,inherit,cache:null);
+GetOverriddenMethods(method,inherit,resolver:null);
+
+publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit,TypeDefinitionCache?cache)=>
+GetOverriddenMethods(method,inherit,(IMetadataResolver?)cache);
 
-publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit,TypeDefinitionCache?cache)
+publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit,IMetadataResolver?resolver)
 {
 yieldreturnmethod;
 if(inherit){
 MethodDefinitionbaseMethod=method;
-while((baseMethod=method.GetBaseDefinition(cache))!=null&&baseMethod!=method){
+while((baseMethod=method.GetBaseDefinition(resolver))!=null&&baseMethod!=method){
 yieldreturnmethod;
 method=baseMethod;
 }
@@ -49,9 +55,12 @@ public static IEnumerable<MethodDefinition> GetOverriddenMethods (MethodDefiniti
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b)=>
-AreParametersCompatibleWith(a,b,cache:null);
+AreParametersCompatibleWith(a,b,resolver:null);
+
+publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b,TypeDefinitionCache?cache)=>
+AreParametersCompatibleWith(a,b,(IMetadataResolver?)cache);
 
-publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b,TypeDefinitionCache?cache)
+publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b,IMetadataResolver?resolver)
 {
 if(a.Count!=b.Count)
 returnfalse;
@@ -60,21 +69,21 @@ public static bool AreParametersCompatibleWith (this Collection<ParameterDefinit
 returntrue;
 
 for(inti=0;i<a.Count;i++)
-if(!IsParameterCompatibleWith(a[i].ParameterType,b[i].ParameterType,cache))
+if(!IsParameterCompatibleWith(a[i].ParameterType,b[i].ParameterType,resolver))
 returnfalse;
 
 returntrue;
 }
 
-staticboolIsParameterCompatibleWith(IModifierTypea,IModifierTypeb,TypeDefinitionCache?cache)
+staticboolIsParameterCompatibleWith(IModifierTypea,IModifierTypeb,IMetadataResolver?cache)
 {
 if(!IsParameterCompatibleWith(a.ModifierType,b.ModifierType,cache))
 returnfalse;
 
 returnIsParameterCompatibleWith(a.ElementType,b.ElementType,cache);
 }
 
-staticboolIsParameterCompatibleWith(TypeSpecificationa,TypeSpecificationb,TypeDefinitionCache?cache)
+staticboolIsParameterCompatibleWith(TypeSpecificationa,TypeSpecificationb,IMetadataResolver?cache)
 {
 if(aisGenericInstanceType)
 returnIsParameterCompatibleWith((GenericInstanceType)a,(GenericInstanceType)b,cache);
@@ -85,7 +94,7 @@ static bool IsParameterCompatibleWith (TypeSpecification a, TypeSpecification b,
 returnIsParameterCompatibleWith(a.ElementType,b.ElementType,cache);
 }
 
-staticboolIsParameterCompatibleWith(GenericInstanceTypea,GenericInstanceTypeb,TypeDefinitionCache?cache)
+staticboolIsParameterCompatibleWith(GenericInstanceTypea,GenericInstanceTypeb,IMetadataResolver?cache)
 {
 if(!IsParameterCompatibleWith(a.ElementType,b.ElementType,cache))
 returnfalse;
@@ -103,7 +112,7 @@ static bool IsParameterCompatibleWith (GenericInstanceType a, GenericInstanceTyp
 returntrue;
 }
 
-staticboolIsParameterCompatibleWith(TypeReferencea,TypeReferenceb,TypeDefinitionCache?cache)
+staticboolIsParameterCompatibleWith(TypeReferencea,TypeReferenceb,IMetadataResolver?cache)
 {
 if(aisTypeSpecification||bisTypeSpecification){
 if(a.GetType()!=b.GetType())

src/Java.Interop.Tools.Cecil/Java.Interop.Tools.Cecil/TypeDefinitionCache.cs

@@ -1,21 +1,39 @@
 usingSystem.Collections.Generic;
 usingMono.Cecil;
 
+usingJava.Interop.Tools.Diagnostics;
+
 namespaceJava.Interop.Tools.Cecil
 {
 /// <summary>
 /// A class for caching lookups from TypeReference -> TypeDefinition.
 /// Generally its lifetime should match an AssemblyResolver instance.
 /// </summary>
-publicclassTypeDefinitionCache
+publicclassTypeDefinitionCache:IMetadataResolver
 {
-readonlyDictionary<TypeReference,TypeDefinition>cache=newDictionary<TypeReference,TypeDefinition>();
+readonlyDictionary<TypeReference,TypeDefinition?>types=newDictionary<TypeReference,TypeDefinition?>();
+readonlyDictionary<FieldReference,FieldDefinition?>fields=newDictionary<FieldReference,FieldDefinition?>();
+readonlyDictionary<MethodReference,MethodDefinition?>methods=newDictionary<MethodReference,MethodDefinition?>();
 
-publicvirtualTypeDefinitionResolve(TypeReferencetypeReference)
+publicvirtualTypeDefinition?Resolve(TypeReferencetypeReference)
 {
-if(cache.TryGetValue(typeReference,outvartypeDefinition))
+if(types.TryGetValue(typeReference,outvartypeDefinition))
 returntypeDefinition;
-returncache[typeReference]=typeReference.Resolve();
+returntypes[typeReference]=typeReference.Resolve();
+}
+
+publicvirtualFieldDefinition?Resolve(FieldReferencefield)
+{
+if(fields.TryGetValue(field,outvarfieldDefinition))
+returnfieldDefinition;
+returnfields[field]=field.Resolve();
+}
+
+publicvirtualMethodDefinition?Resolve(MethodReferencemethod)
+{
+if(methods.TryGetValue(method,outvarmethodDefinition))
+returnmethodDefinition;
+returnmethods[method]=method.Resolve();
 }
 }
 }

src/Java.Interop.Tools.Cecil/Java.Interop.Tools.Cecil/TypeDefinitionRocks.cs

@@ -9,62 +9,74 @@ public static class TypeDefinitionRocks {
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype)=>
-GetBaseType(type,cache:null);
+GetBaseType(type,resolver:null);
 
-publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype,TypeDefinitionCache?cache)
+publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype,TypeDefinitionCache?cache)=>
+GetBaseType(type,(IMetadataResolver?)cache);
+
+publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype,IMetadataResolver?resolver)
 {
 varbt=type.BaseType;
 if(bt==null)
 returnnull;
-if(cache!=null)
-returncache.Resolve(bt);
+if(resolver!=null)
+returnresolver.Resolve(bt);
 returnbt.Resolve();
 }
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype)=>
-GetTypeAndBaseTypes(type,cache:null);
+GetTypeAndBaseTypes(type,resolver:null);
+
+publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype,TypeDefinitionCache?cache)=>
+GetTypeAndBaseTypes(type,(IMetadataResolver?)cache);
 
-publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype,TypeDefinitionCache?cache)
+publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype,IMetadataResolver?resolver)
 {
 TypeDefinition?t=type;
 
 while(t!=null){
 yieldreturnt;
-t=t.GetBaseType(cache);
+t=t.GetBaseType(resolver);
 }
 }
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype)=>
-GetBaseTypes(type,cache:null);
+GetBaseTypes(type,resolver:null);
 
-publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype,TypeDefinitionCache?cache)
+publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype,TypeDefinitionCache?cache)=>
+GetBaseTypes(type,(IMetadataResolver?)cache);
+
+publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype,IMetadataResolver?resolver)
 {
 TypeDefinition?t=type;
 
-while((t=t.GetBaseType(cache))!=null){
+while((t=t.GetBaseType(resolver))!=null){
 yieldreturnt;
 }
 }
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec)=>
-IsAssignableFrom(type,c,cache:null);
+IsAssignableFrom(type,c,resolver:null);
+
+publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec,TypeDefinitionCache?cache)=>
+IsAssignableFrom(type,c,(IMetadataResolver?)cache);
 
-publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec,TypeDefinitionCache?cache)
+publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec,IMetadataResolver?resolver)
 {
 if(type.FullName==c.FullName)
 returntrue;
-vard=c.Resolve();
+vard=(resolver?.Resolve(c))??c.Resolve();
 if(d==null)
 returnfalse;
-foreach(vartind.GetTypeAndBaseTypes(cache)){
+foreach(vartind.GetTypeAndBaseTypes(resolver)){
 if(type.FullName==t.FullName)
 returntrue;
 foreach(varifaceImplint.Interfaces){
 vari=ifaceImpl.InterfaceType;
-if(IsAssignableFrom(type,i,cache))
+if(IsAssignableFrom(type,i,resolver))
 returntrue;
 }
 }
@@ -73,11 +85,13 @@ public static bool IsAssignableFrom (this TypeReference type, TypeReference c, T
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName)=>
-IsSubclassOf(type,typeName,cache:null);
+IsSubclassOf(type,typeName,resolver:null);
 
-publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName,TypeDefinitionCache?cache)
+publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName,TypeDefinitionCache?cache)=>
+IsSubclassOf(type,typeName,(IMetadataResolver?)cache);
+publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName,IMetadataResolver?resolver)
 {
-foreach(vartintype.GetTypeAndBaseTypes(cache)){
+foreach(vartintype.GetTypeAndBaseTypes(resolver)){
 if(t.FullName==typeName){
 returntrue;
 }
@@ -87,11 +101,14 @@ public static bool IsSubclassOf (this TypeDefinition type, string typeName, Type
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName)=>
-ImplementsInterface(type,interfaceName,cache:null);
+ImplementsInterface(type,interfaceName,resolver:null);
 
-publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName,TypeDefinitionCache?cache)
+publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName,TypeDefinitionCache?cache)=>
+ImplementsInterface(type,interfaceName,(IMetadataResolver?)cache);
+
+publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName,IMetadataResolver?resolver)
 {
-foreach(vartintype.GetTypeAndBaseTypes(cache)){
+foreach(vartintype.GetTypeAndBaseTypes(resolver)){
 foreach(variint.Interfaces){
 if(i.InterfaceType.FullName==interfaceName){
 returntrue;
@@ -103,34 +120,43 @@ public static bool ImplementsInterface (this TypeDefinition type, string interfa
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticstringGetPartialAssemblyName(thisTypeReferencetype)=>
-GetPartialAssemblyName(type,cache:null);
+GetPartialAssemblyName(type,resolver:null);
+
+publicstaticstringGetPartialAssemblyName(thisTypeReferencetype,TypeDefinitionCache?cache)=>
+GetPartialAssemblyName(type,(IMetadataResolver?)cache);
 
-publicstaticstringGetPartialAssemblyName(thisTypeReferencetype,TypeDefinitionCache?cache)
+publicstaticstringGetPartialAssemblyName(thisTypeReferencetype,IMetadataResolver?resolver)
 {
-TypeDefinitiondef=cache!=null?cache.Resolve(type):type.Resolve();
+TypeDefinition?def=(resolver?.Resolve(type))??type.Resolve();
 return(def??type).Module.Assembly.Name.Name;
 }
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype)=>
-GetPartialAssemblyQualifiedName(type,cache:null);
+GetPartialAssemblyQualifiedName(type,resolver:null);
 
-publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCache?cache)
+publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCache?cache)=>
+GetPartialAssemblyQualifiedName(type,(IMetadataResolver?)cache);
+
+publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype,IMetadataResolver?resolver)
 {
 returnstring.Format("{0}, {1}",
 // Cecil likes to use '/' as the nested type separator, while
 // Reflection uses '+' as the nested type separator. Use Reflection.
 type.FullName.Replace('/','+'),
-type.GetPartialAssemblyName(cache));
+type.GetPartialAssemblyName(resolver));
 }
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype)=>
-GetAssemblyQualifiedName(type,cache:null);
+GetAssemblyQualifiedName(type,resolver:null);
+
+publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCache?cache)=>
+GetAssemblyQualifiedName(type,(IMetadataResolver?)cache);
 
-publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCache?cache)
+publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype,IMetadataResolver?resolver)
 {
-TypeDefinitiondef=cache!=null?cache.Resolve(type):type.Resolve();
+TypeDefinition?def=(resolver?.Resolve(type))??type.Resolve();
 returnstring.Format("{0}, {1}",
 // Cecil likes to use '/' as the nested type separator, while
 // Reflection uses '+' as the nested type separator. Use Reflection.

src/Java.Interop.Tools.JavaCallableWrappers/Java.Interop.Tools.JavaCallableWrappers/JavaCallableWrapperGenerator.cs

@@ -23,11 +23,11 @@ namespace Java.Interop.Tools.JavaCallableWrappers {
 publicclassJavaCallableWrapperGenerator{
 
 classJavaFieldInfo{
-publicJavaFieldInfo(MethodDefinitionmethod,stringfieldName,TypeDefinitionCachecache)
+publicJavaFieldInfo(MethodDefinitionmethod,stringfieldName,IMetadataResolverresolver)
 {
 this.FieldName=fieldName;
 InitializerName=method.Name;
-TypeName=JavaNativeTypeManager.ReturnTypeFromSignature(GetJniSignature(method,cache)).Type;
+TypeName=JavaNativeTypeManager.ReturnTypeFromSignature(GetJniSignature(method,resolver)).Type;
 IsStatic=method.IsStatic;
 Access=method.Attributes&MethodAttributes.MemberAccessMask;
 Annotations=GetAnnotationsString("\t",method.CustomAttributes);
@@ -54,15 +54,20 @@ public string GetJavaAccess ()
 List<Signature>methods=newList<Signature>();
 List<Signature>ctors=newList<Signature>();
 List<JavaCallableWrapperGenerator>children;
-readonlyTypeDefinitionCachecache;
+readonlyIMetadataResolvercache;
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log)
-:this(type,null,log,cache:null)
+:this(type,null,log,resolver:null)
 {}
 
 publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log,TypeDefinitionCachecache)
-:this(type,null,log,cache)
+:this(type,log,(IMetadataResolver)cache)
+{
+}
+
+publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log,IMetadataResolverresolver)
+:this(type,null,log,resolver)
 {
 if(type.HasNestedTypes){
 children=newList<JavaCallableWrapperGenerator>();
@@ -103,11 +108,11 @@ void AddNestedTypes (TypeDefinition type)
 HasExport|=children.Any(t =>t.HasExport);
 }
 
-JavaCallableWrapperGenerator(TypeDefinitiontype,stringouterType,Action<string,object[]>log,TypeDefinitionCachecache)
+JavaCallableWrapperGenerator(TypeDefinitiontype,stringouterType,Action<string,object[]>log,IMetadataResolverresolver)
 {
 this.type=type;
 this.log=log;
-this.cache=cache??newTypeDefinitionCache();
+this.cache=resolver??newTypeDefinitionCache();
 
 if(type.IsEnum||type.IsInterface||type.IsValueType)
 Diagnostic.Error(4200,LookupSource(type),Localization.Resources.JavaCallableWrappers_XA4200,type.FullName);
@@ -655,7 +660,7 @@ public Signature (MethodDefinition method, RegisterAttribute register, string ma
 Annotations=JavaCallableWrapperGenerator.GetAnnotationsString("\t",method.CustomAttributes);
 }
 
-publicSignature(MethodDefinitionmethod,ExportAttributeexport,TypeDefinitionCachecache)
+publicSignature(MethodDefinitionmethod,ExportAttributeexport,IMetadataResolvercache)
 :this(method.Name,GetJniSignature(method,cache),"__export__",null,null,export.SuperArgumentsString)
 {
 IsExport=true;
@@ -666,7 +671,7 @@ public Signature (MethodDefinition method, ExportAttribute export, TypeDefinitio
 Annotations=JavaCallableWrapperGenerator.GetAnnotationsString("\t",method.CustomAttributes);
 }
 
-publicSignature(MethodDefinitionmethod,ExportFieldAttributeexportField,TypeDefinitionCachecache)
+publicSignature(MethodDefinitionmethod,ExportFieldAttributeexportField,IMetadataResolvercache)
 :this(method.Name,GetJniSignature(method,cache),"__export__",null,null,null)
 {
 if(method.HasParameters)