org.eclipse.xtext.xbase.typesystem.util.CommonTypeComputationServices Java Examples

/**
 * Returns false if the argument expression is a lambda and the expected type
 * of the argument is not a function type or {@link Object}.
 * Returns true in all other cases.
 * 
 * This serves as a shortcut to rule out decision path's where a method is overloaded
 * and one of the overloads accepts a function type but the other doesn't. In those cases
 * it is not necessary to compute the type of the lamdba expression twice.
 * 
 * An example for this pattern is {@link IterableExtensions#filter(Iterable, Class)} vs
 * {@link IterableExtensions#filter(Iterable, org.eclipse.xtext.xbase.lib.Functions.Function1)}.
 */
protected boolean isPossibleFunctionType(int idx) {
	if (idx < arguments.getArgumentCount()) {
		XExpression argument = arguments.getArgument(idx);
		if (argument instanceof XClosure) {
			XClosure closure = (XClosure) argument;
			LightweightTypeReference declaredType = arguments.getDeclaredTypeForLambda(idx);
			if (declaredType != null && !declaredType.isType(Object.class)) {
				CommonTypeComputationServices services = getState().getReferenceOwner().getServices();
				JvmOperation operation = services.getFunctionTypes().findImplementingOperation(declaredType);
				if (operation == null) {
					return false;
				}
				if (closure.isExplicitSyntax() && closure.getDeclaredFormalParameters().size() != operation.getParameters().size()) {
					return false;
				}
			}
		}
	}
	return true;
}
 

/**
 * Returns an existing instance of {@link RawResolvedFeatures} or creates a new one that
 * will be cached on the type. It will not add itself as {@link EContentAdapter} but use
 * the {@link JvmTypeChangeDispatcher} instead.
 */
static RawResolvedFeatures getResolvedFeatures(JvmDeclaredType type, CommonTypeComputationServices services) {
	final List<Adapter> adapterList = type.eAdapters();
	RawResolvedFeatures adapter = (RawResolvedFeatures) EcoreUtil.getAdapter(adapterList, RawResolvedFeatures.class);
	if (adapter != null) {
		return adapter;
	}
	final RawResolvedFeatures newAdapter = new RawResolvedFeatures(type, services);
	requestNotificationOnChange(type, new Runnable() {
		@Override
		public void run() {
			newAdapter.clear();
			adapterList.remove(newAdapter);
		}
	});
	adapterList.add(newAdapter);
	return newAdapter;
}
 

/** Convert a type to a lightweight type reference.
 *
 * @param type - type to convert.
 * @param services - services used for the conversion
 * @param keepUnboundWildcardInformation - indicates if the unbound wild card
 *        information must be keeped in the lightweight reference.
 * @return the lightweight type reference.
 */
public static LightweightTypeReference toLightweightTypeReference(
		JvmType type, CommonTypeComputationServices services,
		boolean keepUnboundWildcardInformation) {
	if (type == null) {
		return null;
	}
	final StandardTypeReferenceOwner owner = new StandardTypeReferenceOwner(services, type);
	final LightweightTypeReferenceFactory factory = new LightweightTypeReferenceFactory(owner,
			keepUnboundWildcardInformation);
	final LightweightTypeReference reference = factory.toLightweightReference(type);
	return reference;
}
 

/** Convert a type reference to a lightweight type reference.
 *
 * @param typeRef - reference to convert.
 * @param services - services used for the conversion
 * @param keepUnboundWildcardInformation - indicates if the unbound wild card
 *        information must be keeped in the lightweight reference.
 * @return the lightweight type reference.
 */
public static LightweightTypeReference toLightweightTypeReference(
		JvmTypeReference typeRef, CommonTypeComputationServices services,
		boolean keepUnboundWildcardInformation) {
	if (typeRef == null) {
		return null;
	}
	final StandardTypeReferenceOwner owner = new StandardTypeReferenceOwner(services, typeRef);
	final LightweightTypeReferenceFactory factory = new LightweightTypeReferenceFactory(owner,
			keepUnboundWildcardInformation);
	final LightweightTypeReference reference = factory.toLightweightReference(typeRef);
	return reference;
}
 

/** Filter the type in order to create the correct processor.
 *
 * @param type the type of the processor specified into the {@code @Active} annotation.
 * @param services the type services of the framework.
 * @return the real type of the processor to instance.
 */
public static JvmType filterActiveProcessorType(JvmType type, CommonTypeComputationServices services) {
	if (AccessorsProcessor.class.getName().equals(type.getQualifiedName())) {
		final JvmType filteredType = services.getTypeReferences().findDeclaredType(SarlAccessorsProcessor.class, type);
		if (filteredType != null) {
			return filteredType;
		}
	}
	return type;
}
 

