@Override public LightweightTypeReference getActualType(XExpression expr) { return types.getActualType(expr); }
protected LightweightTypeReference getTypeForVariableDeclaration(XExpression expr) { IResolvedTypes resolvedTypes = getResolvedTypes(expr); LightweightTypeReference actualType = resolvedTypes.getActualType(expr); if (actualType.isPrimitiveVoid()) { LightweightTypeReference expectedType = resolvedTypes.getExpectedType(expr); if (expectedType == null) { expectedType = resolvedTypes.getExpectedReturnType(expr); if (expectedType == null) { expectedType = resolvedTypes.getReturnType(expr); } } if (expectedType != null && !expectedType.isPrimitiveVoid()) { actualType = expectedType; } } return actualType; }
@Override public List<LightweightTypeReference> getActualTypeArguments(XExpression expression) { return delegate().getActualTypeArguments(expression); }
private boolean mustCheckForMandatoryTypeCast(IResolvedTypes resolvedTypes, XExpression expression) { if (resolvedTypes.isRefinedType(expression)) { return true; } LightweightTypeReference actualType = resolvedTypes.getActualType(expression); if (actualType != null && actualType.isMultiType()) { return true; } return false; }
protected JvmTypeReference doGetTypReferenceWithAnotherTypeReference() { IResolvedTypes resolveTypes = typeResolver.resolveTypes(expression); LightweightTypeReference actualType = returnType ? resolveTypes.getReturnType(expression) : resolveTypes.getActualType(expression); if (actualType == null) { actualType = returnType ? resolvedTypes.getExpectedReturnType(expression) : resolvedTypes.getExpectedType(expression); } if (actualType == null) return null; return toJavaCompliantTypeReference(convertLocalType(actualType), session); }
protected LightweightTypeReference getLightweightReturnType(XExpression expr) { IResolvedTypes resolvedTypes = getResolvedTypes(expr); LightweightTypeReference returnType = resolvedTypes.getReturnType(expr); return returnType; }
private LightweightTypeReference findRealReturnType(XExpression expression) { if (expression == null) return null; JvmIdentifiableElement logicalContainer = getLogicalContainerProvider().getLogicalContainer(expression); if (logicalContainer instanceof JvmOperation) { return getLightweightType(logicalContainer); } if (expression instanceof XClosure) { IResolvedTypes resolvedTypes = batchTypeResolver.resolveTypes(expression); LightweightTypeReference type = resolvedTypes.getExpectedType(expression); if (type == null) { type = resolvedTypes.getActualType(expression); } if (type == null) { return null; } FunctionTypeReference functionType = type.tryConvertToFunctionTypeReference(false); if (functionType != null) { return functionType.getReturnType(); } return null; } XExpression containerExpression = EcoreUtil2.getContainerOfType(expression.eContainer(), XExpression.class); if (containerExpression == null) { LightweightTypeReference returnType = getLightweightReturnType(expression); return returnType; } return findRealReturnType(containerExpression); }
appendableWithNewKeyword.append("new "); IResolvedTypes resolvedTypes = batchTypeResolver.resolveTypes(expr); List<LightweightTypeReference> typeArguments = resolvedTypes.getActualTypeArguments(expr); JvmConstructor constructor = expr.getConstructor(); List<JvmTypeParameter> constructorTypeParameters = constructor.getTypeParameters(); if (hasTypeArguments || (expr.isAnonymousClassConstructorCall() && !explicitTypeArguments.isEmpty() && ((JvmGenericType) constructor.getDeclaringType()).isAnonymous())) { if (typeArguments.isEmpty()) { LightweightTypeReference createdType = resolvedTypes.getActualType(expr); typeArguments = createdType.getNamedType().getTypeArguments();
protected void createReceiverProposals(final XExpression receiver, final CrossReference crossReference, final ContentAssistContext context, final IIdeContentProposalAcceptor acceptor) { final IResolvedTypes resolvedTypes = this.typeResolver.resolveTypes(receiver); final LightweightTypeReference receiverType = resolvedTypes.getActualType(receiver); if (((receiverType == null) || receiverType.isPrimitiveVoid())) { return; } final IExpressionScope expressionScope = resolvedTypes.getExpressionScope(receiver, IExpressionScope.Anchor.RECEIVER); IScope scope = null; final EObject currentModel = context.getCurrentModel(); if ((currentModel != receiver)) { if (((currentModel instanceof XMemberFeatureCall) && (((XMemberFeatureCall) currentModel).getMemberCallTarget() == receiver))) { scope = this.syntaxFilteredScopes.create(expressionScope.getFeatureScope(((XAbstractFeatureCall) currentModel)), crossReference); } else { scope = this.syntaxFilteredScopes.create(expressionScope.getFeatureScope(), crossReference); } } else { scope = this.syntaxFilteredScopes.create(expressionScope.getFeatureScope(), crossReference); } this.getCrossrefProposalProvider().lookupCrossReference(scope, crossReference, context, acceptor, this.featureDescriptionPredicate); }
if (receiver == null || receiver.eIsProxy()) return IScope.NULLSCOPE; LightweightTypeReference receiverType = resolvedTypes.getActualType(receiver); if (receiverType != null && !isUnknownReceiverType(receiverType)) { JvmIdentifiableElement linkedReceiver = resolvedTypes.getLinkedFeature(asAbstractFeatureCall(receiver)); boolean typeLiteral = false; IScope root = createTypeLiteralScope(featureCall, receiver, session, resolvedTypes, receiverType, linkedReceiver);
@Override public IExpressionScope getExpressionScope(EObject context, IExpressionScope.Anchor anchor) { IResolvedTypes delegate = getDelegate(context); return delegate.getExpressionScope(context, anchor); }
@Override public boolean hasExpressionScope(EObject context, IExpressionScope.Anchor anchor) { return delegate().hasExpressionScope(context, anchor); }
@Override public Collection<IAmbiguousLinkingCandidate> getAmbiguousLinkingCandidates() { List<IAmbiguousLinkingCandidate> result = Lists.newArrayList(); for(IResolvedTypes delegate: this) { result.addAll(delegate.getAmbiguousLinkingCandidates()); } return result; }
@Override public LightweightTypeReference getReturnType(XExpression expression, boolean onlyExplicitReturn) { IResolvedTypes delegate = getDelegate(expression); return delegate.getReturnType(expression, onlyExplicitReturn); }
protected void _toJavaExpression(XListLiteral literal, ITreeAppendable b) { LightweightTypeReference literalType = batchTypeResolver.resolveTypes(literal).getActualType(literal); if (literalType == null) { b.append("error - couldn't compute type for literal : "+literal); LightweightTypeReference expectedType = batchTypeResolver.resolveTypes(literal).getExpectedType(literal); boolean skipTypeName = false; if (expectedType != null && expectedType.isArray()) {
@Override public IExpressionScope getExpressionScope(EObject context, IExpressionScope.Anchor anchor) { return delegate().getExpressionScope(context, anchor); }
@Override public boolean hasExpressionScope(EObject context, IExpressionScope.Anchor anchor) { IResolvedTypes delegate = getDelegate(context); return delegate.hasExpressionScope(context, anchor); }
@Override public Collection<IAmbiguousLinkingCandidate> getAmbiguousLinkingCandidates() { return delegate().getAmbiguousLinkingCandidates(); }
@Override public LightweightTypeReference getActualType(XExpression expression) { IResolvedTypes delegate = getDelegate(expression); return delegate.getActualType(expression); }
@Override public LightweightTypeReference getReturnType(XExpression expression, boolean onlyExplicitReturn) { return delegate().getReturnType(expression, onlyExplicitReturn); }