// Returns true if a type was removed. bool RemoveMethod(JavaMethodModel method, TypeResolutionOptions options) { // We cannot remove a non-static, non-default method on an interface without breaking the contract. // If we need to do that we have to remove the entire interface instead. if (method.DeclaringType is JavaInterfaceModel && !method.IsStatic && method.IsAbstract && options.RemoveInterfacesWithUnresolvableMembers) { return(RemoveResolvedType(method.DeclaringType)); } if (method is JavaConstructorModel ctor && method.DeclaringType is JavaClassModel klass) { klass.Constructors.Remove(ctor); }
public JavaParameterModel(JavaMethodModel declaringMethod, string javaName, string javaType, string jniType, bool isNotNull) { DeclaringMethod = declaringMethod; Name = javaName; Type = javaType; JniType = jniType; IsNotNull = isNotNull; GenericType = javaType; if (Type.Contains('<')) { Type = Type.Substring(0, Type.IndexOf('<')); } }
// It should detect implementation method for: // - equivalent implementation // - generic instantiation // - TODO: variance // - TODO?: array indicator fixup ("T..." should match "T[]") public static bool IsImplementing(JavaMethodModel derived, JavaMethodModel basis, IDictionary <JavaTypeReference, JavaTypeReference> genericInstantiation) { if (genericInstantiation == null) { throw new ArgumentNullException("genericInstantiation"); } if (basis.Name != derived.Name) { return(false); } if (basis.Parameters.Count != derived.Parameters.Count) { return(false); } if (basis.Parameters.Zip(derived.Parameters, (bp, dp) => IsParameterAssignableTo(dp, bp, derived, basis, genericInstantiation)).All(v => v)) { return(true); } return(false); }
static bool IsParameterAssignableTo(JavaParameterModel dp, JavaParameterModel bp, JavaMethodModel derived, JavaMethodModel basis, IDictionary <JavaTypeReference, JavaTypeReference> genericInstantiation) { // If type names are equivalent, they simply match... except that the generic type parameter names match. // Generic type arguments need more check, so do not examine them just by name. // // FIXME: It is likely that this check should NOT result in "this method is not an override", // but rather like "this method is an override, but it should be still generated in the resulting XML". // For example, this results in that java.util.EnumMap#put() is NOT an override of // java.util.AbstractMap#put(), it is an override, not just that it is still generated in the XML. if (bp.TypeModel?.ReferencedTypeParameter != null && dp.TypeModel?.ReferencedTypeParameter != null && bp.TypeModel.ReferencedTypeParameter.ToString() != dp.TypeModel.ReferencedTypeParameter.ToString()) { return(false); } if (bp.GenericType == dp.GenericType) { return(true); } if (bp.TypeModel?.ArrayPart != bp.TypeModel?.ArrayPart) { return(false); } // if base is type with generic type parameters and derived is without any generic args, that's OK. // java.lang.Class should match java.lang.Class<T>. if (bp.TypeModel?.ReferencedType != null && dp.TypeModel?.ReferencedType != null && bp.TypeModel?.ReferencedType.FullName == dp.TypeModel?.ReferencedType.FullName && dp.TypeModel?.TypeParameters == null) { return(true); } // generic instantiation check. var baseGTP = bp.TypeModel?.ReferencedTypeParameter; if (baseGTP != null) { if (baseGTP.Parent?.DeclaringMethod != null && IsConformantType(baseGTP, dp.TypeModel)) { return(true); } var k = genericInstantiation.Keys.FirstOrDefault(tr => bp.TypeModel?.Equals(tr) ?? false); if (k == null) { // the specified generic type parameter is not part of // the mappings e.g. non-instantiated ones. return(false); } if (genericInstantiation [k].Equals(dp.TypeModel)) { // the specified generic type parameter exactly matches // whatever specified at the derived method. return(true); } } // FIXME: implement variance check. return(false); }