[Java.Interop.Tools.JavaCallableWrappers] use IMetadataResolver more (#1069)

Context: b81cfbb
Reviewing code in `JavaCallableWrapperGenerator`, I found codepaths
where we weren't caching `TypeReference.Resolve()` calls *at all*,
e.g. `JavaNativeTypeManager.GetPrimitiveClass(TypeDefinition)`.
We thus appear to be calling `TypeReference.Resolve()` potentially on
the same types.
For example, `dotnet trace` output of an incremental build of a `dotnet new maui` project:
41.65ms xamarin.android.cecil!Mono.Cecil.TypeReference.Resolve()
It appears that, in trying to make our maintenance lives easier by
preserving backward API compatibility with callers that couldn't
provide a `TypeDefinitionCache` or `IMetadataResolver` instance -- by
providing method overloads which took e.g.
`IMetadataResolver? resolver` parameters which could be `null` -- we
made our optimization and performance lives *harder*, because not
all codepaths which needed to use caching *were* using caching, as
they were overlooked.
As the `Java.Interop.Tools.*` assemblies are internal API, introduce
an *API break* while preserving *ABI*:
`IMetadataResolver` is now required.
Thus, previous/current "compatibility methods" which allow *not*
providing an `IMetadataResolver` instance such as:
// old and busted
partial class TypeDefinitionRocks {
[Obsolete ("Use the TypeDefinitionCache overload for better performance.")] public static TypeDefinition? GetBaseType (this TypeDefinition type) => GetBaseType (type, resolver: null); }
will now become *errors* to use:
// new hawtness
partial class TypeDefinitionRocks {
[Obsolete ("Use the TypeDefinitionCache overload for better performance.", error:true)] public static TypeDefinition? GetBaseType (this TypeDefinition type) => throw new NotSupportedException ();
}
This allows the C# compiler to help us audit our codebase, ensuring
that *all* codepaths which call `TypeReference.Resolve()` instead use
`IMetadataResolver.Resolve()`, including:
* `JavaCallableWrapperGenerator.GetAnnotationsString()`
* `JavaCallableWrapperGenerator.WriteAnnotations()`
* `JavaNativeTypeManager.GetPrimitiveClass()`
Requiring caching results in:
23.89ms xamarin.android.cecil!Mono.Cecil.TypeReference.Resolve()
Additionally, I updated two places to use plain `foreach` loops
instead of using System.Linq.
* Before:
1.03s xamarin.android.build.tasks!Xamarin.Android.Tasks.GenerateJavaStubs.RunTask()
* After:
944.48ms xamarin.android.build.tasks!Xamarin.Android.Tasks.GenerateJavaStubs.RunTask()
I think this likely saves about ~50ms off incremental builds of a
`dotnet new maui` project.

Author: jonathanpeppers

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

@@ -9,14 +9,13 @@ namespace Java.Interop.Tools.Cecil {
 
 publicstaticclassMethodDefinitionRocks
 {
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod)=>
-GetBaseDefinition(method,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod)=>thrownewNotSupportedException();
 
-publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod,TypeDefinitionCache?cache)=>
-GetBaseDefinition(method,(IMetadataResolver?)cache);
+publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod,TypeDefinitionCachecache)=>
+GetBaseDefinition(method,(IMetadataResolver)cache);
 
-publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod,IMetadataResolver?resolver)
+publicstaticMethodDefinitionGetBaseDefinition(thisMethodDefinitionmethod,IMetadataResolverresolver)
 {
 if(method.IsStatic||method.IsNewSlot||!method.IsVirtual)
 returnmethod;
@@ -34,14 +33,13 @@ public static MethodDefinition GetBaseDefinition (this MethodDefinition method,
 returnmethod;
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit)=>
-GetOverriddenMethods(method,inherit,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit)=>thrownewNotSupportedException();
 
-publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit,TypeDefinitionCache?cache)=>
-GetOverriddenMethods(method,inherit,(IMetadataResolver?)cache);
+publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit,TypeDefinitionCachecache)=>
+GetOverriddenMethods(method,inherit,(IMetadataResolver)cache);
 
-publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit,IMetadataResolver?resolver)
+publicstaticIEnumerable<MethodDefinition>GetOverriddenMethods(MethodDefinitionmethod,boolinherit,IMetadataResolverresolver)
 {
 yieldreturnmethod;
 if(inherit){
@@ -53,14 +51,13 @@ public static IEnumerable<MethodDefinition> GetOverriddenMethods (MethodDefiniti
 }
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b)=>
-AreParametersCompatibleWith(a,b,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b)=>thrownewNotSupportedException();
 
-publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b,TypeDefinitionCache?cache)=>
-AreParametersCompatibleWith(a,b,(IMetadataResolver?)cache);
+publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b,TypeDefinitionCachecache)=>
+AreParametersCompatibleWith(a,b,(IMetadataResolver)cache);
 
-publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b,IMetadataResolver?resolver)
+publicstaticboolAreParametersCompatibleWith(thisCollection<ParameterDefinition>a,Collection<ParameterDefinition>b,IMetadataResolverresolver)
 {
 if(a.Count!=b.Count)
 returnfalse;
@@ -75,15 +72,15 @@ public static bool AreParametersCompatibleWith (this Collection<ParameterDefinit
 returntrue;
 }
 
-staticboolIsParameterCompatibleWith(IModifierTypea,IModifierTypeb,IMetadataResolver?cache)
+staticboolIsParameterCompatibleWith(IModifierTypea,IModifierTypeb,IMetadataResolvercache)
 {
 if(!IsParameterCompatibleWith(a.ModifierType,b.ModifierType,cache))
 returnfalse;
 
 returnIsParameterCompatibleWith(a.ElementType,b.ElementType,cache);
 }
 
-staticboolIsParameterCompatibleWith(TypeSpecificationa,TypeSpecificationb,IMetadataResolver?cache)
+staticboolIsParameterCompatibleWith(TypeSpecificationa,TypeSpecificationb,IMetadataResolvercache)
 {
 if(aisGenericInstanceType)
 returnIsParameterCompatibleWith((GenericInstanceType)a,(GenericInstanceType)b,cache);
@@ -94,7 +91,7 @@ static bool IsParameterCompatibleWith (TypeSpecification a, TypeSpecification b,
 returnIsParameterCompatibleWith(a.ElementType,b.ElementType,cache);
 }
 
-staticboolIsParameterCompatibleWith(GenericInstanceTypea,GenericInstanceTypeb,IMetadataResolver?cache)
+staticboolIsParameterCompatibleWith(GenericInstanceTypea,GenericInstanceTypeb,IMetadataResolvercache)
 {
 if(!IsParameterCompatibleWith(a.ElementType,b.ElementType,cache))
 returnfalse;
@@ -112,7 +109,7 @@ static bool IsParameterCompatibleWith (GenericInstanceType a, GenericInstanceTyp
 returntrue;
 }
 
-staticboolIsParameterCompatibleWith(TypeReferencea,TypeReferenceb,IMetadataResolver?cache)
+staticboolIsParameterCompatibleWith(TypeReferencea,TypeReferenceb,IMetadataResolvercache)
 {
 if(aisTypeSpecification||bisTypeSpecification){
 if(a.GetType()!=b.GetType())

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

@@ -7,31 +7,27 @@ namespace Java.Interop.Tools.Cecil {
 
 publicstaticclassTypeDefinitionRocks{
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype)=>
-GetBaseType(type,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype)=>thrownewNotSupportedException();
 
-publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype,TypeDefinitionCache?cache)=>
-GetBaseType(type,(IMetadataResolver?)cache);
+publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype,TypeDefinitionCachecache)=>
+GetBaseType(type,(IMetadataResolver)cache);
 
-publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype,IMetadataResolver?resolver)
+publicstaticTypeDefinition?GetBaseType(thisTypeDefinitiontype,IMetadataResolverresolver)
 {
 varbt=type.BaseType;
 if(bt==null)
 returnnull;
-if(resolver!=null)
-returnresolver.Resolve(bt);
-returnbt.Resolve();
+returnresolver.Resolve(bt);
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype)=>
-GetTypeAndBaseTypes(type,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype)=>thrownewNotSupportedException();
 
-publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype,TypeDefinitionCache?cache)=>
-GetTypeAndBaseTypes(type,(IMetadataResolver?)cache);
+publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype,TypeDefinitionCachecache)=>
+GetTypeAndBaseTypes(type,(IMetadataResolver)cache);
 
-publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype,IMetadataResolver?resolver)
+publicstaticIEnumerable<TypeDefinition>GetTypeAndBaseTypes(thisTypeDefinitiontype,IMetadataResolverresolver)
 {
 TypeDefinition?t=type;
 
@@ -41,14 +37,13 @@ public static IEnumerable<TypeDefinition> GetTypeAndBaseTypes (this TypeDefiniti
 }
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype)=>
-GetBaseTypes(type,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype)=>thrownewNotSupportedException();
 
-publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype,TypeDefinitionCache?cache)=>
-GetBaseTypes(type,(IMetadataResolver?)cache);
+publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype,TypeDefinitionCachecache)=>
+GetBaseTypes(type,(IMetadataResolver)cache);
 
-publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype,IMetadataResolver?resolver)
+publicstaticIEnumerable<TypeDefinition>GetBaseTypes(thisTypeDefinitiontype,IMetadataResolverresolver)
 {
 TypeDefinition?t=type;
 
@@ -57,18 +52,17 @@ public static IEnumerable<TypeDefinition> GetBaseTypes (this TypeDefinition type
 }
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec)=>
-IsAssignableFrom(type,c,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec)=>thrownewNotSupportedException();
 
-publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec,TypeDefinitionCache?cache)=>
-IsAssignableFrom(type,c,(IMetadataResolver?)cache);
+publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec,TypeDefinitionCachecache)=>
+IsAssignableFrom(type,c,(IMetadataResolver)cache);
 
-publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec,IMetadataResolver?resolver)
+publicstaticboolIsAssignableFrom(thisTypeReferencetype,TypeReferencec,IMetadataResolverresolver)
 {
 if(type.FullName==c.FullName)
 returntrue;
-vard=(resolver?.Resolve(c))??c.Resolve();
+vard=resolver.Resolve(c);
 if(d==null)
 returnfalse;
 foreach(vartind.GetTypeAndBaseTypes(resolver)){
@@ -83,13 +77,12 @@ public static bool IsAssignableFrom (this TypeReference type, TypeReference c, I
 returnfalse;
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName)=>
-IsSubclassOf(type,typeName,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName)=>thrownewNotSupportedException();
 
-publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName,TypeDefinitionCache?cache)=>
-IsSubclassOf(type,typeName,(IMetadataResolver?)cache);
-publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName,IMetadataResolver?resolver)
+publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName,TypeDefinitionCachecache)=>
+IsSubclassOf(type,typeName,(IMetadataResolver)cache);
+publicstaticboolIsSubclassOf(thisTypeDefinitiontype,stringtypeName,IMetadataResolverresolver)
 {
 foreach(vartintype.GetTypeAndBaseTypes(resolver)){
 if(t.FullName==typeName){
@@ -99,14 +92,13 @@ public static bool IsSubclassOf (this TypeDefinition type, string typeName, IMet
 returnfalse;
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName)=>
-ImplementsInterface(type,interfaceName,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName)=>thrownewNotSupportedException();
 
-publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName,TypeDefinitionCache?cache)=>
-ImplementsInterface(type,interfaceName,(IMetadataResolver?)cache);
+publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName,TypeDefinitionCachecache)=>
+ImplementsInterface(type,interfaceName,(IMetadataResolver)cache);
 
-publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName,IMetadataResolver?resolver)
+publicstaticboolImplementsInterface(thisTypeDefinitiontype,stringinterfaceName,IMetadataResolverresolver)
 {
 foreach(vartintype.GetTypeAndBaseTypes(resolver)){
 foreach(variint.Interfaces){
@@ -118,27 +110,25 @@ public static bool ImplementsInterface (this TypeDefinition type, string interfa
 returnfalse;
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticstringGetPartialAssemblyName(thisTypeReferencetype)=>
-GetPartialAssemblyName(type,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticstringGetPartialAssemblyName(thisTypeReferencetype)=>thrownewNotSupportedException();
 
-publicstaticstringGetPartialAssemblyName(thisTypeReferencetype,TypeDefinitionCache?cache)=>
-GetPartialAssemblyName(type,(IMetadataResolver?)cache);
+publicstaticstringGetPartialAssemblyName(thisTypeReferencetype,TypeDefinitionCachecache)=>
+GetPartialAssemblyName(type,(IMetadataResolver)cache);
 
-publicstaticstringGetPartialAssemblyName(thisTypeReferencetype,IMetadataResolver?resolver)
+publicstaticstringGetPartialAssemblyName(thisTypeReferencetype,IMetadataResolverresolver)
 {
-TypeDefinition?def=(resolver?.Resolve(type))??type.Resolve();
+TypeDefinition?def=resolver.Resolve(type);
 return(def??type).Module.Assembly.Name.Name;
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype)=>
-GetPartialAssemblyQualifiedName(type,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype)=>thrownewNotSupportedException();
 
-publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCache?cache)=>
-GetPartialAssemblyQualifiedName(type,(IMetadataResolver?)cache);
+publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCachecache)=>
+GetPartialAssemblyQualifiedName(type,(IMetadataResolver)cache);
 
-publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype,IMetadataResolver?resolver)
+publicstaticstringGetPartialAssemblyQualifiedName(thisTypeReferencetype,IMetadataResolverresolver)
 {
 returnstring.Format("{0}, {1}",
 // Cecil likes to use '/' as the nested type separator, while
@@ -147,16 +137,15 @@ public static string GetPartialAssemblyQualifiedName (this TypeReference type, I
 type.GetPartialAssemblyName(resolver));
 }
 
-[Obsolete("Use the TypeDefinitionCache overload for better performance.")]
-publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype)=>
-GetAssemblyQualifiedName(type,resolver:null);
+[Obsolete("Use the TypeDefinitionCache overload for better performance.",error:true)]
+publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype)=>thrownewNotSupportedException();
 
-publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCache?cache)=>
-GetAssemblyQualifiedName(type,(IMetadataResolver?)cache);
+publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype,TypeDefinitionCachecache)=>
+GetAssemblyQualifiedName(type,(IMetadataResolver)cache);
 
-publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype,IMetadataResolver?resolver)
+publicstaticstringGetAssemblyQualifiedName(thisTypeReferencetype,IMetadataResolverresolver)
 {
-TypeDefinition?def=(resolver?.Resolve(type))??type.Resolve();
+TypeDefinition?def=resolver.Resolve(type);
 returnstring.Format("{0}, {1}",
 // Cecil likes to use '/' as the nested type separator, while
 // Reflection uses '+' as the nested type separator. Use Reflection.