Java Code Examples for org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference#copyInto()

protected void applyImplicitReceiver() {
	if (!isStatic()) {
		XExpression implicitReceiver = getImplicitReceiver();
		if (implicitReceiver != null) {
			ResolvedTypes resolvedTypes = getState().getResolvedTypes();
			LightweightTypeReference receiverType = getImplicitReceiverType();
			if (receiverType == null) {
				throw new IllegalStateException("Cannot determine the receiver's type");
			}
			LightweightTypeReference expectedReceiverType = new FeatureLinkHelper().getExpectedReceiverType(getFeature(), receiverType);
			if (expectedReceiverType != null)
				expectedReceiverType = expectedReceiverType.copyInto(resolvedTypes.getReferenceOwner());
			if (receiverType.isSynonym()) {
				receiverType = receiverType.getMultiTypeComponents().get(0);
			}
			TypeExpectation expectation = new TypeExpectation(expectedReceiverType, getState(), false);
			resolvedTypes.acceptType(implicitReceiver, expectation, receiverType.copyInto(resolvedTypes.getReferenceOwner()), false, ConformanceFlags.UNCHECKED);
			if (implicitReceiver instanceof XAbstractFeatureCall) {
				new ImplicitReceiver(getFeatureCall(), (XAbstractFeatureCall) implicitReceiver, getState()).applyToComputationState();
			} else {
				throw new IllegalStateException("unexpected implicit receiver, was: " + implicitReceiver);
			}
		}
	}
}
 

@Override
/* @Nullable */
protected LightweightTypeReference getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type, Set<JvmTypeParameter> visiting) {
	LightweightMergedBoundTypeArgument boundTypeArgument = getTypeParameterMapping().get(type);
	if (boundTypeArgument != null) {
		LightweightTypeReference boundReference = boundTypeArgument.getTypeReference();
		if (boundReference != null && reference != boundReference) {
			if (boundReference instanceof UnboundTypeReference)
				return boundReference.copyInto(getOwner());
			JvmType boundType = boundReference.getType();
			if (boundType != type) {
				if (visiting.add(type)) {
					try {
						LightweightTypeReference result = boundReference.accept(this, visiting);
						return result;
					} finally {
						visiting.remove(type);
					}
				} else {
					return reference;
				}
			} 
		}
	}
	return null;
}
 

protected AbstractTypeExpectation createTypeExpectation(/* @Nullable */ LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean returnType) {
	AbstractTypeExpectation result = null;
	if (expectedType != null) {
		LightweightTypeReference copied = expectedType.copyInto(actualState.getReferenceOwner());
		result = new TypeExpectation(copied, actualState, returnType);
	} else {
		result = new NoExpectation(actualState, returnType);
	}
	return result;
}
 

@Override
protected AbstractTypeExpectation createTypeExpectation(/* @Nullable */ LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean returnType) {
	LightweightTypeReference type = expectedType != null ? expectedType.copyInto(actualState.getReferenceOwner()) : null;
	AbstractTypeExpectation result;
	if (type != null) {
		result = returnType ? new TypeExpectation(type, actualState, returnType) : new RootTypeExpectation(type, actualState);
	} else {
		result = returnType ? new NoExpectation(actualState, returnType) : new RootNoExpectation(actualState, true);
	}
	return result;
}
 

@Override
public void applyToComputationState() {
	ResolvedTypes resolvedTypes = getState().getResolvedTypes();
	
	LightweightTypeReference actualType = resolvedTypes.getActualType(getFeature());
	if (actualType == null)
		throw new IllegalStateException("Cannot determine actual type of already resolved implicit receiver");
	LightweightTypeReference expectedReceiverType = new FeatureLinkHelper().getExpectedReceiverType(getOwner().getFeature(), actualType);
	if (expectedReceiverType != null)
		expectedReceiverType = expectedReceiverType.copyInto(resolvedTypes.getReferenceOwner());
	TypeExpectation expectation = new TypeExpectation(expectedReceiverType, getState(), false);
	resolvedTypes.acceptType(getFeatureCall(), expectation, actualType.copyInto(resolvedTypes.getReferenceOwner()), false, ConformanceFlags.UNCHECKED);
	super.applyToComputationState();
}
 

protected TypeData prepareMerge(TypeData typeData, ITypeReferenceOwner owner) {
	LightweightTypeReference typeReference = typeData.getActualType();
	if (typeData.isOwnedBy(owner) && !(typeReference instanceof UnboundTypeReference))
		return typeData;
	if (typeReference instanceof UnboundTypeReference && super.isResolved(((UnboundTypeReference) typeReference).getHandle())) {
		typeReference = typeReference.getUpperBoundSubstitute();
	}
	return new TypeData(typeData.getExpression(), typeData.getExpectation().copyInto(owner), typeReference.copyInto(owner), typeData.getConformanceFlags(), typeData.isReturnType());
}
 

