Java Code Examples for org.eclipse.xtext.xbase.typesystem.override.ResolvedFeatures#getType()

protected void addConstructorCandidates(ResolvedFeatures resolvedFeatures, IVisibilityHelper visibilityHelper,
		List<IResolvedExecutable> result) {
	LightweightTypeReference typeReference = resolvedFeatures.getType();
	List<LightweightTypeReference> superTypes = typeReference.getSuperTypes();
	for (LightweightTypeReference superType : superTypes) {
		if (!superType.isInterfaceType()) {
			List<IResolvedConstructor> declaredConstructors = resolvedFeatures.getDeclaredConstructors();
			Set<String> erasedSignatures = Sets.<String>newHashSet();
			for (IResolvedConstructor constructor : declaredConstructors) {
				erasedSignatures.add(constructor.getResolvedErasureSignature());
			}
			ResolvedFeatures superClass = overrideHelper.getResolvedFeatures(superType);
			for (IResolvedConstructor superclassConstructor : superClass.getDeclaredConstructors()) {
				IResolvedConstructor overriddenConstructor = new ResolvedConstructor(
						superclassConstructor.getDeclaration(), typeReference);
				if (isCandidate(typeReference, overriddenConstructor, visibilityHelper)) {
					if (erasedSignatures.add(superclassConstructor.getResolvedErasureSignature())) {
						result.add(overriddenConstructor);
					}
				}
			}
			return;
		}
	}
}
 

public List<IResolvedExecutable> getImplementationCandidates(JvmDeclaredType type, boolean isAnonymous) {
	if (type == null || !(type instanceof JvmGenericType)) {
		return Collections.emptyList();
	}
	JavaVersion sourceVersion = generatorConfigProvider.get(type).getJavaSourceVersion();
	ResolvedFeatures resolvedFeatures = overrideHelper.getResolvedFeatures(type, sourceVersion);
	List<IResolvedExecutable> result = new ArrayList<>();
	ContextualVisibilityHelper contextualVisibilityHelper = new ContextualVisibilityHelper(visibilityHelper,
			resolvedFeatures.getType());
	addOperationCandidates(resolvedFeatures, contextualVisibilityHelper, result);
	if (!isAnonymous && !((JvmGenericType) type).isInterface()) {
		addConstructorCandidates(resolvedFeatures, contextualVisibilityHelper, result);
	}
	return result;
}
 

protected void addOperationCandidates(ResolvedFeatures resolvedFeatures, IVisibilityHelper visibilityHelper,
		List<IResolvedExecutable> result) {
	List<IResolvedOperation> allOperations = resolvedFeatures.getAllOperations();
	LightweightTypeReference inferredType = resolvedFeatures.getType();
	for (IResolvedOperation operation : allOperations) {
		if (isCandidate(inferredType, operation, visibilityHelper)) {
			result.add(operation);
		}
	}
}
 

