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

@SuppressWarnings("checkstyle:magicnumber")
private static int computeCompliance(LightweightTypeReference target, LightweightTypeReference current) {
	if (isSame(target, current)) {
		return 0;
	}
	final LightweightTypeReference target2 = target.getWrapperTypeIfPrimitive();
	if (target2.isSubtypeOf(Number.class)) {
		final LightweightTypeReference current2 = current.getWrapperTypeIfPrimitive();
		if (current2.isSubtypeOf(Number.class)) {
			return 1 + Math.max(getNumberPrecision(target) - getNumberPrecision(current), 0);
		}
		if (target.isAssignableFrom(current)) {
			return 8;
		}
		return 9;
	}
	if (target.isAssignableFrom(current)) {
		return 1;
	}
	return 2;
}
 

/**
 * @param context unused in this context but required for dispatching
 * @param indicator unused in this context but required for dispatching
 */
@SuppressWarnings("unchecked")
protected Object _doEvaluate(XNumberLiteral literal, IEvaluationContext context, CancelIndicator indicator) {
	IResolvedTypes resolvedTypes = typeResolver.resolveTypes(literal);
	LightweightTypeReference expectedType = resolvedTypes.getExpectedType(literal);
	Class<? extends Number> type = numberLiterals.getJavaType(literal);
	if (expectedType != null && expectedType.isSubtypeOf(Number.class)) {
		try {
			Class<?> expectedClassType = getJavaType(expectedType.toJavaCompliantTypeReference().getType());
			if (expectedClassType.isPrimitive()) {
				expectedClassType = ReflectionUtil.getObjectType(expectedClassType);
			}
			if (Number.class != expectedClassType && Number.class.isAssignableFrom(expectedClassType)) {
				type = (Class<? extends Number>) expectedClassType;
			}
		} catch (ClassNotFoundException e) {
		}
	}
	return numberLiterals.numberValue(literal, type);
}
 

protected void addExceptionDetails(AbstractResolvedOperation overriding, AbstractResolvedOperation overridden,
		EnumSet<OverrideCheckDetails> result) {
	List<LightweightTypeReference> exceptions = overriding.getResolvedExceptions();
	if (exceptions.isEmpty()) {
		return;
	}
	List<LightweightTypeReference> inheritedExceptions = overridden.getResolvedExceptions();
	for(LightweightTypeReference exception: exceptions) {
		if (!exception.isSubtypeOf(RuntimeException.class) && !exception.isSubtypeOf(Error.class)) {
			boolean isDeclared = false;
			for(LightweightTypeReference inheritedException: inheritedExceptions) {
				if (inheritedException.isAssignableFrom(exception)) {
					isDeclared = true;
					break;
				}
			}
			if (!isDeclared) {
				result.add(OverrideCheckDetails.EXCEPTION_MISMATCH);
				return;
			}
		}
	}
}
 

@Override
public List<LightweightTypeReference> getIllegallyDeclaredExceptions() {
	if (getDeclaration().getExceptions().isEmpty())
		return Collections.emptyList();
	List<IResolvedOperation> overriddenAndImplemented = getOverriddenAndImplementedMethods();
	if (overriddenAndImplemented.isEmpty())
		return Collections.emptyList();
	List<LightweightTypeReference> exceptions = getResolvedExceptions();
	List<LightweightTypeReference> result = Lists.newArrayListWithCapacity(exceptions.size());
	for(LightweightTypeReference exception: exceptions) {
		if (!exception.isSubtypeOf(RuntimeException.class) && !exception.isSubtypeOf(Error.class)) {
			if (isIllegallyDeclaredException(exception, overriddenAndImplemented)) {
				result.add(exception);
			}
		}
	}
	return result;
}
 

/**
 * Determine whether the given switch expression is valid for Java version 7
 * or higher.
 */
public boolean isJava7SwitchExpression(XSwitchExpression it) {
	LightweightTypeReference switchType = getSwitchVariableType(it);
	if (switchType == null) {
		return false;
	}
	if (switchType.isSubtypeOf(Integer.TYPE)) {
		return true;
	}
	if (switchType.isSubtypeOf(Enum.class)) {
		return true;
	}
	if (switchType.isSubtypeOf(String.class)) {
		return true;
	}
	return false;
}
 

/** Replies if the first parameter is a subtype of the second parameter.
 *
 * @param context the context.
 * @param subType the subtype to test.
 * @param superType the expected super type.
 * @return the type reference.
 */
@Pure
protected boolean isSubTypeOf(EObject context, JvmTypeReference subType, JvmTypeReference superType) {
	if (isTypeReference(superType) && isTypeReference(subType)) {
		StandardTypeReferenceOwner owner = new StandardTypeReferenceOwner(services, context);
		LightweightTypeReferenceFactory factory = new LightweightTypeReferenceFactory(owner, false);
		LightweightTypeReference reference = factory.toLightweightReference(subType);
		return reference.isSubtypeOf(superType.getType());
	}
	return false;
}
 

