org.eclipse.xtext.xbase.typesystem.computation.ITypeComputationResult Java Examples

@Override
public ITypeComputationResult computeTypes(/* @Nullable */ XExpression expression) {
	if (expression == null) {
		throw new IllegalArgumentException("XExpression may not be null");
	}
	StackedResolvedTypes resolvedTypes = components[0].doComputeTypes(expression);
	int flags = resolvedTypes.getConformanceFlags(expression, false);
	for(int i = 1; i < components.length; i++) {
		StackedResolvedTypes candidate = components[i].doComputeTypes(expression);
		int candidateFlags = candidate.getConformanceFlags(expression, false);
		int compareResult = compareFlags(flags, candidateFlags);
		if (compareResult == 1) {
			resolvedTypes = candidate;
			flags = candidateFlags;
		}
	}
	resolvedTypes.performMergeIntoParent();
	ResolutionBasedComputationResult result = new ResolutionBasedComputationResult(expression, resolvedTypes.getParent());
	return result;
}
 

@Override
public final ITypeComputationResult computeTypes(/* @Nullable */ XExpression expression) {
	resolvedTypes.checkCanceled();
	if (expression != null) {
		if (expression.eContainer() == null && expression.eResource() == null)
			throw new IllegalStateException("Dangling expression: " + expression);
		assert getResolvedTypes().doGetTypeData(expression) == null : "Expression was already resolved: " + expression;  
		ExpressionAwareStackedResolvedTypes stackedResolvedTypes = doComputeTypes(expression);
		stackedResolvedTypes.performMergeIntoParent();
		return new ResolutionBasedComputationResult(expression, resolvedTypes);
	} else {
		return new NoTypeResult(null, getReferenceOwner());
	}
}
 

@Override
protected ITypeComputationResult createNoTypeResult() {
	JvmOperation operation = (JvmOperation) getMember();
	LightweightTypeReference expectedType = ((LogicalContainerAwareReentrantTypeResolver)getResolver()).getReturnTypeOfOverriddenOperation(operation, resolvedTypes, getFeatureScopeSession());
	if (expectedType != null) {
		InferredTypeIndicator.resolveTo(operation.getReturnType(), expectedType.toJavaCompliantTypeReference());
	}
	return new NoTypeResult(getMember(), resolvedTypes.getReferenceOwner());
}
 

@Override
protected ITypeComputationResult createNoTypeResult() {
	return new NoTypeResult(null, resolvedTypes.getReferenceOwner());
}
 

@Override
public ITypeComputationResult computeTypes(/* @Nullable */ XExpression expression) {
	return delegate.computeTypes(expression);
}
 

public ITypeComputationResult computeTypes() {
	XExpression rootExpression = getRootExpression();
	if (rootExpression == null)
		return createNoTypeResult();
	return computeTypes(rootExpression);
}
 

@Override
protected ITypeComputationResult createNoTypeResult() {
	return new NoTypeResult(getMember(), resolvedTypes.getReferenceOwner());
}
 

@Override
protected ITypeComputationResult createNoTypeResult() {
	return new NoTypeResult(annotationValue, resolvedTypes.getReferenceOwner());
}
 

@Override
protected ITypeComputationResult createNoTypeResult() {
	return new NoTypeResult(getMember(), resolvedTypes.getReferenceOwner());
}
 

/** Compute the best candidates for the feature behind the cast operator.
 *
 * @param cast the cast operator.
 * @return the candidates.
 */
public List<? extends ILinkingCandidate> getLinkingCandidates(SarlCastedExpression cast) {
	// Prepare the type resolver.
	final StackedResolvedTypes demandComputedTypes = pushTypes();
	final AbstractTypeComputationState forked = withNonVoidExpectation(demandComputedTypes);
	final ForwardingResolvedTypes demandResolvedTypes = new ForwardingResolvedTypes() {
		@Override
		protected IResolvedTypes delegate() {
			return forked.getResolvedTypes();
		}

		@Override
		public LightweightTypeReference getActualType(XExpression expression) {
			final LightweightTypeReference type = super.getActualType(expression);
			if (type == null) {
				final ITypeComputationResult result = forked.computeTypes(expression);
				return result.getActualExpressionType();
			}
			return type;
		}
	};

	// Create the scope
	final IScope scope = getCastScopeSession().getScope(cast,
			// Must be the feature of the AbstractFeatureCall in order to enable the scoping for a function call.
			//XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE,
			SarlPackage.Literals.SARL_CASTED_EXPRESSION__FEATURE,
			demandResolvedTypes);

	// Search for the features into the scope
	final LightweightTypeReference targetType = getReferenceOwner().toLightweightTypeReference(cast.getType());
	final List<ILinkingCandidate> resultList = Lists.newArrayList();
	final LightweightTypeReference expressionType = getStackedResolvedTypes().getActualType(cast.getTarget());
	final ISelector validator = this.candidateValidator.prepare(
			getParent(), targetType, expressionType);
	// FIXME: The call to getAllElements() is not efficient; find another way in order to be faster.
	for (final IEObjectDescription description : scope.getAllElements()) {
		final IIdentifiableElementDescription idesc = toIdentifiableDescription(description);
		if (validator.isCastOperatorCandidate(idesc)) {
			final ExpressionAwareStackedResolvedTypes descriptionResolvedTypes = pushTypes(cast);
			final ExpressionTypeComputationState descriptionState = createExpressionComputationState(cast, descriptionResolvedTypes);
			final ILinkingCandidate candidate = createCandidate(cast, descriptionState, idesc);
			if (candidate != null) {
				resultList.add(candidate);
			}
		}
	}

	return resultList;
}
 

protected abstract ITypeComputationResult createNoTypeResult();