@Override protected LightweightTypeReference handleNullReference() { return owner.newUnknownTypeReference(); }
@Override public LightweightTypeReference doVisitUnknownTypeReference(JvmUnknownTypeReference reference) { if (reference.eIsSet(TypesPackage.Literals.JVM_UNKNOWN_TYPE_REFERENCE__QUALIFIED_NAME)) return owner.newUnknownTypeReference(reference.getQualifiedName()); return owner.newUnknownTypeReference(); }
private LightweightTypeReference createUnknownTypeReference(JvmParameterizedTypeReference reference) { List<INode> nodes = NodeModelUtils.findNodesForFeature(reference, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE); if (nodes.isEmpty()) { Set<EObject> sourceElements = owner.getServices().getJvmModelAssociations().getSourceElements(reference); EObject firstSource = Iterables.getFirst(sourceElements, null); if (firstSource instanceof JvmParameterizedTypeReference) { nodes = NodeModelUtils.findNodesForFeature(firstSource, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE); } } if (nodes.size() == 1) { String name = nodes.get(0).getText().trim(); if (name != null && name.length() != 0) { int lastDot = name.lastIndexOf('.'); int lastDollar = name.lastIndexOf('$'); int lastDotOrDollar = Math.max(lastDot, lastDollar); if (lastDotOrDollar != -1 && lastDotOrDollar != name.length() - 1) { String shortName = name.substring(lastDotOrDollar + 1); if (shortName.length() != 0) { name = shortName; } } return owner.newUnknownTypeReference(name); } } return owner.newUnknownTypeReference(); }
protected void applyType() { state.acceptActualType(state.getReferenceOwner().newUnknownTypeReference(), ConformanceFlags.CHECKED_SUCCESS); }
protected LightweightTypeReference getTypeForName(Class<?> clazz, ITypeComputationState state) { JvmType type = findDeclaredType(clazz, state); ITypeReferenceOwner owner = state.getReferenceOwner(); if (type == null) { return owner.newUnknownTypeReference(clazz.getName()); } return owner.toLightweightTypeReference(type); }
/** * @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); }
/** * Process all children and assign an unknown type to the literal. */ protected void handleCollectionTypeNotAvailable(XCollectionLiteral literal, ITypeComputationState state, Class<?> clazz) { for(XExpression element: literal.getElements()) { state.withNonVoidExpectation().computeTypes(element); } state.acceptActualType(state.getReferenceOwner().newUnknownTypeReference(clazz.getName())); }
/** * @since 2.14 */ protected LightweightTypeReference getRawTypeForName(String clazzName, ITypeComputationState state) { JvmType rawType = findDeclaredType(clazzName, state); if (rawType == null) { return state.getReferenceOwner().newUnknownTypeReference(clazzName); } return state.getReferenceOwner().toPlainTypeReference(rawType); }
@Override public LightweightTypeReference doVisitComputedTypeReference(XComputedTypeReference reference) { IJvmTypeReferenceProvider typeProvider = reference.getTypeProvider(); if (typeProvider instanceof UnboundTypeReferenceResolver) { UnboundTypeReference typeReference = ((UnboundTypeReferenceResolver) typeProvider).getUnboundTypeReference(); return typeReference.copyInto(owner); } JvmTypeReference equivalent = reference.getEquivalent(); if (equivalent == null) return owner.newUnknownTypeReference(); return super.doVisitComputedTypeReference(reference); }
protected void computeFixedArityArgumentType(IFeatureCallArgumentSlot slot, TypeParameterSubstitutor<?> substitutor) { XExpression argument = slot.getArgumentExpression(); if (argument != null) { LightweightTypeReference parameterType = slot.getDeclaredType(); if (parameterType == null) { parameterType = state.getReferenceOwner().newUnknownTypeReference(); } LightweightTypeReference substitutedParameterType = substitutor.substitute(parameterType); AbstractTypeComputationState argumentState = createLinkingTypeComputationState(substitutedParameterType); resolveArgumentType(argument, substitutedParameterType, argumentState); } }
protected ITypeComputationState assignParameters(ITypeAssigner typeAssigner) { XClosure closure = getClosure(); if (closure.isExplicitSyntax() || !closure.getImplicitFormalParameters().isEmpty()) { List<JvmFormalParameter> closureParameters = closure.getFormalParameters(); int paramCount = closureParameters.size(); for(int i = 0; i < paramCount; i++) { JvmFormalParameter closureParameter = closureParameters.get(i); if (closureParameter.getParameterType() != null) { final LightweightTypeReference closureParameterType = typeAssigner.toLightweightTypeReference(closureParameter.getParameterType()); typeAssigner.assignType(closureParameter, closureParameterType); } else { UnknownTypeReference unknownType = typeAssigner.getReferenceOwner().newUnknownTypeReference(); typeAssigner.assignType(closureParameter, unknownType); } } ITypeComputationState result = typeAssigner.getForkedState(); return result; } else { JvmFormalParameter implicitParameter = TypesFactory.eINSTANCE.createJvmFormalParameter(); implicitParameter.setName(IFeatureNames.IT.getFirstSegment()); implicitParameters = Collections.singletonList(implicitParameter); typeAssigner.assignType(implicitParameter, typeAssigner.getReferenceOwner().newUnknownTypeReference()); ITypeComputationState result = typeAssigner.getForkedState(); return result; } } }
return resolvedTypes.getReferenceOwner().newUnknownTypeReference().toJavaCompliantTypeReference();
@Override protected void computeTypes() { ITypeAssigner typeAssigner = getState().withoutRootExpectation().assignTypes(); ITypeComputationState closureBodyTypeComputationState = getClosureBodyTypeComputationState(typeAssigner); closureBodyTypeComputationState.computeTypes(getClosure().getExpression()); getExpectation().acceptActualType(getExpectation().getReferenceOwner().newUnknownTypeReference(), ConformanceFlags.UNCHECKED); }
LightweightTypeReference iterable = null; if (iterableType == null) { iterable = owner.newUnknownTypeReference(Iterable.class.getName()); } else { WildcardTypeReference wildcard = owner.newWildcardTypeReference();
variableType = variableType.getOwner().newUnknownTypeReference();