protected Object wrapOrUnwrapArray(Object result, LightweightTypeReference expectedType) {
	if (expectedType.isArray() && !(result instanceof Object[])) {
		Class<?> arrayType;
		try {
			arrayType = getJavaType(expectedType.getComponentType().getType());
			return Conversions.unwrapArray(result, arrayType);
		} catch (ClassNotFoundException e) {
			return result;
		}
	} else if (!expectedType.isArray() && expectedType.isSubtypeOf(Iterable.class)) {
		return Conversions.doWrapArray(result);
	}
	return result;
}
 

protected boolean isUnhandledException(LightweightTypeReference thrownException, Collection<JvmTypeReference> declaredExceptions) {
	for(JvmTypeReference declaredException: declaredExceptions) {
		if (thrownException.isSubtypeOf(declaredException.getType())) {
			return false;
		}
	}
	return true;
}
 

/** Replies if the linking to the cast operator functions is enabled.
 *
 * @param cast the cast operator.
 * @return {@code true} if the linking is enabled.
 */
public boolean isCastOperatorLinkingEnabled(SarlCastedExpression cast) {
	final LightweightTypeReference sourceType = getStackedResolvedTypes().getReturnType(cast.getTarget());
	final LightweightTypeReference destinationType = getReferenceOwner().toLightweightTypeReference(cast.getType());
	if (sourceType.isPrimitiveVoid() || destinationType.isPrimitiveVoid()) {
		return false;
	}
	if (sourceType.isPrimitive() && destinationType.isPrimitive()) {
		return false;
	}
	return !sourceType.isSubtypeOf(destinationType.getType());
}
 

@Override
protected boolean canCompileToJavaLambda(XClosure closure, LightweightTypeReference typeRef,
		JvmOperation operation) {
	// This function overrides the super one in order to avoid the generation of a Java 8 lambda when
	// the implemented interface is serializable. In this case, it will avoid issue for serialization and
	// deserialization of  the closure.
	return !typeRef.isSubtypeOf(Serializable.class) && super.canCompileToJavaLambda(closure, typeRef, operation);
}
 

/**
 * Determine whether the given switch expression is valid for Java version 6
 * or lower.
 */
public boolean isJavaSwitchExpression(XSwitchExpression it) {
	LightweightTypeReference switchType = getSwitchVariableType(it);
	if (switchType == null) {
		return false;
	}
	if (switchType.isSubtypeOf(Integer.TYPE)) {
		return true;
	}
	if (switchType.isSubtypeOf(Enum.class)) {
		return true;
	}
	return false;
}
 

@Override
public void accept(LightweightTypeReference type) {
	for(LightweightTypeReference caughtException: caughtExceptions) {
		if (type.isSubtypeOf(caughtException.getType())) {
			return;
		}
	}
	delegate.accept(type);
}
 

/** Validate the return type of the operation.
 *
 * @param expectedTypeName the expected simple name of the return type.
 * @param type the return type.
 * @return {@code true} if the return type is valid; otherwise {@code false}.
 */
protected boolean isValidReturnType(String expectedTypeName, LightweightTypeReference type) {
	if (type != null
			&& (type.isSubtypeOf(this.castType.getType())
			|| (this.primitiveCast && type.isSubtypeOf(this.primitiveCastType.getType())))) {
		return type.getSimpleName().equals(expectedTypeName);
	}
	return false;
}
 

@Override
public boolean isVisible(JvmMember member, /* @Nullable */ LightweightTypeReference receiverType, /* @Nullable */ JvmIdentifiableElement receiverFeature) {
	boolean result = isVisible(member);
	if (result && JvmVisibility.PROTECTED == member.getVisibility()) {
		if (receiverFeature != null) {
			// We bypass this check for qualified.this and qualified.super in the scope provider
			// they are considered to be always visible
			/*
			 * class A {
			 *   class B {
			 *     {
			 *       A.super.toString
			 *     }
			 *   }
			 * }
			 */
			if (isThisSuperOrTypeLiteral(receiverFeature)) {
				if (receiverType == null || !receiverType.isType(Class.class)) {
					return true;
				}
			}
		}
		JvmType contextType = visibilityHelper.getRawContextType();
		if (contextType instanceof JvmDeclaredType) {
			String packageName = visibilityHelper.getPackageName();
			JvmDeclaredType declaringType = member.getDeclaringType();
			String memberPackageName = declaringType.getPackageName();
			if (Strings.equal(packageName, memberPackageName)) {
				return true;
			}
		}
		if (receiverType != null) {
			if (receiverType.isSubtypeOf(contextType)) {
				return true;
			}
			EObject container = contextType.eContainer();
			while (container instanceof JvmType) {
				if (receiverType.isSubtypeOf((JvmType)container)) {
					return true;
				}
				container = container.eContainer();
			}
		}
		return false;
	}
	return result;
}
 

