@Override protected LightweightTypeReference doVisitParameterizedTypeReference(final ParameterizedTypeReference reference) { return this.visit(reference.getTypeArguments()); }
@Override protected LightweightTypeReference enhanceParameterizedTypeReference(ParameterizedTypeReference origin, JvmType type, ParameterizedTypeReference result, ConstraintVisitingInfo visiting) { for(int i = 0; i < origin.getTypeArguments().size(); i++) { LightweightTypeReference argument = origin.getTypeArguments().get(i); visiting.pushInfo(type instanceof JvmTypeParameterDeclarator ? (JvmTypeParameterDeclarator) type : null, i); LightweightTypeReference visitedArgument = visitTypeArgument(argument, visiting); result.addTypeArgument(visitedArgument); } return result; }
@Override protected void doVisitParameterizedTypeReference(ParameterizedTypeReference reference, StringBuilder param) { param.append(reference.getType().getSimpleName()); List<LightweightTypeReference> typeArguments = reference.getTypeArguments(); if (!typeArguments.isEmpty()) { param.append("<"); for(int i = 0; i < typeArguments.size(); i++) { if (i != 0) { param.append(", "); } typeArguments.get(i).accept(this, param); } param.append(">"); } }
/** * @param type the type of the reference. May be used by subtypes. */ protected LightweightTypeReference enhanceParameterizedTypeReference(ParameterizedTypeReference origin, JvmType type, ParameterizedTypeReference result, Visiting visiting) { for(LightweightTypeReference argument: origin.getTypeArguments()) { result.addTypeArgument(visitTypeArgument(argument, visiting)); } return result; }
@Override protected Boolean doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { for(LightweightTypeReference argument: reference.getTypeArguments()) { if (argument.isWildcard()) { if (!((WildcardTypeReference)argument).isUnbounded()) { return Boolean.TRUE; } } else { return Boolean.TRUE; } } return Boolean.FALSE; }
@Override protected LightweightTypeReference enhanceParameterizedTypeReference(ParameterizedTypeReference reference, JvmType type, ParameterizedTypeReference result, ConstraintVisitingInfo visiting) { boolean convertToWildcard = false; for(int i = 0; i < reference.getTypeArguments().size(); i++) { wasCapturedWildcard = false; LightweightTypeReference argument = reference.getTypeArguments().get(i); visiting.pushInfo(type instanceof JvmTypeParameterDeclarator ? (JvmTypeParameterDeclarator) type : null, i); LightweightTypeReference visitedArgument = argument.accept(this, visiting); if (wasCapturedWildcard) convertToWildcard = true; wasCapturedWildcard = false; result.addTypeArgument(visitedArgument); } if (convertToWildcard) { WildcardTypeReference wildcard = result.getOwner().newWildcardTypeReference(); wildcard.addUpperBound(result); return wildcard; } return result; }
protected FunctionTypeReference getAsFunctionOrNull(ParameterizedTypeReference typeReference) { if (typeReference.isRawType()) return null; FunctionTypeReference functionType = new FunctionTypeReference(typeReference.getOwner(), typeReference.getType()); List<LightweightTypeReference> allTypeArguments = typeReference.getTypeArguments(); if (!tryAssignTypeArguments(allTypeArguments.subList(0, allTypeArguments.size() - 1), functionType)) return null; LightweightTypeReference lastTypeArgument = allTypeArguments.get(allTypeArguments.size() - 1); functionType.addTypeArgument(lastTypeArgument); LightweightTypeReference returnType = lastTypeArgument.getUpperBoundSubstitute(); functionType.setReturnType(returnType); return functionType; }
@Override protected void doVisitParameterizedTypeReference(ParameterizedTypeReference reference, ParameterizedTypeReference declaration) { JvmType type = declaration.getType(); if (type instanceof JvmTypeParameter) { if (type != reference.getType() && shouldProcess((JvmTypeParameter) type)) { JvmTypeParameter typeParameter = (JvmTypeParameter) type; processTypeParameter(typeParameter, reference); } } else if (type instanceof JvmTypeParameterDeclarator && !((JvmTypeParameterDeclarator) type).getTypeParameters().isEmpty() && !declaration.getTypeArguments().isEmpty()) { doVisitMatchingTypeParameters(reference, declaration); } }
@Override protected void doVisitParameterizedTypeReference(final ParameterizedTypeReference reference) { boolean _isAnonymous = reference.isAnonymous(); if (_isAnonymous) { reference.getNamedType().accept(this); } else { this.appender.append(reference.getType()); boolean _isEmpty = reference.getTypeArguments().isEmpty(); boolean _not = (!_isEmpty); if (_not) { this.appender.append("<"); this.appendCommaSeparated(reference.getTypeArguments()); this.appender.append(">"); } } }
@Override protected Boolean doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { if (reference.isResolved()) { return true; } if (reference.getOwner().getDeclaredTypeParameters().contains(reference.getType())) { return true; } if (!visit(reference.getTypeArguments())) { return false; } return !(reference.getType() instanceof JvmTypeParameter); }
return true; LightweightTypeReference parameterReference = parameterized.getTypeArguments().get(i); if (parameterized instanceof FunctionTypeReference && !(parameterReference instanceof WildcardTypeReference)) { FunctionTypeReference functionType = (FunctionTypeReference) parameterized;
/** * Returns a projection of this type to the instance level. That is, type arguments will * be replaced by their invariant bounds. * * The instance projection of <code>ArrayList<? extends Iterable<? extends String>></code> * is <code>ArrayList<Iterable<? extends String>></code> since it is possible to create instances * of <code>ArrayList<Iterable<? extends String>></code>. */ public ParameterizedTypeReference toInstanceTypeReference() { ParameterizedTypeReference result = getOwner().newParameterizedTypeReference(getType()); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.addTypeArgument(typeArgument.getInvariantBoundSubstitute()); } return result; } }
protected int doIsConformant(ParameterizedTypeReference left, ArrayTypeReference right, int flags) { if (left.isType(Object.class) || left.isType(Serializable.class) || left.isType(Cloneable.class)) { return flags | SUCCESS | SUBTYPE; } if ((flags & ALLOW_SYNONYMS) != 0) { // Arrays are generally assignable to List and its supertypes if (left.isType(List.class) || left.isType(Collection.class) || left.isType(Iterable.class)) { List<LightweightTypeReference> arguments = left.getTypeArguments(); if (arguments.isEmpty()) { // type argument is bound to Object return flags | SUCCESS | DEMAND_CONVERSION; } LightweightTypeReference componentType = right.getComponentType().getWrapperTypeIfPrimitive(); int result = doIsConformant(arguments.get(0).getInvariantBoundSubstitute(), componentType, flags); if ((result & SUCCESS) != 0) { return result | DEMAND_CONVERSION; } } } return flags; }
List<LightweightTypeReference> typeArguments = reference.getTypeArguments(); int size = Math.min(typeArguments.size(), typeParameters.size()); for (int i = 0; i < size; i++) {
@Override protected void doVisitArrayTypeReference(ArrayTypeReference reference, ParameterizedTypeReference declaration) { JvmType type = declaration.getType(); if (type instanceof JvmTypeParameter) { if (shouldProcess((JvmTypeParameter) type)) { JvmTypeParameter typeParameter = (JvmTypeParameter) type; processTypeParameter(typeParameter, reference); } } else { if (!declaration.isRawType() && (declaration.isType(List.class) || declaration.isType(Collection.class) || declaration.isType(Iterable.class))) { LightweightTypeReference elementType = declaration.getTypeArguments().get(0); LightweightTypeReference componentType = reference.getComponentType(); outerVisit(componentType.getInvariantBoundSubstitute(), elementType); } } } }
protected FunctionTypeReference getAsProcedureOrNull(ParameterizedTypeReference typeReference) { ITypeReferenceOwner owner = typeReference.getOwner(); JvmType type = typeReference.getType(); FunctionTypeReference functionType = new FunctionTypeReference(owner, type); if (!tryAssignTypeArguments(typeReference.getTypeArguments(), functionType)) return null; JvmType voidType = (JvmType) owner.getContextResourceSet().getEObject(URIHelperConstants.PRIMITIVES_URI.appendFragment("void"), true); functionType.setReturnType(owner.newParameterizedTypeReference(voidType)); return functionType; }
private FunctionTypeReference createFunctionTypeRef( ITypeReferenceOwner owner, LightweightTypeReference functionType, List<LightweightTypeReference> parameterTypes, /* @Nullable */ LightweightTypeReference returnType, /* @Nullable */ LightweightTypeReference outer) { JvmType type = functionType.getType(); if (type == null) throw new IllegalArgumentException("type may not be null"); FunctionTypeReference result; if (outer == null) { result = owner.newFunctionTypeReference(type); } else { result = owner.newFunctionTypeReference(outer, type); } if (functionType instanceof ParameterizedTypeReference) { for(LightweightTypeReference typeArgument: ((ParameterizedTypeReference) functionType).getTypeArguments()) { result.addTypeArgument(typeArgument.copyInto(owner)); } } for(LightweightTypeReference parameterType: parameterTypes) { result.addParameterType(parameterType.copyInto(owner)); } if (returnType != null) { result.setReturnType(returnType.copyInto(owner)); } return result; }
for(LightweightTypeReference argument: reference.getTypeArguments()) { SubstitutionResult visited = visitTypeArgument(argument, VarianceInfo.INVARIANT); result.addTypeArgument(visited.typeReference);