@Override public LightweightTypeReference doVisitAnyTypeReference(JvmAnyTypeReference reference) { return owner.newAnyTypeReference(); }
private static LightweightTypeReference findTopLevelType(LightweightTypeReference context, String typeName) { ITypeReferenceOwner owner = context.getOwner(); ResourceSet resourceSet = owner.getContextResourceSet(); Resource typeResource = resourceSet.getResource(URIHelperConstants.OBJECTS_URI.appendSegment(typeName), true); EList<EObject> contents = typeResource.getContents(); if (contents.isEmpty()) { return null; } JvmType type = (JvmType) contents.get(0); if (type == null) return null; return owner.newParameterizedTypeReference(type); }
/** * @deprecated use {@link ITypeReferenceOwner#newReferenceTo(Class)} instead. */ /* @NotNull */ @Deprecated protected LightweightTypeReference getRawTypeForName(Class<?> clazz, ITypeReferenceOwner owner) { return owner.newReferenceTo(clazz); }
/** * @see #findDeclaredType(String, ITypeReferenceOwner) * @since 2.14 */ protected LightweightTypeReference getTypeForName(String clazzName, ITypeComputationState state) { JvmType type = findDeclaredType(clazzName, state); ITypeReferenceOwner owner = state.getReferenceOwner(); if (type == null) { return owner.newUnknownTypeReference(clazzName); } return owner.toLightweightTypeReference(type); }
protected JvmType getObjectType() { return owner.getServices().getTypeReferences().findDeclaredType(Object.class, owner.getContextResourceSet()); }
public LightweightTypeReference toPlainTypeReference(JvmType type) { if (type.eClass() == TypesPackage.Literals.JVM_ARRAY_TYPE) { JvmComponentType componentType = ((JvmArrayType) type).getComponentType(); LightweightTypeReference componentTypeReference = toPlainTypeReference(componentType); return owner.newArrayTypeReference(componentTypeReference); } return owner.newParameterizedTypeReference(type); }
@Override protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature) { if (feature instanceof JvmConstructor) { return getState().getReferenceOwner().newReferenceTo(Void.TYPE); ParameterizedTypeReference result = owner.newParameterizedTypeReference(((JvmOperation) feature).getReturnType().getType()); WildcardTypeReference wildcard = owner.newWildcardTypeReference(); wildcard.addUpperBound(owner.toPlainTypeReference(rawTypes.get(0))); result.addTypeArgument(wildcard); return result;
@Override protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature) { if (feature instanceof JvmConstructor) { return getState().getReferenceOwner().toLightweightTypeReference(getState().getTypeReferences().getTypeForName(Void.TYPE, feature)); ParameterizedTypeReference result = owner.newParameterizedTypeReference(((JvmOperation) feature).getReturnType().getType()); WildcardTypeReference wildcard = owner.newWildcardTypeReference(); wildcard.addUpperBound(owner.toPlainTypeReference(rawTypes.get(0))); result.addTypeArgument(wildcard); return result;
@Override public LightweightTypeReference doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { DeclaratorTypeArgumentCollector typeArgumentCollector = new ConstraintAwareTypeArgumentCollector(owner); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> typeParameterMapping = typeArgumentCollector.getTypeParameterMapping(reference); TypeParameterSubstitutor<?> substitutor = new UnboundTypeParameterPreservingSubstitutor(typeParameterMapping, owner); JvmGenericType iterable = (JvmGenericType) owner.getServices().getTypeReferences().findDeclaredType(Iterable.class, owner.getContextResourceSet()); if (iterable == null) { return owner.newReferenceToObject(); } LightweightTypeReference substituteMe = owner.newParameterizedTypeReference(iterable.getTypeParameters().get(0)); LightweightTypeReference substitutedArgument = substitutor.substitute(substituteMe).getUpperBoundSubstitute(); if (substitutedArgument.getType() instanceof JvmTypeParameter && !(owner.getDeclaredTypeParameters().contains(substitutedArgument.getType()))) { return substitutedArgument.getRawTypeReference(); } return substitutedArgument; }
final CompoundTypeReference withSynonyms = state.getReferenceOwner().newCompoundTypeReference(true); LightweightTypeReference iterableOrArray = getAndEnhanceIterableOrArrayFromComponent(parameterType, iterableType, withSynonyms); LightweightTypeReference iterable = null; if (iterableType == null) { iterable = owner.newUnknownTypeReference(Iterable.class.getName()); } else { WildcardTypeReference wildcard = owner.newWildcardTypeReference(); ParameterizedTypeReference iterableTypeRef = owner.newParameterizedTypeReference(iterableType); UnboundTypeReference unbound = state.createUnboundTypeReference(object, iterableType.getTypeParameters().get(0)); wildcard.addUpperBound(unbound);
protected LightweightTypeReference toLightweightTypeReference(JvmFormalParameter parameter) { JvmTypeReference parameterType = parameter.getParameterType(); if (parameterType == null) { return null; } LightweightTypeReference result = owner.toLightweightTypeReference(parameterType); return result; }
protected void _computeTypes(XTypeLiteral object, ITypeComputationState state) { JvmType type = object.getType(); if (type == null) { return; } checkTypeParameterNotAllowedAsLiteral(object, type, state); ITypeReferenceOwner owner = state.getReferenceOwner(); LightweightTypeReference clazz = owner.newParameterizedTypeReference(type); for (int i = 0; i < object.getArrayDimensions().size(); i++) { clazz = owner.newArrayTypeReference(clazz); } if (object.getArrayDimensions().isEmpty()) { if (clazz.isPrimitiveVoid()) { clazz = state.getReferenceOwner().newReferenceTo(Void.class); } else { clazz = clazz.getWrapperTypeIfPrimitive(); } } LightweightTypeReference result = owner.newReferenceTo(Class.class); if (result instanceof ParameterizedTypeReference) { ParameterizedTypeReference parameterizedTypeReference = (ParameterizedTypeReference) result; parameterizedTypeReference.addTypeArgument(clazz); } state.acceptActualType(result); }
@Override public LightweightTypeReference enhance(ParameterizedTypeReference reference) { reference.addTypeArgument(owner.newWildcardTypeReference()); return reference; } });
@Override protected ParameterizedTypeReference doCopyInto(ITypeReferenceOwner owner) { ParameterizedTypeReference result = owner.newParameterizedTypeReference(type); copyTypeArguments(result, owner); return result; }
@Override protected LightweightTypeReference handleNullReference() { return owner.newUnknownTypeReference(); }
protected LightweightTypeReference getDeclaredUpperBound(JvmTypeParameter typeParameter, ConstraintVisitingInfo visiting) { if (!typeParameter.getConstraints().isEmpty()) { JvmTypeConstraint constraint = typeParameter.getConstraints().get(0); if (constraint instanceof JvmUpperBound) { LightweightTypeReference reference = getOwner().toLightweightTypeReference(constraint.getTypeReference()); if (visiting.getCurrentDeclarator() != reference.getType()) { return visitTypeArgument(reference, visiting); } WildcardTypeReference result = getOwner().newWildcardTypeReference(); result.addUpperBound(getObjectReference()); return result; } } return null; }
@Override public LightweightTypeReference enhance(ParameterizedTypeReference reference) { LightweightTypeReference argumentType = owner.newParameterizedTypeReference((JvmType) feature); if (argumentType.isPrimitiveVoid()) { argumentType = owner.newReferenceTo(Void.class); } else { argumentType = argumentType.getWrapperTypeIfPrimitive(); } reference.addTypeArgument(argumentType); return reference; } });
@Override public LightweightTypeReference enhance(ParameterizedTypeReference ref) { ref.addTypeArgument(owner.newReferenceTo(ArrayList.class, new TypeReferenceInitializer<ParameterizedTypeReference>(){ @Override public LightweightTypeReference enhance(ParameterizedTypeReference keyType) { keyType.addTypeArgument(owner.newWildcardExtendsObject()); return keyType; } })); ref.addTypeArgument(owner.toLightweightTypeReference(createOperation.getReturnType())); return ref; } });
protected void _computeTypes(XVariableDeclaration object, ITypeComputationState state) { JvmTypeReference declaredType = object.getType(); LightweightTypeReference lightweightTypeReference = declaredType != null ? state.getReferenceOwner().toLightweightTypeReference(declaredType) : null; variableType = variableType.getOwner().newUnknownTypeReference(); ExtendedEarlyExitComputer earlyExitComputer = state.getReferenceOwner().getServices().getEarlyExitComputer(); if (earlyExitComputer.isDefiniteEarlyExit(computedType.getExpression())) { AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(
protected void _computeTypes(XTryCatchFinallyExpression object, ITypeComputationState state) { List<LightweightTypeReference> caughtExceptions = Lists.newArrayList(); ITypeReferenceOwner referenceOwner = state.getReferenceOwner(); for (XCatchClause catchClause : object.getCatchClauses()) if (catchClause.getDeclaredParam() != null && catchClause.getDeclaredParam().getParameterType() != null) caughtExceptions.add(referenceOwner.toLightweightTypeReference(catchClause.getDeclaredParam().getParameterType())); state.withExpectedExceptions(caughtExceptions).computeTypes(object.getExpression()); for (XCatchClause catchClause : object.getCatchClauses()) { JvmFormalParameter catchClauseParam = catchClause.getDeclaredParam(); JvmTypeReference parameterType = catchClauseParam.getParameterType(); LightweightTypeReference lightweightReference = parameterType != null ? normalizedMultiType(referenceOwner, parameterType) : referenceOwner.newAnyTypeReference(); if (lightweightReference.isSynonym()) { lightweightReference = getCommonSuperType(lightweightReference.getMultiTypeComponents(), referenceOwner); } ITypeComputationState catchClauseState = assignType(catchClauseParam, lightweightReference, state); catchClauseState.withinScope(catchClause); catchClauseState.computeTypes(catchClause.getExpression()); } // TODO validate / handle return / throw in finally block state.withoutExpectation().computeTypes(object.getFinallyExpression()); }