@Override public String apply(IResolvedOperation from) { return EcoreUtil.getURI(from.getDeclaration()).toString(); } });
protected boolean isIllegallyDeclaredException(LightweightTypeReference exception, List<IResolvedOperation> overriddenAndImplemented) { for(IResolvedOperation operation: overriddenAndImplemented) { if (operation.getOverrideCheckResult().getDetails().contains(OverrideCheckDetails.EXCEPTION_MISMATCH)) { List<LightweightTypeReference> inheritedExceptions = operation.getResolvedExceptions(); if (inheritedExceptions.isEmpty()) { return true; } boolean isDeclared = false; for(LightweightTypeReference inheritedException: inheritedExceptions) { if (inheritedException.isAssignableFrom(exception)) { isDeclared = true; break; } } if (!isDeclared) { return true; } } } return false; }
@Override public String apply(IResolvedOperation input) { return input.getResolvedErasureSignature(); } });
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 (flaggedOperations.add(source)) { if (operation.getDeclaration().isStatic() && !localOperation.getDeclaration().isStatic()) { error("The instance method " + localOperation.getSimpleSignature() + " cannot override the static method " + operation.getSimpleSignature() + " of type " + getDeclaratorName(operation.getDeclaration()) + ".", source, nameFeature(source), DUPLICATE_METHOD); } else { error("Name clash: The method " + localOperation.getSimpleSignature() + " of type " + inferredType.getSimpleName() + " has the same erasure as " operation.getSimpleSignature() + " of type "
List<IResolvedOperation> exceptionMismatch = null; for (final IResolvedOperation inherited: allInherited) { if (inherited.getOverrideCheckResult().hasProblems()) { overrideProblems = true; final EnumSet<OverrideCheckDetails> details = inherited.getOverrideCheckResult().getDetails(); if (details.contains(OverrideCheckDetails.IS_FINAL)) { error(MessageFormat.format(Messages.SARLValidator_43, inherited.getSimpleSignature()), sourceElement, nameFeature(sourceElement), OVERRIDDEN_FINAL); } else if (details.contains(OverrideCheckDetails.REDUCED_VISIBILITY)) { error(MessageFormat.format(Messages.SARLValidator_44, inherited.getSimpleSignature()), sourceElement, nameFeature(sourceElement), OVERRIDE_REDUCES_VISIBILITY); } else if (details.contains(OverrideCheckDetails.EXCEPTION_MISMATCH)) { final JvmTypeReference inheritedReturnType = inherited.getOverrideCheckResult().getGivenOperation().getReturnType(); final LightweightTypeReference resolvedReturnType = inherited.getOverrideCheckResult().getThisOperation().getResolvedReturnType(); final String signature = inherited.getSimpleSignature(); final EStructuralFeature sourceReturnTypeFeature = returnTypeFeature(sourceElement); error(MessageFormat.format(Messages.SARLValidator_45, && sourceElement instanceof SarlAction) { final SarlAction function = (SarlAction) sourceElement; if (function.getReturnType() == null && !inherited.getResolvedReturnType().isPrimitiveVoid()) { warning(MessageFormat.format(Messages.SARLValidator_46, resolved.getResolvedReturnType().getHumanReadableName()), sourceElement, returnTypeFeature(sourceElement), RETURN_TYPE_SPECIFICATION_IS_RECOMMENDED, inherited.getResolvedReturnType().getIdentifier());
protected void doCheckFunctionOverrides(IResolvedOperation operation, Set<EObject> flaggedOperations) { EObject sourceElement = findPrimarySourceElement(operation); if (sourceElement != null) { List<IResolvedOperation> allInherited = operation.getOverriddenAndImplementedMethods(); if (allInherited.isEmpty()) { if (sourceElement instanceof XtendFunction && flaggedOperations.add(sourceElement)) { XtendFunction function = (XtendFunction) sourceElement; if (function.isOverride()) { error("The method "+ operation.getSimpleSignature() +" of type "+getDeclaratorName(operation.getDeclaration())+" must override a superclass method.", function, XTEND_MEMBER__MODIFIERS, function.getModifiers().indexOf("override"), OBSOLETE_OVERRIDE); } else { for (XAnnotation anno : function.getAnnotations()) { if (anno != null && anno.getAnnotationType() != null && Override.class.getName().equals(anno.getAnnotationType().getIdentifier())) { error("Superfluous @Override annotation", anno, null, OBSOLETE_ANNOTATION_OVERRIDE); } } } } } else if (flaggedOperations.add(sourceElement)) { doCheckFunctionOverrides(sourceElement, operation, allInherited); } } }
return null; IResolvedOperation overriddenMethod = overriddenMethods.get(0); JvmOperation declaration = overriddenMethod.getDeclaration(); XExpression inferredFrom = getInferredFrom(declaration.getReturnType()); return null; LightweightTypeReference result = overriddenMethod.getResolvedReturnType(); return result;
List<IResolvedOperation> exceptionMismatch = null; for(IResolvedOperation inherited: allInherited) { if (inherited.getOverrideCheckResult().hasProblems()) { overrideProblems = true; EnumSet<OverrideCheckDetails> details = inherited.getOverrideCheckResult().getDetails(); if (details.contains(OverrideCheckDetails.IS_FINAL)) { error("Attempt to override final method " + inherited.getSimpleSignature(), sourceElement, nameFeature(sourceElement), OVERRIDDEN_FINAL); } else if (details.contains(OverrideCheckDetails.REDUCED_VISIBILITY)) { error("Cannot reduce the visibility of the overridden method " + inherited.getSimpleSignature(), sourceElement, nameFeature(sourceElement), OVERRIDE_REDUCES_VISIBILITY); } else if (details.contains(OverrideCheckDetails.EXCEPTION_MISMATCH)) { exceptionMismatch.add(inherited); } else if (details.contains(OverrideCheckDetails.RETURN_MISMATCH)) { error("The return type is incompatible with " + inherited.getSimpleSignature(), sourceElement, returnTypeFeature(sourceElement), INCOMPATIBLE_RETURN_TYPE); } else if (details.contains(OverrideCheckDetails.SYNCHRONIZED_MISMATCH)) { XtendFunction function = (XtendFunction) sourceElement; if (!overrideProblems && !function.isOverride() && !function.isStatic()) { error("The method " + resolved.getSimpleSignature() + " of type " + getDeclaratorName(resolved) + " must use override keyword since it actually overrides a supertype method.", function, XTEND_FUNCTION__NAME, MISSING_OVERRIDE); error("The method " + resolved.getSimpleSignature() + " of type " + getDeclaratorName(resolved) + " shadows the method " + resolved.getSimpleSignature() + " of type " + getDeclaratorName(inherited) + ", but does not override it.", function, XTEND_FUNCTION__NAME, function.getModifiers().indexOf("override"), OBSOLETE_OVERRIDE);
@Override public TypeReference getResolvedReturnType() { return this.getCompilationUnit().toTypeReference(this.getDelegate().getResolvedReturnType()); }
protected void createExceptionMismatchError(IResolvedOperation operation, EObject sourceElement, List<IResolvedOperation> exceptionMismatch) { List<LightweightTypeReference> exceptions = operation.getIllegallyDeclaredExceptions(); StringBuilder message = new StringBuilder(100); message.append("The declared exception"); message.append(getDeclaratorName(resolvedOperation)); message.append('.'); message.append(exceptionMismatch.get(i).getSimpleSignature());
boolean isOverridden = false; for (IResolvedOperation conflictingOp : conflictingDefaultOperation.getConflictingOperations()) { if (conflictingOp.getResolvedDeclarator().isSubtypeOf(operation.getDeclaringType())) { isOverridden = true; break;
if(needsNewLine) errorMsg.append("\n- "); errorMsg.append(operation.getSimpleSignature());
if (overriddenMethods.isEmpty()) return null; LightweightTypeReference result = overriddenMethods.get(0).getResolvedReturnType(); return result;
boolean isOverridden = false; for (IResolvedOperation conflictingOp : conflictingDefaultOperation.getConflictingOperations()) { if (conflictingOp.getResolvedDeclarator().isSubtypeOf(operation.getDeclaringType())) { isOverridden = true; break;
protected EObject findPrimarySourceElement(IResolvedOperation operation) { return associations.getPrimarySourceElement(operation.getDeclaration()); }
public String getJavaMethodResolvedErasedSignature(final IResolvedOperation op) { return op.getResolvedErasureSignature(); }
protected String getDeclaratorName(IResolvedOperation resolved) { return getDeclaratorName(resolved.getDeclaration()); }
protected List<IResolvedOperation> computeAllOperations() { JvmType rawType = getRawType(); if (!(rawType instanceof JvmDeclaredType)) { return Collections.emptyList(); } Multimap<String, AbstractResolvedOperation> processedOperations = LinkedHashMultimap.create(); for (IResolvedOperation resolvedOperation : getDeclaredOperations()) { processedOperations.put(resolvedOperation.getDeclaration().getSimpleName(), (AbstractResolvedOperation) resolvedOperation); } if (targetVersion.isAtLeast(JavaVersion.JAVA8)) { computeAllOperationsFromSortedSuperTypes((JvmDeclaredType) rawType, processedOperations); } else { Set<JvmType> processedTypes = Sets.newHashSet(rawType); computeAllOperationsFromSuperTypes((JvmDeclaredType) rawType, processedOperations, processedTypes); } // make sure the declared operations are the first in the list List<IResolvedOperation> result = new ArrayList<IResolvedOperation>(processedOperations.size()); result.addAll(getDeclaredOperations()); for (AbstractResolvedOperation operation : processedOperations.values()) { if (operation.getDeclaration().getDeclaringType() != rawType) { result.add(operation); } } return Collections.unmodifiableList(result); }
protected OverrideCheckDetails getPrimaryValidDetail(IResolvedOperation overriding, JvmOperation overridden) { OverrideCheckDetails result = OverrideCheckDetails.IMPLEMENTATION; JvmOperation declaration = overriding.getDeclaration(); if (declaration.isStatic()) { result = OverrideCheckDetails.SHADOWED; } else if (declaration.isAbstract()) { if (overridden.isAbstract()) { result = OverrideCheckDetails.REPEATED; } else { result = OverrideCheckDetails.REDECLARATION; } } else if (!overridden.isAbstract()) { result = OverrideCheckDetails.OVERRIDE; } return result; }
@Override public IResolvedOperation getOverriddenMethod() { if (!getDeclaration().isAbstract() && getDeclaration().getVisibility() != JvmVisibility.PRIVATE) { List<IResolvedOperation> overriddenAndImplemented = getOverriddenAndImplementedMethods(); for(IResolvedOperation candidate: overriddenAndImplemented) { if (!candidate.getDeclaration().isAbstract()) { return candidate; } } } return null; }