@Override
protected Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> getDeclaratorParameterMapping() {
	final Wrapper<Map<JvmTypeParameter, LightweightMergedBoundTypeArgument>> receiverTypeParameterMapping = Wrapper.wrap(Collections.<JvmTypeParameter, LightweightMergedBoundTypeArgument>emptyMap());
	XExpression receiver = getReceiver();
	if (receiver != null) {
		LightweightTypeReference receiverType = getReceiverType();
		if (receiverType == null) {
			throw new IllegalStateException("Cannot determine type of receiver "+ getReceiver());
		}
		JvmIdentifiableElement feature = getFeature();
		if (feature instanceof JvmFeature) {
			JvmDeclaredType declaringType = ((JvmFeature) feature).getDeclaringType();
			final LightweightTypeReference declaringTypeReference = receiverType.getOwner().newParameterizedTypeReference(declaringType);
			final TypeConformanceComputationArgument rawConformanceCheck = new TypeConformanceComputationArgument(true, false, false, false, false, false);
			if (declaringTypeReference.isAssignableFrom(receiverType, rawConformanceCheck)) {
				receiverTypeParameterMapping.set(new DeclaratorTypeArgumentCollector().getTypeParameterMapping(receiverType));
			} else {
				CommonTypeComputationServices services = receiverType.getOwner().getServices();
				SynonymTypesProvider synonymProvider = services.getSynonymTypesProvider();
				synonymProvider.collectSynonymTypes(receiverType, new SynonymTypesProvider.Acceptor() {
					
					@Override
					protected boolean accept(LightweightTypeReference synonym, int hints) {
						if (declaringTypeReference.isAssignableFrom(synonym, rawConformanceCheck)) {
							receiverTypeParameterMapping.set(new DeclaratorTypeArgumentCollector().getTypeParameterMapping(synonym));
							return false;
						}
						return true;
					}
				});
			}
			
		} else {
			receiverTypeParameterMapping.set(new DeclaratorTypeArgumentCollector().getTypeParameterMapping(receiverType));
		}
	}
	return receiverTypeParameterMapping.get();
}
 

@Override
public CommonTypeComputationServices getServices() {
	return services;
}
 

/** Change the common type service.
 *
 * @param services the service.
 */
@Inject
public void setCommonTypeComputationServices(CommonTypeComputationServices services) {
	this.services = services;
}
 

@Pure
protected CommonTypeComputationServices getServices() {
  return this.services;
}
 

public CommonTypeComputationServices getServices() {
	return services;
}
 

protected CommonTypeComputationServices getTypeComputationServices() {
	return services;
}
 

protected RawResolvedFeatures(JvmDeclaredType type, CommonTypeComputationServices services) {
	this(createTypeReference(type, services), new OverrideTester());
}
 

/**
 * Static helper method that is used from within the super call in the constructor of
 * {@link RawResolvedFeatures}.
 */
private static LightweightTypeReference createTypeReference(JvmDeclaredType type, CommonTypeComputationServices services) {
	StandardTypeReferenceOwner owner = new StandardTypeReferenceOwner(services, type);
	return owner.newParameterizedTypeReference(type);
}
 

protected CommonTypeComputationServices getServices() {
	return getOwner().getServices();
}
 

public StandardTypeReferenceOwner(CommonTypeComputationServices services, EObject context) {
	super(services, context);
}
 

public StandardTypeReferenceOwner(CommonTypeComputationServices services, Resource context) {
	this(services, context.getResourceSet());
}
 

public StandardTypeReferenceOwner(CommonTypeComputationServices services, EObject context) {
	this(services, context.eResource());
}
 

public StandardTypeReferenceOwner(CommonTypeComputationServices services, /* @Nullable */ ResourceSet context) {
	this.services = services;
	this.context = context;
	this.factory = new LightweightTypeReferenceFactory(this);
}
 

public CommonTypeComputationServices getServices() {
	return owner.getServices();
}
 

public Owner(CommonTypeComputationServices services, ResourceSet context) {
	super(services, context);
}
 

protected boolean isDefiniteEarlyExit(XExpression expression) {
	CommonTypeComputationServices services = getState().getReferenceOwner().getServices();
	return services.getEarlyExitComputer().isDefiniteEarlyExit(expression);
}
 

protected CommonTypeComputationServices getServices() {
	return services;
}
 

protected CommonTypeComputationServices getServices() {
	return services;
}
 

protected CommonTypeComputationServices getServices() {
	return services;
}
 

public StandardTypeReferenceOwner(CommonTypeComputationServices services, ResourceSet context) {
	super(services, context);
}
 

public StandardTypeReferenceOwner(CommonTypeComputationServices services, Resource context) {
	super(services, context);
}
 

/**
 * Access to commonly used services for type references.
 */
CommonTypeComputationServices getServices();
 

/** Replies the type services.
 *
 * @return the type services.
 */
public CommonTypeComputationServices getTypeServices() {
	return this.services;
}
 

/** Convert a type reference to a lightweight type reference.
 *
 * @param typeRef - reference to convert.
 * @param services - services used for the conversion
 * @return the lightweight type reference.
 */
public static LightweightTypeReference toLightweightTypeReference(
		JvmTypeReference typeRef, CommonTypeComputationServices services) {
	return toLightweightTypeReference(typeRef, services, false);
}
 

/** Convert a type reference to a lightweight type reference.
 *
 * @param type - type to convert.
 * @param services - services used for the conversion
 * @return the lightweight type reference.
 */
public static LightweightTypeReference toLightweightTypeReference(
		JvmType type, CommonTypeComputationServices services) {
	return toLightweightTypeReference(type, services, false);
}