@Override public LightweightTypeReference enhance(ParameterizedTypeReference reference) { reference.addTypeArgument(owner.newWildcardTypeReference()); return reference; } });
@Override public JvmTypeReference toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper) { if (isTypeVisible(visibilityHelper)) { JvmParameterizedTypeReference result = getTypesFactory().createJvmParameterizedTypeReference(); result.setType(type); if (typeArguments != null) { for(LightweightTypeReference typeArgument: typeArguments) { result.getArguments().add(typeArgument.toJavaCompliantTypeReference()); } } return result; } else { return toJavaCompliantTypeReference(getSuperTypes(), visibilityHelper); } }
/** * 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 LightweightTypeReference getRawSuperType(JvmType rawType) { Object result = internalGetSuperType(rawType); if (result instanceof ParameterizedTypeReference) { return (LightweightTypeReference) result; } else if (result != null) { return createRawTypeReference(rawType); } return null; }
@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); }
@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); }
protected boolean enhanceSuperType(List<LightweightTypeReference> superTypes, ParameterizedTypeReference result) { JvmType rawType = result.getType(); ITypeReferenceOwner owner = result.getOwner(); List<JvmTypeParameter> typeParameters = ((JvmTypeParameterDeclarator) rawType).getTypeParameters(); List<LightweightTypeReference> parameterSuperTypes = Lists.newArrayListWithCapacity(superTypes.size()); if (reference instanceof ParameterizedTypeReference) { ParameterizedTypeReference parameterized = (ParameterizedTypeReference) reference; if (!parameterized.hasTypeArguments()) { // raw type candidate - best result return true; LightweightTypeReference parameterReference = parameterized.getTypeArguments().get(i); if (parameterized instanceof FunctionTypeReference && !(parameterReference instanceof WildcardTypeReference)) { FunctionTypeReference functionType = (FunctionTypeReference) parameterized; result.addTypeArgument(parameterSuperType.copyInto(owner)); LightweightTypeReference outer = result.getOuter(); if (outer != null) { List<LightweightTypeReference> outerSuperTypes = Lists.newArrayListWithCapacity(superTypes.size());
@Override protected LocalTypeSubstitutor.SubstitutionResult doVisitParameterizedTypeReference(ParameterizedTypeReference reference, VarianceInfo varianceInfo) { JvmType type = reference.getType(); if (!(type instanceof JvmTypeParameter) && EcoreUtil.isAncestor(boundary, type)) { SubstitutionResult visited = reference.getSuperTypes().get(0).accept(this, varianceInfo); switch(varianceInfo) { case IN: ParameterizedTypeReference result = owner.newParameterizedTypeReference(reference.getType()); boolean didSubstitute = false; for(LightweightTypeReference argument: reference.getTypeArguments()) { SubstitutionResult visited = visitTypeArgument(argument, VarianceInfo.INVARIANT); result.addTypeArgument(visited.typeReference); didSubstitute = didSubstitute || visited.didSubstitute;
protected int doIsConformant(ParameterizedTypeReference left, ParameterizedTypeReference right, int flags) { if (left.getType() == right.getType()) { if ((flags & AS_TYPE_ARGUMENT) != 0) { flags |= AS_NESTED_TYPE_ARGUMENT; if (left.isPrimitiveVoid() || right.isPrimitiveVoid()) { return flags; if (!(right.getType().eClass() == TypesPackage.Literals.JVM_TYPE_PARAMETER)) return flags; } else if ((flags & ALLOW_BOXING) != 0) { Primitive rightPrimitiveKind = right.getPrimitiveKind(); if (rightPrimitiveKind != null) { if (left.isType(Object.class)) { return flags | SUCCESS | BOXING; if (left.isType(String.class)) { return flags; } else if (left.isPrimitive() || right.isPrimitive()) { return flags; if (left.isType(Object.class)) { return flags | SUCCESS | SUBTYPE; JvmType leftType = left.getType(); JvmType rightType = right.getType(); EClass leftEClass = leftType.eClass(); if (leftEClass == TypesPackage.Literals.JVM_GENERIC_TYPE) {
@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 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 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(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 /* @Nullable */ public LightweightTypeReference getSuperType(JvmType rawType) { Object rawResult = internalGetSuperType(rawType); if (rawResult instanceof ParameterizedTypeReference) { return (LightweightTypeReference) rawResult; } else if (rawResult != null) { JvmTypeReference superType = (JvmTypeReference) rawResult; if (isRawType()) { return createRawTypeReference(rawType); } if (superType.eClass() == TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE) { if (((JvmParameterizedTypeReference) superType).getArguments().isEmpty()) { return getOwner().newParameterizedTypeReference(rawType); } } LightweightTypeReference unresolved = getOwner().toLightweightTypeReference(rawType); TypeParameterSubstitutor<?> substitutor = createSubstitutor(); LightweightTypeReference result = substitutor.substitute(unresolved); return result; } return null; }
private LightweightTypeReference getSuperTypeByName(String typeName, boolean interfaceType) { JvmTypeReference superType = getSuperTypeByName(typeName, interfaceType, type, new RecursionGuard<JvmType>()); if (superType != null) { JvmType rawType = superType.getType(); if (isRawType()) { return createRawTypeReference(rawType); } if (superType.eClass() == TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE) { if (((JvmParameterizedTypeReference) superType).getArguments().isEmpty()) { return getOwner().newParameterizedTypeReference(rawType); } } LightweightTypeReference unresolved = getOwner().toLightweightTypeReference(rawType); TypeParameterSubstitutor<?> substitutor = createSubstitutor(); LightweightTypeReference result = substitutor.substitute(unresolved); return result; } return null; }
@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 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); }
@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); } } }
@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 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; }