protected void doCheckOverriddenMethods(XtendTypeDeclaration xtendType, JvmGenericType inferredType, ResolvedFeatures resolvedFeatures,
		Set<EObject> flaggedOperations) {
	List<IResolvedOperation> operationsMissingImplementation = null;
	boolean doCheckAbstract = !inferredType.isAbstract();
	if (doCheckAbstract) {
		operationsMissingImplementation = Lists.newArrayList();
	}
	IVisibilityHelper visibilityHelper = new ContextualVisibilityHelper(this.visibilityHelper, resolvedFeatures.getType());
	boolean flaggedType = false;
	for (IResolvedOperation operation : resolvedFeatures.getAllOperations()) {
		JvmDeclaredType operationDeclaringType = operation.getDeclaration().getDeclaringType();
		if (operationDeclaringType != inferredType) {
			if (operationsMissingImplementation != null && operation.getDeclaration().isAbstract()) {
				operationsMissingImplementation.add(operation);
			}
			if (visibilityHelper.isVisible(operation.getDeclaration())) {
				String erasureSignature = operation.getResolvedErasureSignature();
				List<IResolvedOperation> declaredOperationsWithSameErasure = resolvedFeatures.getDeclaredOperations(erasureSignature);
				for (IResolvedOperation localOperation : declaredOperationsWithSameErasure) {
					if (!localOperation.isOverridingOrImplementing(operation.getDeclaration()).isOverridingOrImplementing()) {
						EObject source = findPrimarySourceElement(localOperation);
						if (operation.getDeclaration().isStatic() && !localOperation.getDeclaration().isStatic()) {
							if (!isInterface(operationDeclaringType)) {
								if (flaggedOperations.add(source)) {
									error("The instance method "
											+ localOperation.getSimpleSignature()
											+ " cannot override the static method "
											+ operation.getSimpleSignature() + " of type "
											+ getDeclaratorName(operation.getDeclaration()) + ".",
											source, nameFeature(source), DUPLICATE_METHOD);
								}
							}
						} else if (!operation.getDeclaration().isStatic() && localOperation.getDeclaration().isStatic()) {
							if (flaggedOperations.add(source)) {
								error("The static method "
										+ localOperation.getSimpleSignature()
										+ " cannot hide the instance method "
										+ operation.getSimpleSignature() + " of type "
										+ getDeclaratorName(operation.getDeclaration()) + ".",
										source, nameFeature(source), DUPLICATE_METHOD);
							}
						} else if (flaggedOperations.add(source)) {
							error("Name clash: The method "
									+ localOperation.getSimpleSignature() + " of type "
									+ inferredType.getSimpleName()
									+ " has the same erasure as "
									+ operation.getSimpleSignature() + " of type "
									+ getDeclaratorName(operation.getDeclaration()) + " but does not override it.",
									source, nameFeature(source), DUPLICATE_METHOD);
						}
					}
				}
				if (operation instanceof ConflictingDefaultOperation
						&& contributesToConflict(inferredType, (ConflictingDefaultOperation) operation) && !flaggedType) {
					IResolvedOperation conflictingOperation = ((ConflictingDefaultOperation) operation).getConflictingOperations()
							.get(0);
					// Include the declaring class in the issue code in order to give better quick fixes
					String[] uris = new String[] {
							getDeclaratorName(operation.getDeclaration()) + "|"
									+ EcoreUtil.getURI(operation.getDeclaration()).toString(),
							getDeclaratorName(conflictingOperation.getDeclaration()) + "|"
									+ EcoreUtil.getURI(conflictingOperation.getDeclaration()).toString() };
					if (!operation.getDeclaration().isAbstract() && !conflictingOperation.getDeclaration().isAbstract()) {
						error("The type " + inferredType.getSimpleName() + " inherits multiple implementations of the method "
								+ conflictingOperation.getSimpleSignature() + " from "
								+ getDeclaratorName(conflictingOperation.getDeclaration()) + " and "
								+ getDeclaratorName(operation.getDeclaration()) + ".", xtendType,
								XtendPackage.Literals.XTEND_TYPE_DECLARATION__NAME, CONFLICTING_DEFAULT_METHODS, uris);
					} else {
						// At least one of the operations is non-abstract
						IResolvedOperation abstractOp, nonabstractOp;
						if (operation.getDeclaration().isAbstract()) {
							abstractOp = operation;
							nonabstractOp = conflictingOperation;
						} else {
							abstractOp = conflictingOperation;
							nonabstractOp = operation;
						}
						error("The non-abstract method " + nonabstractOp.getSimpleSignature() + " inherited from "
								+ getDeclaratorName(nonabstractOp.getDeclaration()) + " conflicts with the method "
								+ abstractOp.getSimpleSignature() + " inherited from " + getDeclaratorName(abstractOp.getDeclaration())
								+ ".", xtendType, XtendPackage.Literals.XTEND_TYPE_DECLARATION__NAME, CONFLICTING_DEFAULT_METHODS,
								uris);
					}
					flaggedType = true;
				}
			}
		}
	}
	if (operationsMissingImplementation != null && !operationsMissingImplementation.isEmpty() && !flaggedType) {
		reportMissingImplementations(xtendType, inferredType, operationsMissingImplementation);
	}
}