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

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);
		}
	}
}
 

@Test
public void testAllOperationsIncludeDeclaredOperations() {
  final ResolvedFeatures resolvedOperations = this.toResolvedOperations(ResolvedFeaturesTest.DerivedClass.class);
  final List<IResolvedOperation> declared = resolvedOperations.getDeclaredOperations();
  final List<IResolvedOperation> all = resolvedOperations.getAllOperations();
  Assert.assertFalse(all.isEmpty());
  Assert.assertEquals(1, declared.size());
  Assert.assertSame(IterableExtensions.<IResolvedOperation>head(declared), IterableExtensions.<IResolvedOperation>head(all));
}
 

@Test
public void testDeclaredOperationsAreIncludedInAllOperations() {
  final ResolvedFeatures resolvedOperations = this.toResolvedOperations(ResolvedFeaturesTest.DerivedClass.class);
  final List<IResolvedOperation> all = resolvedOperations.getAllOperations();
  final List<IResolvedOperation> declared = resolvedOperations.getDeclaredOperations();
  Assert.assertFalse(all.isEmpty());
  Assert.assertEquals(1, declared.size());
  Assert.assertSame(IterableExtensions.<IResolvedOperation>head(declared), IterableExtensions.<IResolvedOperation>head(all));
}
 

@Test
public void testDeclaredOperationsErasedSignatureAreIncludedInAllOperations() {
  final ResolvedFeatures resolvedOperations = this.toResolvedOperations(ResolvedFeaturesTest.DerivedClass.class);
  final List<IResolvedOperation> all = resolvedOperations.getAllOperations(ResolvedFeaturesTest.DERIVED_CLASS_METHOD_ERASED_SIGNATURE);
  final List<IResolvedOperation> declared = resolvedOperations.getDeclaredOperations(ResolvedFeaturesTest.DERIVED_CLASS_METHOD_ERASED_SIGNATURE);
  Assert.assertFalse(all.isEmpty());
  Assert.assertEquals(1, declared.size());
  Assert.assertSame(IterableExtensions.<IResolvedOperation>head(declared), IterableExtensions.<IResolvedOperation>head(all));
}
 

@Test
public void testAllOperationsErasedSignatureIncludeDeclaredOperations() {
  final ResolvedFeatures resolvedOperations = this.toResolvedOperations(ResolvedFeaturesTest.DerivedClass.class);
  final List<IResolvedOperation> declared = resolvedOperations.getDeclaredOperations(ResolvedFeaturesTest.DERIVED_CLASS_METHOD_ERASED_SIGNATURE);
  final List<IResolvedOperation> all = resolvedOperations.getAllOperations(ResolvedFeaturesTest.DERIVED_CLASS_METHOD_ERASED_SIGNATURE);
  Assert.assertFalse(all.isEmpty());
  Assert.assertEquals(1, declared.size());
  Assert.assertSame(IterableExtensions.<IResolvedOperation>head(declared), IterableExtensions.<IResolvedOperation>head(all));
}
 

@Test
public void testArrayListHasNoAbstractMethods() {
  final ResolvedFeatures resolvedOperations = this.toResolvedOperations(ArrayList.class);
  final List<IResolvedOperation> all = resolvedOperations.getAllOperations();
  Assert.assertFalse(all.isEmpty());
  final Consumer<IResolvedOperation> _function = (IResolvedOperation it) -> {
    Assert.assertFalse(it.getDeclaration().isAbstract());
  };
  all.forEach(_function);
}
 

@Test
public void testIterableIterator() {
  final ResolvedFeatures resolvedOperations = this.toResolvedOperations(Iterable.class);
  final List<IResolvedOperation> all = resolvedOperations.getAllOperations();
  Assert.assertFalse(all.isEmpty());
  final Function1<IResolvedOperation, Boolean> _function = (IResolvedOperation it) -> {
    return Boolean.valueOf(it.getDeclaration().isAbstract());
  };
  final IResolvedOperation iterator = Iterables.<IResolvedOperation>getOnlyElement(IterableExtensions.<IResolvedOperation>filter(all, _function));
  Assert.assertEquals("java.lang.Iterable.iterator()", iterator.getDeclaration().getIdentifier());
}
 

protected IResolvedExecutable _resolveExecutable(JvmOperation operation, XAbstractFeatureCall featureCall,
		IResolvedTypes resolvedTypes) {
	XExpression actualReceiver = featureCall.getActualReceiver();
	if (actualReceiver != null) {
		LightweightTypeReference actualType = resolvedTypes.getActualType(actualReceiver);
		ResolvedFeatures resolvedFeatures = overrideHelper.getResolvedFeatures(actualType);
		for (IResolvedOperation resolvedOperation : resolvedFeatures.getAllOperations()) {
			if (resolvedOperation.getDeclaration().equals(operation)) {
				return resolvedOperation;
			}
		}
	}
	return null;
}
 

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);
	}
}