@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(">"); } }
@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); } } }
@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); }
@Override protected List<JvmType> doVisitParameterizedTypeReference(ParameterizedTypeReference reference, ResourceSet resourceSet) { JvmType type = reference.getType(); if (!type.eIsProxy()) { if (type instanceof JvmTypeParameter) { return getRawTypesFromConstraints(reference.getOwner(), (JvmTypeParameter) type, resourceSet); } return Collections.singletonList(type); } return Collections.emptyList(); }
@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(ParameterizedTypeReference reference, StringBuilder param) { JvmType type = reference.getType(); if (type instanceof JvmDeclaredType) { boolean local = ((JvmDeclaredType) type).isLocal(); if (local) { param.append("new "); Iterables.getLast(reference.getSuperTypes()).accept(this, param); param.append("(){}"); return; } } super.doVisitParameterizedTypeReference(reference, param); }
/** * 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; } }
public FunctionTypeKind getFunctionTypeKind(ParameterizedTypeReference typeReference) { JvmType type = typeReference.getType(); if (type.eClass() == TypesPackage.Literals.JVM_GENERIC_TYPE) { JvmDeclaredType outerType = ((JvmGenericType) type).getDeclaringType(); if (outerType != null) { if (Procedures.class.getName().equals(outerType.getIdentifier())) { return FunctionTypeKind.PROCEDURE; } if (Functions.class.getName().equals(outerType.getIdentifier())) { return FunctionTypeKind.FUNCTION; } } } return FunctionTypeKind.NONE; }
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 public Boolean doVisitParameterizedTypeReference(ParameterizedTypeReference reference, LightweightTraversalData data) { JvmType type = reference.getType(); // TODO improve handling of redundant super types where a better path to the supertype exists /* * e.g. MyList extends AbstractList implements List<String> {} * the implements clause seems to be redundant but provides more reliable information */ if (!type.eIsProxy() && data.getVisited().add(type)) { return doVisitParameterizedTypeReference(reference, type, data); } return Boolean.FALSE; }
@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 void doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { JvmType rawType = reference.getType(); if (rawType.eClass() == TypesPackage.Literals.JVM_GENERIC_TYPE) { List<JvmTypeParameter> typeParameters = ((JvmTypeParameterDeclarator) rawType).getTypeParameters(); for(int i = 0, size = typeParameters.size(); i < size; i++) { JvmTypeParameter typeParameter = typeParameters.get(i); reference.addTypeArgument(owner.newParameterizedTypeReference(typeParameter)); } } } });
@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); } } } }
@Override protected void doVisitCompoundTypeReference(CompoundTypeReference reference, ParameterizedTypeReference declaration) { JvmType type = declaration.getType(); if (type instanceof JvmTypeParameter) { JvmTypeParameter unboundTypeParameter = (JvmTypeParameter) type; if (shouldProcess(unboundTypeParameter)) { processTypeParameter(unboundTypeParameter, reference); } } else { super.doVisitCompoundTypeReference(reference, declaration); } } }
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; }
@Override protected void doVisitParameterizedTypeReference(ParameterizedTypeReference reference, ArrayTypeReference declaration) { JvmType type = reference.getType(); if (type instanceof JvmTypeParameter) { if (shouldProcess((JvmTypeParameter) type)) { JvmTypeParameter typeParameter = (JvmTypeParameter) type; processTypeParameter(typeParameter, declaration); } } else { LightweightTypeReference declarationAsList = declaration.tryConvertToListType(); outerVisit(declarationAsList, reference); } }
@Override protected LightweightTypeReference doVisitParameterizedTypeReference(ParameterizedTypeReference reference, ResourceSet resourceSet) { JvmType type = reference.getType(); if (reference.isRawType() && !(type instanceof JvmTypeParameter)) { return reference; } if (type instanceof JvmTypeParameter) { return getRawTypeFromConstraints(reference.getOwner(), (JvmTypeParameter) type, resourceSet); } return reference.getOwner().toPlainTypeReference(type); }
private int internalGetPrimitiveKindFromWrapper(ParameterizedTypeReference typeReference) { JvmType type = typeReference.getType(); if (type == null || type.eIsProxy()) { return PRIMITIVE_NONE; } EClass eClass = type.eClass(); if (eClass != TypesPackage.Literals.JVM_GENERIC_TYPE) { if (eClass == TypesPackage.Literals.JVM_TYPE_PARAMETER) { return internalGetPrimitiveKindFromWrapper((JvmTypeParameter)type, null); } return PRIMITIVE_NONE; } return internalGetPrimitiveKindFromWrapper((JvmGenericType)type); }
@Override protected LightweightTypeReference doVisitParameterizedTypeReference(ParameterizedTypeReference reference, Visiting visiting) { if (reference.isResolved() && reference.isOwnedBy(getOwner())) return reference; JvmType type = reference.getType(); if (type instanceof JvmTypeParameter) { LightweightTypeReference boundTypeArgument = getBoundTypeArgument(reference, (JvmTypeParameter) type, visiting); if (boundTypeArgument != null) return boundTypeArgument; } return doVisitParameterizedTypeReference(reference, type, visiting); }
@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.isSubtypeOf(Iterable.class)) { ArrayTypeReference array = declaration.tryConvertToArray(); if (array != null) { outerVisit(array, reference); } } }