protected LightweightTypeReference getActualType(EObject context, JvmIdentifiableElement element) { return typeResolver.resolveTypes(context).getActualType(element); }
protected LightweightTypeReference getExpectedType(XExpression expression) { return typeResolver.resolveTypes(expression).getExpectedType(expression); }
/** * @since 2.7 */ public void resolveBatched(EObject root, CancelIndicator monitor) { batchTypeResolver.resolveTypes(root, monitor); }
protected LightweightTypeReference resolveType(XExpression element, Class<?> clazz) { LightweightTypeReference elementType = typeResolver.resolveTypes(element).getActualType(element); return elementType != null && elementType.isType(clazz) ? elementType : null; }
public IInputKey getExpressionType() { LightweightTypeReference expressionType = xbaseResolver.resolveTypes(xExpression).getReturnType(xExpression); if (expressionType == null) { return new JavaTransitiveInstancesKey(Object.class); } else if (expressionType instanceof UnknownTypeReference) { return new JavaTransitiveInstancesKey(Object.class); } else { return new JavaTransitiveInstancesKey(expressionType.getWrapperTypeIfPrimitive().getJavaIdentifier()); } }
protected JvmIdentifiableElement getReferencedElement(EObject owner, EReference reference) { JvmIdentifiableElement referencedThing = (JvmIdentifiableElement) owner.eGet(reference); if (referencedThing != null && owner instanceof XConstructorCall && referencedThing.eIsProxy()) { JvmIdentifiableElement potentiallyLinkedType = batchTypeResolver.resolveTypes(owner).getLinkedFeature((XConstructorCall)owner); if (potentiallyLinkedType != null && !potentiallyLinkedType.eIsProxy()) { referencedThing = potentiallyLinkedType; } } return referencedThing; }
@Override public LightweightTypeReference getActualType(XExpression expr) { return types.getActualType(expr); }
@Override public LightweightTypeReference getReturnType(XExpression expression, boolean onlyExplicitReturn) { IResolvedTypes delegate = getDelegate(expression); return delegate.getReturnType(expression, onlyExplicitReturn); }
protected static <R extends LocalVariableCapturer> R findLocalClassSupertype(JvmTypeReference typeReference) { if (InferredTypeIndicator.isInferred(typeReference)) { JvmTypeReference equivalent = ((XComputedTypeReference) typeReference).getEquivalent(); return findLocalClassSupertype(equivalent); } if (typeReference instanceof XComputedTypeReference) { IJvmTypeReferenceProvider typeProvider = ((XComputedTypeReference) typeReference).getTypeProvider(); if (typeProvider instanceof LocalVariableCapturer) { @SuppressWarnings("unchecked") R result = (R) typeProvider; return result; } } return null; }
protected LightweightTypeReference getLightweightReturnType(XExpression expr) { IResolvedTypes resolvedTypes = getResolvedTypes(expr); LightweightTypeReference returnType = resolvedTypes.getReturnType(expr); return returnType; }
@Override public List<LightweightTypeReference> getThrownExceptions(XExpression obj) { IResolvedTypes delegate = getDelegate(obj); return delegate.getThrownExceptions(obj); }
public static void captureLocalVariables(JvmTypeReference typeReference, ITypeComputationState state) { LocalVariableCapturer localClassSupertype = findLocalClassSupertype(typeReference); if (localClassSupertype != null) { if (!localClassSupertype.captured) { localClassSupertype.captured = true; localClassSupertype.capture(state); } return; } throw new IllegalStateException("Unexpected typeReference: " + typeReference); }
@Override protected void awaitCapturing() { super.awaitCapturing(); }
protected boolean needsSneakyThrow(XExpression obj, Collection<JvmTypeReference> declaredExceptions) { IResolvedTypes resolvedTypes = getResolvedTypes(obj); List<LightweightTypeReference> thrownExceptions = resolvedTypes.getThrownExceptions(obj); return hasUnhandledException(thrownExceptions, declaredExceptions); }
protected LightweightTypeReference getActualType(XExpression expression) { return typeResolver.resolveTypes(expression).getActualType(expression); }
protected LightweightTypeReference resolveType(XExpression element, Class<?> clazz) { LightweightTypeReference elementType = batchTypeResolver.resolveTypes(element).getActualType(element); return elementType != null && elementType.isType(clazz) ? elementType : null; }
protected LightweightTypeReference getActualType(JvmIdentifiableElement identifiable) { return typeResolver.resolveTypes(identifiable).getActualType(identifiable); }
private LightweightTypeReference determineReturnType(JvmOperation operation) { // operation could have been removed by AA, thus the resource is possibly null if(operation != null && operation.eResource() != null) { return batchTypeResolver.resolveTypes(operation).getActualType(operation); } return null; }
/** Compute the expected type of the given expression. * * @param expr the expression. * @return the expected type of the argument. */ protected LightweightTypeReference getExpectedType(XExpression expr) { final IResolvedTypes resolvedTypes = getTypeResolver().resolveTypes(expr); final LightweightTypeReference actualType = resolvedTypes.getActualType(expr); return actualType; }
/** Compute the expected type of the given expression. * * @param expr the expression. * @return the expected type of the argument. */ protected LightweightTypeReference getExpectedType(XExpression expr) { final IResolvedTypes resolvedTypes = getTypeResolver().resolveTypes(expr); final LightweightTypeReference actualType = resolvedTypes.getActualType(expr); return actualType; }