protected boolean validateUnhandledExceptions(JvmExecutable executable, IAcceptor<? super AbstractDiagnostic> result) {
	TypeParameterSubstitutor<?> substitutor = createArgumentTypeSubstitutor();
	List<LightweightTypeReference> unhandledExceptions = null;
	List<LightweightTypeReference> expectedExceptions = getState().getExpectedExceptions();
	ITypeReferenceOwner referenceOwner = getState().getReferenceOwner();
	outer: for(JvmTypeReference typeReference: executable.getExceptions()) {
		LightweightTypeReference exception = referenceOwner.toLightweightTypeReference(typeReference);
		LightweightTypeReference resolvedException = substitutor.substitute(exception);
		if (resolvedException.isSubtypeOf(Throwable.class) && !resolvedException.isSubtypeOf(RuntimeException.class) && !resolvedException.isSubtypeOf(Error.class)) {
			for (LightweightTypeReference expectedException : expectedExceptions) {
				if (expectedException.isAssignableFrom(resolvedException)) {
					continue outer;
				}
			}
			if (unhandledExceptions == null) {
				unhandledExceptions = Lists.newArrayList(resolvedException);
			} else {
				unhandledExceptions.add(resolvedException);
			}
		}
	}
	if (unhandledExceptions != null) {
		String message = null;
		int count = unhandledExceptions.size();
		if (count > 1) {
			message = String.format("Unhandled exception types %s and %s", 
					IterableExtensions.join(unhandledExceptions.subList(0, count - 1), ", "),
					unhandledExceptions.get(count - 1));
		} else {
			message = String.format("Unhandled exception type %s", unhandledExceptions.get(0).getHumanReadableName());
		}
		String[] data = new String[unhandledExceptions.size() + 1];
		for(int i = 0; i < data.length - 1; i++) {
			LightweightTypeReference unhandled = unhandledExceptions.get(i);
			data[i] = EcoreUtil.getURI(unhandled.getType()).toString();
		}
		data[data.length - 1] = EcoreUtil.getURI(getExpression()).toString();
		AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(
				getUnhandledExceptionSeverity(executable), 
				IssueCodes.UNHANDLED_EXCEPTION,
				message, 
				getExpression(),
				getDefaultValidationFeature(), 
				-1, 
				data);
		result.accept(diagnostic);
		return false;
	}
	return true;
}
 

/** Replies if the given JVM element is a SARL agent.
 *
 * @param type the JVM type to test.
 * @return {@code true} if the given type is a SARL agent, or not.
 * @since 0.8
 */
public boolean isSarlAgent(LightweightTypeReference type) {
	return !type.isInterfaceType() && (getSarlElementEcoreType(type) == SarlPackage.SARL_AGENT
			|| type.isSubtypeOf(Agent.class));
}
 

/** Replies if the given JVM element is a SARL skill.
 *
 * @param type the JVM type to test.
 * @return {@code true} if the given type is a SARL skill, or not.
 * @since 0.8
 */
public boolean isSarlSkill(LightweightTypeReference type) {
	return !type.isInterfaceType() && (getSarlElementEcoreType(type) == SarlPackage.SARL_SKILL
			|| type.isSubtypeOf(Skill.class));
}
 

/** Replies if the given JVM element is a SARL capacity.
 *
 * @param type the JVM type to test.
 * @return {@code true} if the given type is a SARL capacity, or not.
 * @since 0.8
 */
public boolean isSarlCapacity(LightweightTypeReference type) {
	return type.isInterfaceType() && (getSarlElementEcoreType(type) == SarlPackage.SARL_CAPACITY
			|| type.isSubtypeOf(Capacity.class));
}
 

/** Replies if the given JVM element is a SARL event.
 *
 * @param type the JVM type to test.
 * @return {@code true} if the given type is a SARL event, or not.
 * @since 0.8
 */
public boolean isSarlEvent(LightweightTypeReference type) {
	return !type.isInterfaceType() && (getSarlElementEcoreType(type) == SarlPackage.SARL_EVENT
			|| type.isSubtypeOf(Event.class));
}
 

/** Replies if the given closure could be represented by an not static anonymous class.
 *
 * @param closure the closure.
 * @param typeRef the type of the closure.
 * @param operation the operation to implement.
 * @return {@code true} if the given closure could be represented by a not-static anonymous class.
 * @since 0.8.6
 */
@SuppressWarnings("static-method")
protected boolean canBeNotStaticAnonymousClass(XClosure closure, LightweightTypeReference typeRef,
		JvmOperation operation) {
	return !typeRef.isSubtypeOf(Serializable.class);
}