@Override public TypeReference visitWildcard(final WildcardType t, final Boolean recurse) { return erase(getUpperBound(t), recurse); } };
@Override public TypeReference visitClassType(final TypeReference t, final TypeReference s) { if (isSameType(t, s)) { return t; final TypeReference base = asSuper(t, s); mappings = adapt(base, t); mappings = getGenericSubTypeMappings(t, base); final TypeReference result = substituteGenericArguments(s, mappings); if (!isSubType(result, t)) { return null; if (isRawType(t)) { return eraseRecursive(result); return substituteGenericArguments(result, unboundMappings);
public static boolean areSameTypes( final List<? extends TypeReference> t, final List<? extends TypeReference> s, final boolean strict) { if (t.size() != s.size()) { return false; } for (int i = 0, n = t.size(); i < n; i++) { if (!isSameType(t.get(i), s.get(i), strict)) { return false; } } return true; }
public static TypeReference substituteGenericArguments( final TypeReference inputType, final TypeReference substitutionsProvider) { if (inputType == null || substitutionsProvider == null) { return inputType; } return substituteGenericArguments(inputType, adapt(inputType, substitutionsProvider)); }
@Override public TypeReference visitArrayType(final ArrayType t, final Boolean recurse) { final TypeReference elementType = getElementType(t); final TypeReference erasedElementType = erase(getElementType(t), recurse); return erasedElementType == elementType ? t : erasedElementType.makeArrayType(); }
inferredType = MetadataHelper.getUpperBound(inferredType); if (MetadataHelper.isSubType(inferredType, expectedType)) { tempResult = inferredType; tempResult = MetadataHelper.asSubType(inferredType, expectedType); final Map<TypeReference, TypeReference> mappings = MetadataHelper.adapt(tempResult, inferredType); if (MetadataHelper.isSameType(gp, key, true)) { if (mappingsToRemove == null) { mappingsToRemove = new ArrayList<>(); tempResult = MetadataHelper.asSubType(v.getType(), expectedType); tempResult = MetadataHelper.asSubType(MetadataHelper.eraseRecursive(v.getType()), expectedType); if (MetadataHelper.areGenericsSupported(thisType)) { if (MetadataHelper.getUnboundGenericParameterCount(result) > 0) { result = MetadataHelper.substituteGenericArguments(result, inferredType); if (result.isGenericDefinition() && !MetadataHelper.canReferenceTypeVariablesOf(result, _context.getCurrentType())) { result = new RawType(result.getUnderlyingType()); result = MetadataHelper.getUpperBound(result); !MetadataHelper.isSameType(result, inferredType) && _previouslyInferred.get(v).add(result)) {
boundMethod = MetadataHelper.asMemberOf(method, expectedTargetType); MetadataHelper.isRawType(targetType) && !MetadataHelper.canReferenceTypeVariablesOf(targetType, _context.getCurrentType())) { targetType = MetadataHelper.erase(targetType); final MethodReference m = targetType != null ? MetadataHelper.asMemberOf(r != null ? r : method, targetType) : method; oldMappings.putAll(MetadataHelper.getGenericSubTypeMappings(targetType.getUnderlyingType(), targetType)); if (oldMapping == null || MetadataHelper.isSubType(newMapping, oldMapping)) { mappings.put(t, newMapping); if (oldMapping == null || MetadataHelper.isSubType(newMapping, oldMapping)) { mappings.put(t, newMapping); if (inScope != null && MetadataHelper.isSameType(gp, inScope)) { continue; mappings.put(gp, MetadataHelper.eraseRecursive(gp)); mappings.put(gp, MetadataHelper.eraseRecursive(gp)); expectedTargetType = MetadataHelper.substituteGenericArguments(boundMethod.getDeclaringType(), mappings); expectedTargetType = MetadataHelper.asSuper( expectedTargetType,
final List<MethodReference> methods = MetadataHelper.findMethods( resolvedType, callSite != null ? MetadataFilters.matchName(callSite.getMethodName()) final TypeReference asMemberOf = MetadataHelper.asSuper(functionMethod.getDeclaringType(), lambdaType); final TypeReference effectiveType = asMemberOf != null ? asMemberOf : lambdaType; if (MetadataHelper.isRawType(effectiveType)) { return MetadataHelper.erase(functionMethod); functionMethod = MetadataHelper.asMemberOf(functionMethod, effectiveType);
targetType = method.getDeclaringType(); else if (!(targetType instanceof RawType) && MetadataHelper.isRawType(targetType)) { targetType = MetadataHelper.eraseRecursive(targetType); final TypeReference asSuper = MetadataHelper.asSuper(method.getDeclaringType(), targetType); final TypeReference asSubType = asSuper != null ? MetadataHelper.asSubType(method.getDeclaringType(), asSuper) : null; final List<MethodReference> candidates = MetadataHelper.findMethods( targetType, MetadataFilters.matchName(method.getName()) final boolean castNeeded = !MetadataHelper.isSameType( castType, MetadataHelper.getUnderlyingPrimitiveTypeOrSelf(newParameter.getParameterType()) ); if (MetadataHelper.isAssignableFrom(newParameter.getParameterType(), castType)) { addToResults(cast, false);
asMember = erase(method); base = getUpperBound(base); final TypeReference asSuper = asSuper(method.getDeclaringType(), base); map = adapt(method.getDeclaringType(), asSuper != null ? asSuper : base); map = getGenericSubTypeMappings(method.getDeclaringType(), asSuper != null ? asSuper : base); final MethodReference result = specializeIfNecessary(method, asMember, base);
if (expectedType != null && !MetadataHelper.isSameType(expectedType, BuiltinTypes.Object)) { final TypeReference asSubType = MetadataHelper.asSubType(type, expectedType); inferredType = asSubType != null ? asSubType : type; mappings.put(gp, MetadataHelper.eraseRecursive(gp)); final MethodReference asMember = MetadataHelper.asMemberOf( constructor, TypeSubstitutionVisitor.instance().visit(inferredType, mappings) t = t.hasExtendsBound() ? t.getExtendsBound() : MetadataHelper.getUpperBound(t); final GenericParameter inScope = _context.getCurrentMethod().findTypeVariable(t.getName()); if (inScope != null && MetadataHelper.isSameType(t, inScope)) { break; if (!MetadataHelper.isSameType(o, t)) { t = o; t = t.hasExtendsBound() ? t.getExtendsBound() : MetadataHelper.getUpperBound(t);
MetadataHelper.getConversionType(topCastType, innerOperandType) != ConversionType.NONE) { final ConversionType valueToInner = MetadataHelper.getNumericConversionType(innerCastType, innerOperandType); final ConversionType outerToInner = MetadataHelper.getNumericConversionType(innerCastType, topCastType); final ConversionType valueToOuter = MetadataHelper.getNumericConversionType(topCastType, innerOperandType); MetadataHelper.getNumericConversionType(topCastType, innerOperandType) == ConversionType.IMPLICIT) { final TypeReference conditionalType = getType(parent); if (!MetadataHelper.isSameType(operandType, conditionalType, true)) { if (!checkResolveAfterRemoveCast(parent)) { return null; final TypeReference oppositeType = getType(opposite); if (oppositeType == null || !MetadataHelper.isSameType(conditionalType, oppositeType, true)) { return null; final TypeReference asSubType = MetadataHelper.asSubType(lambdaResult.getType(), topCastType); if (!MetadataHelper.isAssignableFrom(topCastType, functionalInterfaceType, false)) { return null;
: MetadataHelper.asSubType(inferredType, expectedType); if (result.isGenericType() || MetadataHelper.isRawType(result)) { final MethodReference bootstrapMethod = callSite.getBootstrapMethod(); final List<MethodReference> methods = MetadataHelper.findMethods( resolvedType != null ? resolvedType : result, MetadataFilters.matchName(callSite.getMethodName()) MetadataHelper.isSubType(targetType, expectedArgType)) { final MethodReference asMember = MetadataHelper.asMemberOf(actualMethod, targetType); final GenericParameter genericParameter = genericParameters.get(i); if (!MetadataHelper.isSameType(typeArgument, genericParameter, true)) { expectedMappings.put(genericParameter, typeArgument); final TypeReference inferredMapping = inferredMappings.get(key); if (inferredMapping == null || MetadataHelper.isSubType(expectedMapping, inferredMapping)) { inferredMappings.put(key, expectedMapping); if (!declaringType.isGenericDefinition() && !MetadataHelper.isRawType(actualMethod.getDeclaringType())) { return result; final MethodReference resultMethod = MetadataHelper.asMemberOf(functionMethod, result);
public static boolean isSubType(final TypeReference type, final TypeReference baseType, final boolean capture) { if (type == baseType) { return true; } if (type == null || baseType == null) { return false; } if (baseType instanceof CompoundTypeReference) { final CompoundTypeReference c = (CompoundTypeReference) baseType; if (!isSubType(type, getSuperType(c), capture)) { return false; } for (final TypeReference interfaceType : c.getInterfaces()) { if (!isSubType(type, interfaceType, capture)) { return false; } } return true; } final TypeReference lower = getLowerBound(baseType); if (lower != baseType) { return isSubType(capture ? capture(type) : type, lower, false); } return IS_SUBTYPE_VISITOR.visit(capture ? capture(type) : type, baseType); }
final Map<TypeReference, TypeReference> map = adaptSelf(t); final TypeReference original = map.get(k); TypeReference s = rewriteSupers(original); s = WildcardType.makeExtends(getUpperBound(s)); return substituteGenericArguments(t, rewrite);
@Override public TypeReference visitClassType(final TypeReference t, final TypeReference s) { if (StringUtilities.equals(t.getInternalName(), s.getInternalName())) { return t; } final TypeReference st = getSuperType(t); if (st != null && (st.getSimpleType() == JvmType.Object || st.getSimpleType() == JvmType.TypeVariable)) { final TypeReference x = asSuper(s, st); if (x != null) { return x; } } final TypeDefinition ds = s.resolve(); if (ds != null && ds.isInterface()) { for (final TypeReference i : getInterfaces(t)) { final TypeReference x = asSuper(s, i); if (x != null) { return x; } } } return null; }
!MetadataHelper.isAssignableFrom(commonSuper, assigned)) { final TypeReference asSubType = MetadataHelper.asSubType(commonSuper, assigned); !MetadataHelper.isSameType(c.getInferredType(), inferredType)) {
@Override public Void visitParameterizedType(final TypeReference t, final Map<TypeReference, TypeReference> map) { final TypeReference r = MetadataHelper.asSuper(t.getUnderlyingType(), argumentType); final TypeReference s = MetadataHelper.asSubType(argumentType, r != null ? r : t.getUnderlyingType()); if (s != null && s instanceof IGenericInstance) { final List<TypeReference> tArgs = ((IGenericInstance) t).getTypeArguments(); final List<TypeReference> sArgs = ((IGenericInstance) s).getTypeArguments(); if (tArgs.size() == sArgs.size()) { for (int i = 0, n = tArgs.size(); i < n; i++) { argumentType = sArgs.get(i); visit(tArgs.get(i), map); } } } return null; }
public static TypeReference erase(final TypeReference type) { return erase(type, false); }
@Override public TypeReference visitGenericParameter(final GenericParameter t, final TypeReference s) { if (isSameType(t, s)) { return t; } return asSuper(s, t.hasExtendsBound() ? t.getExtendsBound() : BuiltinTypes.Object); }