protected AbstractTypeExpectation createTypeExpectation(/* @Nullable */ LightweightTypeReference expectedType,
		AbstractTypeComputationState actualState, boolean returnType, int flags) {
	AbstractTypeExpectation result = null;
	if (expectedType != null) {
		LightweightTypeReference copied = expectedType.copyInto(actualState.getReferenceOwner());
		result = new ObservableTypeExpectation(copied, actualState, returnType, flags);
	} else {
		result = new NoExpectation(actualState, returnType);
	}
	return result;
}
 

@Override
public ObservableTypeExpectation copyInto(ITypeReferenceOwner referenceOwner) {
	LightweightTypeReference expectedType = getExpectedType();
	if (expectedType == null || expectedType.isOwnedBy(referenceOwner))
		return this;
	return new ObservableTypeExpectation(expectedType.copyInto(referenceOwner), getState(), isReturnType(), flags);
}
 

protected AbstractTypeExpectation createTypeExpectation(/* @Nullable */ LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean voidAllowed, boolean returnType) {
	AbstractTypeExpectation result = null;
	if (expectedType != null) {
		LightweightTypeReference copied = expectedType.copyInto(actualState.getReferenceOwner());
		result = new RootTypeExpectation(copied, actualState);
	} else if (returnType) {
		result = new PendingRootExpectation(actualState, this, voidAllowed);
	} else {
		result = new RootNoExpectation(actualState, voidAllowed);
	}
	return result;
}
 

protected void resolveKnownArgumentType(XExpression argument, LightweightTypeReference knownType,
		/* @Nullable */ LightweightTypeReference declaredType, ITypeComputationState argumentState) {
	if (!(argumentState instanceof AbstractLinkingCandidate.ArgumentTypeComputationState))
		throw new IllegalArgumentException("argumentState was " + argumentState);
	AbstractLinkingCandidate<?>.ArgumentTypeComputationState castedArgumentState = (AbstractLinkingCandidate<?>.ArgumentTypeComputationState) argumentState;
	ResolvedTypes resolvedTypes = getState().getResolvedTypes();
	LightweightTypeReference copiedDeclaredType = declaredType != null ? declaredType.copyInto(resolvedTypes.getReferenceOwner()) : null;
	TypeExpectation expectation = new TypeExpectation(copiedDeclaredType, castedArgumentState, false);
	LightweightTypeReference copiedReceiverType = knownType.copyInto(resolvedTypes.getReferenceOwner());
	// TODO should we use the result of #acceptType?
	int defaultFlags = castedArgumentState.getDefaultFlags();
	resolvedTypes.acceptType(argument, expectation, copiedReceiverType, false, ConformanceFlags.UNCHECKED | defaultFlags);
	if (copiedDeclaredType != null)
		resolveAgainstActualType(copiedDeclaredType, copiedReceiverType, castedArgumentState);
}
 

protected void resolveKnownArgumentType(XExpression argument, LightweightTypeReference knownType,
		/* @Nullable */ LightweightTypeReference declaredType, ITypeComputationState argumentState) {
	if (!(argumentState instanceof AbstractTypeComputationState))
		throw new IllegalArgumentException("argumentState was " + argumentState);
	AbstractTypeComputationState castedArgumentState = (AbstractTypeComputationState) argumentState;
	ResolvedTypes resolvedTypes = getState().getResolvedTypes();
	LightweightTypeReference copiedDeclaredType = declaredType != null ? declaredType.copyInto(resolvedTypes.getReferenceOwner()) : null;
	TypeExpectation expectation = new TypeExpectation(copiedDeclaredType, castedArgumentState, false);
	LightweightTypeReference copiedReceiverType = knownType.copyInto(resolvedTypes.getReferenceOwner());
	// TODO should we use the result of #acceptType?
	resolvedTypes.acceptType(argument, expectation, copiedReceiverType, false, ConformanceFlags.UNCHECKED);
	if (copiedDeclaredType != null)
		resolveAgainstActualType(copiedDeclaredType, copiedReceiverType, castedArgumentState);
}
 

protected LightweightTypeReference toOwnedReference(/* @Nullable */ LightweightTypeReference result) {
	return result != null ? result.copyInto(getReferenceOwner()) : null;
}
 

protected LightweightTypeReference copy(LightweightTypeReference reference) {
	return reference.copyInto(getOwner());
}