/** * @since 2.7 */ public void resolveBatched(EObject root, CancelIndicator monitor) { batchTypeResolver.resolveTypes(root, monitor); }
private void resolveTypes(final XExpression expression) { final Resource resource = expression.eResource(); IResolvedTypes resolvedTypes = this.resolvedTypesPerResource.get(resource); if ((resolvedTypes == null)) { resolvedTypes = this.typeResolver.resolveTypes(expression); this.resolvedTypesPerResource.put(resource, resolvedTypes); } this.resolvedTypesStack.push(resolvedTypes); }
protected LightweightTypeReference getActualType(EObject context, JvmIdentifiableElement element) { return typeResolver.resolveTypes(context).getActualType(element); }
protected LightweightTypeReference getActualType(XExpression expression) { return typeResolver.resolveTypes(expression).getActualType(expression); }
protected LightweightTypeReference getExpectedType(XExpression expression) { return typeResolver.resolveTypes(expression).getExpectedType(expression); }
protected LightweightTypeReference getActualType(JvmIdentifiableElement identifiable) { return typeResolver.resolveTypes(identifiable).getActualType(identifiable); }
public InvokedResolvedOperation resolve(XAbstractFeatureCall featureCall) { IResolvedTypes resolvedTypes = batchTypeResolver.resolveTypes(featureCall); ITypeReferenceOwner owner = new StandardTypeReferenceOwner(services, featureCall); return resolve(featureCall, resolvedTypes, owner); }
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; }
protected LightweightTypeReference resolveType(XExpression element, Class<?> clazz) { LightweightTypeReference elementType = typeResolver.resolveTypes(element).getActualType(element); return elementType != null && elementType.isType(clazz) ? elementType : 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; }
/** * @param context unused in this context but required for dispatching * @param indicator unused in this context but required for dispatching */ protected Object _doEvaluate(XStringLiteral literal, IEvaluationContext context, CancelIndicator indicator) { LightweightTypeReference type = typeResolver.resolveTypes(literal).getActualType(literal); if (type != null && (type.isType(Character.TYPE) || type.isType(Character.class))) { return literal.getValue().charAt(0); } return literal.getValue(); }
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; }
protected Object internalEvaluate(XExpression expression, IEvaluationContext context, CancelIndicator indicator) throws EvaluationException { if (indicator.isCanceled()) throw new InterpreterCanceledException(); Object result = doEvaluate(expression, context, indicator); final LightweightTypeReference expectedType = typeResolver.resolveTypes(expression).getExpectedType(expression); if(expectedType != null) result = wrapOrUnwrapArray(result, expectedType); return result; }
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 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); }
@Check public void checkVariableIsNotInferredAsVoid(XVariableDeclaration declaration) { if (declaration.getType() != null) return; LightweightTypeReference variableType = typeResolver.resolveTypes(declaration).getActualType((JvmIdentifiableElement) declaration); // TODO move to type resolver if (variableType != null && variableType.isPrimitiveVoid()) { error("void is an invalid type for the variable " + declaration.getName(), declaration, XbasePackage.Literals.XVARIABLE_DECLARATION__NAME, INVALID_USE_OF_TYPE); } }
protected Object _doEvaluate(XIfExpression ifExpression, IEvaluationContext context, CancelIndicator indicator) { Object conditionResult = internalEvaluate(ifExpression.getIf(), context, indicator); if (Boolean.TRUE.equals(conditionResult)) { return internalEvaluate(ifExpression.getThen(), context, indicator); } else { if (ifExpression.getElse() == null) return getDefaultObjectValue(typeResolver.resolveTypes(ifExpression).getActualType(ifExpression)); return internalEvaluate(ifExpression.getElse(), context, indicator); } }
@Check public void checkReturnTypeOfCheckConstraints(CheckConstraint checkConstraint) { XExpression xExpression = checkConstraint.getExpression(); if (xExpression != null) { final IResolvedTypes resolvedType = typeResolver.resolveTypes(xExpression); LightweightTypeReference type = resolvedType.getReturnType(xExpression); if (type.getPrimitiveIfWrapperType().getPrimitiveKind() != Primitive.Boolean) { error("Check expressions must return boolean instead of " + type.getSimpleName(), checkConstraint, PatternLanguagePackage.Literals.CHECK_CONSTRAINT__EXPRESSION, IssueCodes.CHECK_MUST_BE_BOOLEAN); } } }
@Check public void checkReturnTypeOfCheckConstraints(CheckConstraint checkConstraint) { XExpression xExpression = checkConstraint.getExpression(); if (xExpression != null) { final IResolvedTypes resolvedType = typeResolver.resolveTypes(xExpression); LightweightTypeReference type = resolvedType.getReturnType(xExpression); if (type.getPrimitiveIfWrapperType().getPrimitiveKind() != Primitive.Boolean) { error("Check expressions must return boolean instead of " + type.getSimpleName(), checkConstraint, PatternLanguagePackage.Literals.CHECK_CONSTRAINT__EXPRESSION, IssueCodes.CHECK_MUST_BE_BOOLEAN); } } }