Here is a way that this annotation may be used: + * + *
+ * class MyEnumeration<T> implements Enumeration<T> {
+ * {@literal @}Delegate
+ * private Enumeration<T> e;
+ *
+ * public boolean hasMoreElements() {
+ * return e.hasMoreElements();
+ * }
+ * }
+ * Here is a way that this annotation may be used: + * + *
Given a class that declares a method with a postcondition annotation: + * + *
+ * class ArrayListVariant<T> {
+ * {@literal @}EnsuresPresentIf(result = true)
+ * {@literal @}DelegatorMustOverride
+ * public boolean hasMoreElements() {
+ * return e.hasMoreElements();
+ * }
+ * }
+ *
+ * class MyArrayListVariant<T> extends ArrayListVariant<T> {
+ *
+ * {@literal @}Delegate
+ * private ArrayListVariant<T> myList;
+ *
+ *
+ * {@literal @}Override
+ * {@literal @}EnsuresPresentIf(result = true)
+ * public boolean hasMoreElements() {
+ * return myList.hasMoreElements();
+ * }
+ * }
+ * It is not a checker for a type system. It enforces the following syntactic checks: + * + *
A delegate method call must fulfill the following properties: its receiver must be the
+ * current field marked with {@link Delegate} in the class, and the name of the method call must
+ * match that of the enclosing method.
+ *
+ * @param enclosingMethodName the name of the enclosing method
+ * @param delegatedMethodCall the delegated method call
+ * @return true if the given method call is a valid delegate call for the enclosing method
+ */
+ private boolean isValidDelegateCall(
+ Name enclosingMethodName, MethodInvocationTree delegatedMethodCall) {
+ assert delegate != null; // This method should only be invoked when delegate is non-null
+ ExpressionTree methodSelectTree = delegatedMethodCall.getMethodSelect();
+ MemberSelectTree fieldAccessTree = (MemberSelectTree) methodSelectTree;
+ VariableElement delegatedField = TreeUtils.asFieldAccess(fieldAccessTree.getExpression());
+ Name delegatedMethodName = TreeUtils.methodName(delegatedMethodCall);
+ // TODO: is there a better way to check? Comparing names seems fragile.
+ return enclosingMethodName.equals(delegatedMethodName)
+ && delegatedField != null
+ && delegatedField.getSimpleName().equals(delegate.getName());
+ }
+
+ /**
+ * Returns the fields of a class marked with a {@link Delegate} annotation.
+ *
+ * @param tree a class
+ * @return the fields of a class marked with a {@link Delegate} annotation
+ */
+ private List This method is used to identify a possible delegate method call. It will check whether a
+ * method has only one statement (a method invocation or a return statement), and return the
+ * expression that is associated with it. Otherwise, it will return null.
+ *
+ * @param tree the method body
+ * @return the last expression in the method body
+ */
+ private @Nullable MethodInvocationTree getLastExpression(BlockTree tree) {
+ List stmts = tree.getStatements();
+ if (stmts.size() != 1) {
+ return null;
+ }
+ StatementTree stmt = stmts.get(0);
+ ExpressionTree lastExprInMethod = null;
+ if (stmt instanceof ExpressionStatementTree) {
+ lastExprInMethod = ((ExpressionStatementTree) stmt).getExpression();
+ } else if (stmt instanceof ReturnTree) {
+ lastExprInMethod = ((ReturnTree) stmt).getExpression();
+ }
+ if (!(lastExprInMethod instanceof MethodInvocationTree)) {
+ return null;
+ }
+ return (MethodInvocationTree) lastExprInMethod;
+ }
+
+ /**
+ * Return true if the last (and only) statement of the block throws an exception of the given
+ * class.
+ *
+ * @param tree a block tree
+ * @param clazz a class of exception (usually {@link UnsupportedOperationException})
+ * @return true if the last and only statement throws an exception of the given class
+ */
+ private boolean hasExceptionalExit(BlockTree tree, Class clazz) {
+ List stmts = tree.getStatements();
+ if (stmts.size() != 1) {
+ return false;
+ }
+ StatementTree lastStmt = stmts.get(0);
+ if (!(lastStmt instanceof ThrowTree)) {
+ return false;
+ }
+ ThrowTree throwStmt = (ThrowTree) lastStmt;
+ AnnotatedTypeMirror throwType = atypeFactory.getAnnotatedType(throwStmt.getExpression());
+ Class exceptionClass = TypesUtils.getClassFromType(throwType.getUnderlyingType());
+ return exceptionClass.equals(clazz);
+ }
+
+ /**
+ * Validate whether a class overrides all declared methods in its superclass.
+ *
+ * This is a basic implementation that naively checks whether all the superclass methods have
+ * been overridden by the subclass. It is unlikely in practice that a delegating subclass needs to
+ * override all the methods in a superclass for postconditions to hold.
+ *
+ * @param tree a class tree
+ */
+ private void checkSuperClassOverrides(ClassTree tree) {
+ TypeElement classTreeElt = TreeUtils.elementFromDeclaration(tree);
+ if (classTreeElt == null || classTreeElt.getSuperclass() == null) {
+ return;
+ }
+ DeclaredType superClassMirror = (DeclaredType) classTreeElt.getSuperclass();
+ if (superClassMirror == null || superClassMirror.getKind() == TypeKind.NONE) {
+ return;
+ }
+ Set