/// <summary> /// Clone the properties of valueArg into node. /// </summary> private static void CopyEnumValueOf(AstExpression node, XTypeReference type, AstExpression valueArg) { // Clear node node.Arguments.Clear(); node.InferredType = type; node.ExpectedType = type; switch (valueArg.Code) { case AstCode.Ldloca: node.Code = AstCode.Ldloc; break; case AstCode.Ldflda: node.Code = AstCode.Ldfld; break; case AstCode.Ldsflda: node.Code = AstCode.Ldsfld; break; default: node.Code = valueArg.Code; break; } node.Operand = valueArg.Operand; node.Arguments.AddRange(valueArg.Arguments); ConvertLoadArguments(node, type); }
/// <summary> /// Generate an Add opcode. /// </summary> private static RCode OpcodeForType(XTypeReference type, RCode[] opcodes) { if (type.IsInt32() || type.IsUInt32() || type.IsInt16() || type.IsUInt16() || type.IsChar() || type.IsByte() || type.IsSByte() || type.IsBoolean()) { return(opcodes[0]); } if (type.IsInt64() || type.IsUInt64()) { return(opcodes[1]); } if (type.IsFloat()) { return(opcodes[2]); } if (type.IsDouble()) { return(opcodes[3]); } XTypeDefinition typeDef; if (type.TryResolve(out typeDef)) { if (typeDef.IsEnum) { return(OpcodeForType(typeDef.GetEnumUnderlyingType(), opcodes)); } } throw new ArgumentException("Unsupported type " + type); }
private static void BoxIfGeneric(XTypeReference type, AstExpression node) { // TODO: CLR allows return-by-reference, though C# does not. Do we need to handle this here? if (type.IsGenericParameter) { var resultType = node.GetResultType(); if (resultType.IsPrimitive) { var clone = new AstExpression(node); node.SetCode(AstCode.BoxToGeneric) .SetArguments(clone) .Operand = type; } } else if (type.IsGenericParameterArray()) { var resultType = node.GetResultType().ElementType; if (resultType.IsPrimitive) { var clone = new AstExpression(node); node.SetCode(AstCode.BoxToGeneric).SetArguments(clone).Operand = type; } } }
/// <summary> /// Variable ctor /// </summary> public AstILVariable(string name, XTypeReference type, VariableDefinition originalVariable, string originalVariableName) { Name = name; Type = type; this.originalVariable = originalVariable; this.originalVariableName = originalVariableName; }
/// <summary> /// Generate converter for the value of an Const instruction. /// </summary> internal static Func <object, object> ConstValueConverter(this XTypeReference elementType, bool keepUnsigned) { if (elementType.IsBoolean()) { return(x => Convert.ToBoolean(x) ? 1 : 0); } if (elementType.IsByte()) { if (keepUnsigned) { return(x => (int)Convert.ToByte(x)); } return(x => (int)((sbyte)unchecked (Convert.ToByte(x)))); } if (elementType.IsSByte()) { return(x => (int)(Convert.ToSByte(x))); } if (elementType.IsChar()) { return(x => (int)(Convert.ToChar(x))); } if (elementType.IsUInt16()) { return(x => (int)(Convert.ToUInt16(x))); } if (elementType.IsInt16()) { return(x => (int)(Convert.ToInt16(x))); } if (elementType.IsInt32()) { return(x => XConvert.ToInt(x)); } if (elementType.IsUInt32()) { return(x => XConvert.ToInt(x)); // unchecked((int)Convert.ToUInt32(Convert.ToInt64(x) & 0xFFFFFFFF)); } if (elementType.IsFloat()) { return(x => Convert.ToSingle(x)); } if (elementType.IsInt64()) { return(x => XConvert.ToLong(x)); } if (elementType.IsUInt64()) { return(x => XConvert.ToLong(x)); // unchecked((long)Convert.ToInt64(x)); } if (elementType.IsDouble()) { return(x => Convert.ToDouble(x)); } if (elementType.IsDexObject() && !elementType.IsVoid()) { return(x => x); } throw new NotSupportedException("Unknown type for constValueConverter " + elementType); }
/// <summary> /// Convert a nullable ctor into a convert function. /// </summary> private static void ConvertOtherCtor(AstExpression node, XTypeReference type, AstExpression target, AstExpression value) { // Clear node node.Arguments.Clear(); node.InferredType = type; node.ExpectedType = type; switch (target.Code) { case AstCode.Ldloca: node.Code = AstCode.Stloc; node.Operand = target.Operand; node.Arguments.Add(value); break; case AstCode.Ldflda: node.Code = AstCode.Stfld; node.Operand = target.Operand; node.Arguments.Add(value); break; case AstCode.Ldsflda: node.Code = AstCode.Stsfld; node.Operand = target.Operand; node.Arguments.Add(value); break; } ConvertLoadArguments(node, type); }
/// <summary> /// Convert ret or store field node. /// /// converts to IEnumerable, ICollection or IList if required. /// </summary> private static void ConvertRetOrStfldOrStsfld(AssemblyCompiler compiler, XTypeReference targetType, AstExpression node, XTypeSystem typeSystem) { var argument = node.Arguments.LastOrDefault(); if (argument == null) { return; } if (argument.InferredType == null || !argument.InferredType.IsArray) { return; } var methodName = GetCollectionConvertMethodName(targetType); if (methodName == null) { return; } // Call "ret asMethod(x)" var arrayHelper = compiler.GetDot42InternalType(InternalConstants.CompilerHelperName).Resolve(); var asArray = arrayHelper.Methods.First(x => x.Name == "As" + methodName); // AsX(x) var asXExpr = new AstExpression(node.SourceLocation, AstCode.Call, asArray, argument).SetType(typeSystem.Object); // replace argument. node.Arguments[node.Arguments.Count - 1] = asXExpr; }
private static string GetCollectionConvertMethodName(XTypeReference targetType) { if (targetType.IsSystemCollectionsIEnumerable()) { return("Enumerable"); } if (targetType.IsSystemCollectionsIEnumerableT()) { return("EnumerableOfObject"); } if (targetType.IsSystemCollectionsICollection()) { return("Collection"); } if (targetType.IsSystemCollectionsICollectionT()) { return("CollectionOfObject"); } if (targetType.IsSystemCollectionsIList()) { return("List"); } if (targetType.IsSystemCollectionsIListT()) { return("ListOfObject"); } return(null); }
private static void UnboxIfGeneric(XTypeReference type, AstExpression node, XTypeSystem typeSystem) { if (type.IsGenericParameter || type.IsGenericParameterArray()) { var resultType = node.GetResultType(); if (resultType.IsByReference && !type.IsByReference) { var elementType = resultType.ElementType; var clone = new AstExpression(node); node.SetCode(AstCode.SimpleCastclass).SetArguments(clone).Operand = elementType; } else { if (TreatAsStruct(type, resultType)) { ConvertUnboxStruct(node, resultType, typeSystem); } else { var clone = new AstExpression(node); node.SetCode(AstCode.UnboxFromGeneric).SetArguments(clone).Operand = type; } } } }
/// <summary> /// Convert the given argument if it does not match the target type. /// </summary> private static void ConvertForRetIfNeeded(AstExpression arg, XTypeReference targetType) { var argType = arg.GetResultType(); if (!targetType.IsSame(argType)) { if (targetType.IsChar()) { if (argType.IsUInt16() || argType.IsByte() || argType.IsInt16()) { Convert(arg, AstCode.Conv_U2, targetType); } } else if (targetType.IsUInt16()) { if (argType.IsChar() || argType.IsByte()) { Convert(arg, AstCode.Int_to_ushort, targetType); } } else if (targetType.IsInt16()) { if (argType.IsChar() || argType.IsByte()) { Convert(arg, AstCode.Conv_I2, targetType); } } } }
/// <summary> /// Gets the type of stelem code to use for the given element type. /// </summary> public static AstCode GetStElemCode(this XTypeReference elementType) { if (elementType.IsByte() || elementType.IsSByte() || elementType.IsBoolean()) { return(AstCode.Stelem_I1); } if (elementType.IsChar() || elementType.IsInt16() || elementType.IsUInt16()) { return(AstCode.Stelem_I2); } if (elementType.IsInt32() || elementType.IsUInt32()) { return(AstCode.Stelem_I4); } if (elementType.IsInt64() || elementType.IsUInt64()) { return(AstCode.Stelem_I8); } if (elementType.IsFloat()) { return(AstCode.Stelem_R4); } if (elementType.IsDouble()) { return(AstCode.Stelem_R8); } return(AstCode.Stelem_Ref); }
/// <summary> /// Gets a box method for the given primitive type. /// </summary> internal static MethodReference GetBoxValueOfMethod(XTypeReference type) { var info = Get(type); var cref = info.boxedClass; return(new MethodReference(cref, "valueOf", new Prototype(cref, new Parameter(info.primitiveType, "value")))); }
/// <summary> /// Convert a nullable .GetValueOrDefault() /// </summary> private static void ConvertGetValueOrDefault(AstExpression node, XTypeReference type, XModule module) { var defExpr = node.Arguments.Count == 1 ? new AstExpression(node.SourceLocation, AstCode.DefaultValue, type).SetType(type) : node.Arguments[1]; defExpr.ExpectedType = type; if (type.IsPrimitive) { // replace with obj != null ? unbox(obj) : defExpr AstExpression compareExpr, valueExpr; var loadExpr = node.Arguments[0]; ConvertLoad(loadExpr); loadExpr.InferredType = module.TypeSystem.Object; loadExpr.ExpectedType = module.TypeSystem.Object; if (loadExpr.Code != AstCode.Ldloc) { // TODO: how can we get the backend to remove/combine these variables again? var tmpVar = new AstGeneratedVariable("tmp$", null) { Type = module.TypeSystem.Object }; compareExpr = new AstExpression(node.SourceLocation, AstCode.Stloc, tmpVar, loadExpr).SetType(module.TypeSystem.Object); valueExpr = new AstExpression(node.SourceLocation, AstCode.Ldloc, tmpVar).SetType(module.TypeSystem.Object); } else { compareExpr = loadExpr; valueExpr = loadExpr; } valueExpr = new AstExpression(node.SourceLocation, AstCode.Unbox, type, valueExpr).SetType(type); var newNode = new AstExpression(node.SourceLocation, AstCode.Conditional, type, compareExpr, valueExpr, defExpr) .SetType(type); node.CopyFrom(newNode); } else { // replace with obj ?? defExpr var loadExpr = node.Arguments[0]; ConvertLoad(loadExpr); if (!type.IsSame(loadExpr.InferredType)) { //loadExpr.ExpectedType = type; // todo: how to get the cast inserted automatically? loadExpr = new AstExpression(loadExpr.SourceLocation, AstCode.SimpleCastclass, type, loadExpr); } var nullCoalescing = new AstExpression(node.SourceLocation, AstCode.NullCoalescing, null, loadExpr, defExpr); nullCoalescing.InferredType = type; node.CopyFrom(nullCoalescing); } }
/// <summary> /// Default ctor /// </summary> private XSyntheticFieldDefinition(XTypeDefinition declaringType, XSyntheticFieldFlags flags, string name, XTypeReference fieldType, object initialValue) : base(declaringType) { this.flags = flags; this.name = name; this.fieldType = fieldType; this.initialValue = initialValue; }
/// <summary> /// Default ctor /// </summary> private XSyntheticMethodDefinition(XTypeDefinition declaringType, XSyntheticMethodFlags flags, string name, XTypeReference returnType, params XParameter[] parameters) : base(declaringType) { this.flags = flags; this.name = name; this.returnType = returnType; this.parameters = parameters.ToList(); astParameters = parameters.Select(x => new AstParameterVariable(x)).Cast <AstVariable>().ToList(); }
/// <summary> /// Create a synthetic field and add it to the given declaring type. /// </summary> public static XSyntheticTypeDefinition Create(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType, string fullScopeId) { var type = new XSyntheticTypeDefinition(module, declaringType, flags, @namespace, name, baseType, fullScopeId); if(declaringType != null) declaringType.Add(type); module.Register(type); return type; }
/// <summary> /// Default ctor /// </summary> public JavaFieldReference(string name, XTypeReference fieldType, XTypeReference declaringType, string javaName, string javaDescriptor, string javaClassName) : base(declaringType) { this.name = name; this.fieldType = fieldType; this.javaName = javaName; this.javaDescriptor = javaDescriptor; this.javaClassName = javaClassName; }
/// <summary> /// Gets a unbox method for the given primitive type. /// </summary> internal static MethodReference GetUnboxValueMethod(XTypeReference type, AssemblyCompiler compiler, DexTargetPackage targetPackage, out RCode convertAfterCode) { var info = Get(type); convertAfterCode = info.convertAfterCode; var boxingClass = compiler.GetDot42InternalType("Boxing").GetClassReference(targetPackage); return(new MethodReference(boxingClass, info.unboxMethodName, new Prototype(info.primitiveType, new Parameter(FrameworkReferences.Object, "value")))); }
/// <summary> /// Variable ctor /// </summary> public AstJavaVariable(XTypeReference type, LocalVariableReference varRef) { this.varRef = varRef; index = varRef.Index; isParameter = varRef.IsParameter; isThis = varRef.IsThis; Name = (isParameter ? "_P" : "_V") + varRef; Type = type; }
/// <summary> /// Convert the given node to a box operation with given type and argument. /// </summary> private static void ConvertToBox(AstExpression node, XTypeReference boxType, AstExpression argument) { node.Code = AstCode.Box; node.Operand = boxType; node.InferredType = boxType; node.ExpectedType = boxType; node.Arguments.Clear(); node.Arguments.Add(argument); }
/// <summary> /// Returns the method name when converting an array to an IEnumerableT in compiler helper. /// /// (not sure if this is the best place for this method...) /// </summary> public static string GetAsEnumerableTMethodName(XTypeReference sourceArrayElementType) { var convertMethodName = "AsObjectEnumerable"; if (sourceArrayElementType.IsPrimitive) { if (sourceArrayElementType.IsBoolean()) { convertMethodName = "AsBoolEnumerable"; } else if (sourceArrayElementType.IsByte()) { convertMethodName = "AsByteEnumerable"; } else if (sourceArrayElementType.IsSByte()) { convertMethodName = "AsSByteEnumerable"; } else if (sourceArrayElementType.IsChar()) { convertMethodName = "AsCharEnumerable"; } else if (sourceArrayElementType.IsInt16()) { convertMethodName = "AsInt16Enumerable"; } else if (sourceArrayElementType.IsUInt16()) { convertMethodName = "AsUInt16Enumerable"; } else if (sourceArrayElementType.IsInt32()) { convertMethodName = "AsInt32Enumerable"; } else if (sourceArrayElementType.IsUInt32()) { convertMethodName = "AsUInt32Enumerable"; } else if (sourceArrayElementType.IsInt64()) { convertMethodName = "AsInt64Enumerable"; } else if (sourceArrayElementType.IsFloat()) { convertMethodName = "AsFloatEnumerable"; } else if (sourceArrayElementType.IsDouble()) { convertMethodName = "AsDoubleEnumerable"; } else { throw new ArgumentOutOfRangeException("Unknown primitive array element type " + sourceArrayElementType); } } return(convertMethodName); }
/// <summary> /// Convert a nullable .HasValue into. /// </summary> private static void ConvertEnumHasValue(AstExpression node, XTypeReference type, XModule data) { // Clear node node.Code = AstCode.CIsNotNull; node.Operand = null; node.InferredType = data.TypeSystem.Bool; node.ExpectedType = data.TypeSystem.Bool; ConvertLoadArguments(node, type); }
/// <summary> /// Create a descriptor for comparing the given method without generics. /// </summary> private static string CreateNoGenericsDescriptor(XTypeReference type) { if (type.IsArray) { return(CreateNoGenericsDescriptor(((XArrayType)type).ElementType) + "[]"); } XTypeDefinition typeDef; return(type.TryResolve(out typeDef) ? typeDef.GetFullName(true) : type.GetFullName(true)); }
/// <summary> /// Gets a class reference for the given type reference. /// </summary> internal static ClassReference GetClassReference(this XTypeReference type, DexTargetPackage targetPackage) { var classRef = type.GetReference(targetPackage) as ClassReference; if (classRef == null) { throw new ArgumentException(string.Format("type {0} is not a class reference", type.FullName)); } return(classRef); }
/// <summary> /// Create code to unbox the given source array of boxed type elements into an array of primitive elements. /// </summary> public static RLRange UnboxGenericArray(this IRLBuilder builder, ISourceLocation sequencePoint, RegisterSpec source, RegisterSpec boxedArray, XTypeReference type, DexTargetPackage targetPackage, IRegisterAllocator frame, AssemblyCompiler compiler) { var internalBoxingType = compiler.GetDot42InternalType("Boxing").Resolve(); var ilUnboxMethod = internalBoxingType.Methods.First(x => x.EqualsName("UnboxTo") && (x.Parameters.Count == 2) && (x.Parameters[1].ParameterType.IsSame(type, true))); var unboxMethod = ilUnboxMethod.GetReference(targetPackage); var call = builder.Add(sequencePoint, RCode.Invoke_static, unboxMethod, boxedArray, source); return(new RLRange(call, null)); }
/// <summary> /// Gets the box information for the given type. /// </summary> private static BoxInfo Get(XTypeReference type) { var info = Infos.FirstOrDefault(x => type.Is(x.metadataType)); if (info != null) { return(info); } throw new ArgumentException(string.Format("No box information for for type {0}", type.FullName)); }
/// <summary> /// Ensure that javaImportType is loaded. /// </summary> private void EnsureJavaImportType() { if (javaImportType == null) { // Load java import type string className; javaImportType = TryGetJavaImportNames(out className) ? Java.XBuilder.AsTypeReference(Module, className, XTypeUsageFlags.DeclaringType) : Module.TypeSystem.NoType; } }
/// <summary> /// Convert a nullable .HasValue into. /// </summary> private static void ConvertHasValue(AstExpression node, XTypeReference type, AstExpression target) { // Clear node var originalArgs = node.Arguments.ToList(); node.Code = AstCode.CIsNotNull; node.Operand = null; node.Arguments.Clear(); AddLoadArgument(node, target, originalArgs[0]); }
private static void Convert(AstExpression node, AstCode convertCode, XTypeReference expectedType) { // Copy load expression var clone = new AstExpression(node); // Convert node node.Code = convertCode; node.SetArguments(clone); node.Operand = null; node.SetType(expectedType); }
/// <summary> /// Default ctor /// </summary> private XSyntheticTypeDefinition(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType) : base(module, declaringType, flags.HasFlag(XSyntheticTypeFlags.ValueType), null) { this.flags = flags; this.@namespace = @namespace; this.name = name; this.baseType = baseType; fields = new List<XFieldDefinition>(); methods = new List<XMethodDefinition>(); nestedTypes = new List<XTypeDefinition>(); interfaces = new List<XTypeReference>(); }
/// <summary> /// Default ctor /// </summary> private XSyntheticTypeDefinition(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType) : base(module, declaringType, flags.HasFlag(XSyntheticTypeFlags.ValueType), null) { this.flags = flags; this.@namespace = @namespace; this.name = name; this.baseType = baseType; fields = new List <XFieldDefinition>(); methods = new List <XMethodDefinition>(); nestedTypes = new List <XTypeDefinition>(); interfaces = new List <XTypeReference>(); }
/// <summary> /// Create code to unbox the given source array of boxed type elements resulting from a call into an array of primitive elements. /// </summary> public static RLRange UnboxGenericArrayResult(this IRLBuilder builder, ISourceLocation sequencePoint, RegisterSpec boxedArray, XTypeReference type, DexTargetPackage targetPackage, IRegisterAllocator frame, AssemblyCompiler compiler) { var internalBoxingType = compiler.GetDot42InternalType("Boxing").Resolve(); var primitiveArray = frame.AllocateTemp(type.GetReference(targetPackage)); var ilUnboxMethod = internalBoxingType.Methods.First(x => x.Name.StartsWith("Unbox") && (x.Parameters.Count == 1) && (x.ReturnType.IsSame(type, true))); var unboxMethod = ilUnboxMethod.GetReference(targetPackage); var call = builder.Add(sequencePoint, RCode.Invoke_static, unboxMethod, boxedArray); var saveArray = builder.Add(sequencePoint, RCode.Move_result_object, primitiveArray); return(new RLRange(call, saveArray, primitiveArray)); }
/// <summary> /// Default ctor /// </summary> public JavaMethodReference(string name, bool hasThis, XTypeReference returnType, XTypeReference declaringType, IEnumerable<XParameter> parameters, IEnumerable<string> genericParameterNames, string javaName, string javaDescriptor, string javaClassName) : base(declaringType) { this.name = name; this.hasThis = hasThis; this.returnType = returnType; this.javaName = javaName; this.javaDescriptor = javaDescriptor; this.javaClassName = javaClassName; this.parameters = (parameters ?? Enumerable.Empty<XParameter>()).ToList().AsReadOnly(); genericParameters = (genericParameterNames ?? Enumerable.Empty<string>()).Select((x, i) => new XGenericParameter.SimpleXGenericParameter(this, i)).Cast<XGenericParameter>().ToList().AsReadOnly(); }
/// <summary> /// Default ctor /// </summary> public ILMethodReference(XTypeReference declaringType, MethodReference method) : base(declaringType) { this.method = method; }
/// <summary> /// Default ctor /// </summary> public XOptionalModifierType(XTypeReference modifierType, XTypeReference elementType) : base(elementType) { this.modifierType = modifierType; }
/// <summary> /// Create a synthetic field and add it to the given declaring type. /// </summary> public static XSyntheticFieldDefinition Create(XTypeDefinition declaringType, XSyntheticFieldFlags flags, string name, XTypeReference fieldType, object initialValue = null) { var field = new XSyntheticFieldDefinition(declaringType, flags, name, fieldType, initialValue); declaringType.Add(field); return field; }
/// <summary> /// Convert an Java field reference to an XFieldReference. /// </summary> public static XFieldReference AsFieldReference(XModule module, string fieldName, string descriptor, XTypeReference declaringType, string className) { var fieldType = AsTypeReference(module, Descriptors.ParseFieldType(descriptor), XTypeUsageFlags.FieldType); return new JavaFieldReference(fieldName, fieldType, declaringType, fieldName, descriptor, className); }
/// <summary> /// Convert an Java method reference to an XMethodReference. /// </summary> public static XMethodReference AsMethodReference(XModule module, string methodName, string descriptor, XTypeReference declaringType, string className, bool hasThis) { if (declaringType.IsArray) { declaringType = module.TypeSystem.Object; } var _descriptor = Descriptors.ParseMethodDescriptor(descriptor); var returnType = AsTypeReference(module, _descriptor.ReturnType, XTypeUsageFlags.ReturnType); var parameters = _descriptor.Parameters.Select((x, i) => new JavaParameter(module, "p" + i, x)); var name = methodName; if (name == "<init>") name = ".ctor"; else if (name == "<clinit>") name = ".cctor"; return new JavaMethodReference(name, hasThis, returnType, declaringType, parameters, null, methodName, descriptor, className); }
/// <summary> /// Default ctor /// </summary> public XByReferenceType(XTypeReference elementType) : base(elementType) { }
/// <summary> /// Default ctor /// </summary> public XPointerType(XTypeReference elementType) : base(elementType) { }
public static XParameter Create(string name, XTypeReference type) { return new TypedParameter(name, type); }
/// <summary> /// Create a synthetic field and add it to the given declaring type. /// </summary> public static XSyntheticTypeDefinition Create(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType) { var type = new XSyntheticTypeDefinition(module, declaringType, flags, @namespace, name, baseType); declaringType.Add(type); return type; }
/// <summary> /// Create a System.Nullable<T> type with given T argument. /// </summary> private static XGenericInstanceType CreateNullableT(XModule module, XTypeReference argument) { return new XGenericInstanceType(new XTypeReference.SimpleXTypeReference(module, "System", "Nullable`1", null, true, new[] { "T" }), new[] { argument }); }
public TypedParameter(string name, XTypeReference type, XParameterKind kind = XParameterKind.Input) : base(name, kind) { this.type = type; }
/// <summary> /// Default ctor /// </summary> public XRequiredModifierType(XTypeReference modifierType, XTypeReference elementType) : base(elementType) { this.modifierType = modifierType; }
/// <summary> /// Does this type reference point to the same type as the given other reference? /// </summary> public override bool IsSame(XTypeReference other, bool ignoreSign) { if (base.IsSame(other, ignoreSign)) return true; EnsureDexImportType(); if (dexImportType != Module.TypeSystem.NoType) { if (dexImportType.IsSame(other, ignoreSign)) return true; } EnsureJavaImportType(); if (javaImportType != Module.TypeSystem.NoType) { if (javaImportType.IsSame(other, ignoreSign)) return true; } return false; }