| package org.checkerframework.checker.guieffect; |
| |
| import com.sun.source.tree.AssignmentTree; |
| import com.sun.source.tree.ClassTree; |
| import com.sun.source.tree.ExpressionTree; |
| import com.sun.source.tree.LambdaExpressionTree; |
| import com.sun.source.tree.MethodInvocationTree; |
| import com.sun.source.tree.MethodTree; |
| import com.sun.source.tree.NewClassTree; |
| import com.sun.source.tree.ReturnTree; |
| import com.sun.source.tree.Tree; |
| import com.sun.source.tree.VariableTree; |
| import com.sun.source.util.TreePath; |
| import java.util.ArrayDeque; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import javax.lang.model.element.AnnotationMirror; |
| import javax.lang.model.element.ExecutableElement; |
| import javax.lang.model.element.TypeElement; |
| import javax.lang.model.element.VariableElement; |
| import javax.lang.model.type.DeclaredType; |
| import org.checkerframework.checker.guieffect.qual.AlwaysSafe; |
| import org.checkerframework.checker.guieffect.qual.PolyUI; |
| import org.checkerframework.checker.guieffect.qual.PolyUIEffect; |
| import org.checkerframework.checker.guieffect.qual.PolyUIType; |
| import org.checkerframework.checker.guieffect.qual.SafeEffect; |
| import org.checkerframework.checker.guieffect.qual.UI; |
| import org.checkerframework.checker.guieffect.qual.UIEffect; |
| import org.checkerframework.common.basetype.BaseTypeChecker; |
| import org.checkerframework.common.basetype.BaseTypeVisitor; |
| import org.checkerframework.framework.type.AnnotatedTypeFactory.ParameterizedExecutableType; |
| import org.checkerframework.framework.type.AnnotatedTypeMirror; |
| import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType; |
| import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType; |
| import org.checkerframework.framework.util.AnnotatedTypes; |
| import org.checkerframework.javacutil.AnnotationBuilder; |
| import org.checkerframework.javacutil.ElementUtils; |
| import org.checkerframework.javacutil.Pair; |
| import org.checkerframework.javacutil.TreePathUtil; |
| import org.checkerframework.javacutil.TreeUtils; |
| import org.checkerframework.javacutil.TypesUtils; |
| |
| /** Require that only UI code invokes code with the UI effect. */ |
| public class GuiEffectVisitor extends BaseTypeVisitor<GuiEffectTypeFactory> { |
| |
| protected final boolean debugSpew; |
| |
| // effStack and currentMethods should always be the same size. |
| protected final ArrayDeque<Effect> effStack; |
| protected final ArrayDeque<MethodTree> currentMethods; |
| |
| public GuiEffectVisitor(BaseTypeChecker checker) { |
| super(checker); |
| debugSpew = checker.getLintOption("debugSpew", false); |
| if (debugSpew) { |
| System.err.println("Running GuiEffectVisitor"); |
| } |
| effStack = new ArrayDeque<>(); |
| currentMethods = new ArrayDeque<>(); |
| } |
| |
| @Override |
| protected GuiEffectTypeFactory createTypeFactory() { |
| return new GuiEffectTypeFactory(checker, debugSpew); |
| } |
| |
| // The issue is that the receiver implicitly receives an @AlwaysSafe anno, so calls on @UI |
| // references fail because the framework doesn't implicitly upcast the receiver (which in |
| // general wouldn't be sound). |
| // TODO: Fix method receiver defaults: method-polymorphic for any polymorphic method, UI |
| // for any UI instantiations, safe otherwise |
| @Override |
| protected void checkMethodInvocability( |
| AnnotatedExecutableType method, MethodInvocationTree node) { |
| // The inherited version of this complains about invoking methods of @UI instantiations of |
| // classes, which by default are annotated @AlwaysSafe, which for data type qualifiers is |
| // reasonable, but it not what we want, since we want . |
| // TODO: Undo this hack! |
| } |
| |
| protected class GuiEffectOverrideChecker extends OverrideChecker { |
| /** |
| * Extend the receiver part of the method override check. We extend the standard check, to |
| * additionally permit narrowing the receiver's permission to {@code @AlwaysSafe} in a safe |
| * instantiation of a {@code @PolyUIType}. Returns true if the override is permitted. |
| */ |
| @Override |
| protected boolean checkReceiverOverride() { |
| // We cannot reuse the inherited method because it directly issues the failure, but we |
| // want a more permissive check. So this is copied down and modified from |
| // BaseTypeVisitor.OverrideChecker.checkReceiverOverride. |
| // isSubtype() requires its arguments to be actual subtypes with |
| // respect to JLS, but the overrider receiver is not a subtype of the |
| // overridden receiver. Hence copying the annotations. |
| // TODO: Does this need to be improved for generic receivers? I.e., do we need to |
| // add extra checking to reject the case of also changing qualifiers in type parameters? |
| // Such as overriding a {@code @PolyUI C<@UI T>} by {@code @AlwaysSafe C<@AlwaysSafe |
| // T>}? The change to the receiver permission is acceptable, while the change to the |
| // parameter should be rejected. |
| AnnotatedTypeMirror overriddenReceiver = |
| overrider.getReceiverType().getErased().shallowCopy(false); |
| overriddenReceiver.addAnnotations(overridden.getReceiverType().getAnnotations()); |
| if (!atypeFactory |
| .getTypeHierarchy() |
| .isSubtype(overriddenReceiver, overrider.getReceiverType().getErased())) { |
| // This is the point at which the default check would issue an error. |
| // We additionally permit overrides to move from @PolyUI receivers to @AlwaysSafe |
| // receivers, if it's in a @AlwaysSafe specialization of a @PolyUIType |
| boolean safeParent = overriddenType.getAnnotation(AlwaysSafe.class) != null; |
| boolean polyParentDecl = |
| atypeFactory.getDeclAnnotation( |
| overriddenType.getUnderlyingType().asElement(), PolyUIType.class) |
| != null; |
| // TODO: How much validation do I need here? Do I need to check that the overridden |
| // receiver was really @PolyUI and the method is really an @PolyUIEffect? I don't think so |
| // - we know it's a polymorphic parent type, so all receivers would be @PolyUI. |
| // Java would already reject before running type annotation processors if the Java |
| // types were wrong. |
| // The *only* extra leeway we want to permit is overriding @PolyUI receiver to |
| // @AlwaysSafe. But with generics, the tentative check below is inadequate. |
| boolean safeReceiverOverride = |
| overrider.getReceiverType().getAnnotation(AlwaysSafe.class) != null; |
| if (safeParent && polyParentDecl && safeReceiverOverride) { |
| return true; |
| } |
| checker.reportError( |
| overriderTree, |
| "override.receiver", |
| overrider.getReceiverType(), |
| overridden.getReceiverType(), |
| overriderType, |
| overrider, |
| overriddenType, |
| overridden); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Create a GuiEffectOverrideChecker. |
| * |
| * @param overriderTree the AST node of the overriding method or method reference |
| * @param overrider the type of the overriding method |
| * @param overridingType the type enclosing the overrider method, usually an |
| * AnnotatedDeclaredType; for Method References may be something else |
| * @param overridingReturnType the return type of the overriding method |
| * @param overridden the type of the overridden method |
| * @param overriddenType the declared type enclosing the overridden method |
| * @param overriddenReturnType the return type of the overridden method |
| */ |
| public GuiEffectOverrideChecker( |
| Tree overriderTree, |
| AnnotatedExecutableType overrider, |
| AnnotatedTypeMirror overridingType, |
| AnnotatedTypeMirror overridingReturnType, |
| AnnotatedExecutableType overridden, |
| AnnotatedDeclaredType overriddenType, |
| AnnotatedTypeMirror overriddenReturnType) { |
| super( |
| overriderTree, |
| overrider, |
| overridingType, |
| overridingReturnType, |
| overridden, |
| overriddenType, |
| overriddenReturnType); |
| } |
| } |
| |
| @Override |
| protected OverrideChecker createOverrideChecker( |
| Tree overriderTree, |
| AnnotatedExecutableType overrider, |
| AnnotatedTypeMirror overridingType, |
| AnnotatedTypeMirror overridingReturnType, |
| AnnotatedExecutableType overridden, |
| AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType, |
| AnnotatedTypeMirror overriddenReturnType) { |
| return new GuiEffectOverrideChecker( |
| overriderTree, |
| overrider, |
| overridingType, |
| overridingReturnType, |
| overridden, |
| overriddenType, |
| overriddenReturnType); |
| } |
| |
| @Override |
| protected Set<? extends AnnotationMirror> getExceptionParameterLowerBoundAnnotations() { |
| return Collections.singleton(AnnotationBuilder.fromClass(elements, AlwaysSafe.class)); |
| } |
| |
| @Override |
| public boolean isValidUse( |
| AnnotatedTypeMirror.AnnotatedDeclaredType declarationType, |
| AnnotatedTypeMirror.AnnotatedDeclaredType useType, |
| Tree tree) { |
| boolean ret = |
| useType.hasAnnotation(AlwaysSafe.class) |
| || useType.hasAnnotation(PolyUI.class) |
| || atypeFactory.isPolymorphicType( |
| (TypeElement) declarationType.getUnderlyingType().asElement()) |
| || (useType.hasAnnotation(UI.class) && declarationType.hasAnnotation(UI.class)); |
| if (debugSpew && !ret) { |
| System.err.println("use: " + useType); |
| System.err.println("use safe: " + useType.hasAnnotation(AlwaysSafe.class)); |
| System.err.println("use poly: " + useType.hasAnnotation(PolyUI.class)); |
| System.err.println("use ui: " + useType.hasAnnotation(UI.class)); |
| System.err.println("declaration safe: " + declarationType.hasAnnotation(AlwaysSafe.class)); |
| System.err.println( |
| "declaration poly: " |
| + atypeFactory.isPolymorphicType( |
| (TypeElement) declarationType.getUnderlyingType().asElement())); |
| System.err.println("declaration ui: " + declarationType.hasAnnotation(UI.class)); |
| System.err.println("declaration: " + declarationType); |
| } |
| return ret; |
| } |
| |
| @Override |
| @SuppressWarnings("interning:not.interned") // comparing AST nodes |
| public Void visitLambdaExpression(LambdaExpressionTree node, Void p) { |
| Void v = super.visitLambdaExpression(node, p); |
| // If this is a lambda inferred to be @UI, scan up the path and re-check any assignments |
| // involving it. |
| if (atypeFactory.isDirectlyMarkedUIThroughInference(node)) { |
| // Backtrack path to the lambda expression itself |
| TreePath path = visitorState.getPath(); |
| while (path.getLeaf() != node) { |
| assert path.getLeaf().getKind() != Tree.Kind.COMPILATION_UNIT; |
| path = path.getParentPath(); |
| } |
| scanUp(path); |
| } |
| return v; |
| } |
| |
| @Override |
| protected void checkExtendsImplements(ClassTree classTree) { |
| // Skip this check |
| } |
| |
| @Override |
| protected void checkConstructorResult( |
| AnnotatedExecutableType constructorType, ExecutableElement constructorElement) { |
| // Skip this check. |
| } |
| |
| @Override |
| protected void checkForPolymorphicQualifiers(ClassTree classTree) { |
| // Polymorphic qualifiers are legal on classes, so skip this check. |
| } |
| |
| // Check that the invoked effect is <= permitted effect (effStack.peek()) |
| @Override |
| public Void visitMethodInvocation(MethodInvocationTree node, Void p) { |
| if (debugSpew) { |
| System.err.println("For invocation " + node + " in " + currentMethods.peek().getName()); |
| } |
| |
| // Target method annotations |
| ExecutableElement methodElt = TreeUtils.elementFromUse(node); |
| if (debugSpew) { |
| System.err.println("methodElt found"); |
| } |
| |
| Tree callerTree = TreePathUtil.enclosingMethodOrLambda(getCurrentPath()); |
| if (callerTree == null) { |
| // Static initializer; let's assume this is safe to have the UI effect |
| if (debugSpew) { |
| System.err.println("No enclosing method: likely static initializer"); |
| } |
| return super.visitMethodInvocation(node, p); |
| } |
| if (debugSpew) { |
| System.err.println("callerTree found: " + callerTree.getKind()); |
| } |
| |
| Effect targetEffect = |
| atypeFactory.getComputedEffectAtCallsite(node, visitorState.getMethodReceiver(), methodElt); |
| |
| Effect callerEffect = null; |
| if (callerTree.getKind() == Tree.Kind.METHOD) { |
| ExecutableElement callerElt = TreeUtils.elementFromDeclaration((MethodTree) callerTree); |
| if (debugSpew) { |
| System.err.println("callerElt found"); |
| } |
| |
| callerEffect = atypeFactory.getDeclaredEffect(callerElt); |
| final DeclaredType callerReceiverType = this.visitorState.getClassType().getUnderlyingType(); |
| assert callerReceiverType != null; |
| final TypeElement callerReceiverElt = (TypeElement) callerReceiverType.asElement(); |
| // Note: All these checks should be fast in the common case, but happen for every method call |
| // inside the anonymous class. Consider a cache here if profiling surfaces this as taking too |
| // long. |
| if (TypesUtils.isAnonymous(callerReceiverType) |
| // Skip if already inferred @UI |
| && !effStack.peek().isUI() |
| // Ignore if explicitly annotated |
| && !atypeFactory.fromElement(callerReceiverElt).hasAnnotation(AlwaysSafe.class) |
| && !atypeFactory.fromElement(callerReceiverElt).hasAnnotation(UI.class)) { |
| boolean overridesPolymorphic = false; |
| Map<AnnotatedTypeMirror.AnnotatedDeclaredType, ExecutableElement> overriddenMethods = |
| AnnotatedTypes.overriddenMethods(elements, atypeFactory, callerElt); |
| for (Map.Entry<AnnotatedTypeMirror.AnnotatedDeclaredType, ExecutableElement> pair : |
| overriddenMethods.entrySet()) { |
| AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType = pair.getKey(); |
| AnnotatedExecutableType overriddenMethod = |
| AnnotatedTypes.asMemberOf(types, atypeFactory, overriddenType, pair.getValue()); |
| if (atypeFactory.getDeclAnnotation(overriddenMethod.getElement(), PolyUIEffect.class) |
| != null |
| && atypeFactory.getDeclAnnotation( |
| overriddenType.getUnderlyingType().asElement(), PolyUIType.class) |
| != null) { |
| overridesPolymorphic = true; |
| break; |
| } |
| } |
| // Perform anonymous class polymorphic effect inference: |
| // method overrides @PolyUIEffect method of @PolyUIClass class, calls @UIEffect => |
| // @UI anon class |
| if (overridesPolymorphic && targetEffect.isUI()) { |
| // Mark the anonymous class as @UI |
| atypeFactory.constrainAnonymousClassToUI(callerReceiverElt); |
| // Then re-calculate this method's effect (it might still not be an |
| // @PolyUIEffect method). |
| callerEffect = atypeFactory.getDeclaredEffect(callerElt); |
| effStack.pop(); |
| effStack.push(callerEffect); |
| } |
| } |
| |
| // Field initializers inside anonymous inner classes show up with a null current-method |
| // --- the traversal goes straight from the class to the initializer. |
| assert (currentMethods.peek() == null || callerEffect.equals(effStack.peek())); |
| } else if (callerTree.getKind() == Tree.Kind.LAMBDA_EXPRESSION) { |
| callerEffect = |
| atypeFactory.getInferedEffectForLambdaExpression((LambdaExpressionTree) callerTree); |
| // Perform lambda polymorphic effect inference: @PolyUI lambda, calling @UIEffect => @UI |
| // lambda |
| if (targetEffect.isUI() && callerEffect.isPoly()) { |
| atypeFactory.constrainLambdaToUI((LambdaExpressionTree) callerTree); |
| callerEffect = new Effect(UIEffect.class); |
| } |
| } |
| assert callerEffect != null; |
| |
| if (!Effect.lessThanOrEqualTo(targetEffect, callerEffect)) { |
| checker.reportError(node, "call.ui", targetEffect, callerEffect); |
| if (debugSpew) { |
| System.err.println("Issuing error for node: " + node); |
| } |
| } |
| if (debugSpew) { |
| System.err.println("Successfully finished main non-recursive checkinv of invocation " + node); |
| } |
| return super.visitMethodInvocation(node, p); |
| } |
| |
| @Override |
| public Void visitMethod(MethodTree node, Void p) { |
| // TODO: If the type we're in is a polymorphic (over effect qualifiers) type, the receiver must |
| // be @PolyUI. Otherwise a "non-polymorphic" method of a polymorphic type could be called on a |
| // UI instance, which then gets a Safe reference to itself (unsound!) that it can then pass off |
| // elsewhere (dangerous!). So all receivers in methods of a @PolyUIType must be @PolyUI. |
| |
| // TODO: What do we do then about classes that inherit from a concrete instantiation? If it |
| // subclasses a Safe instantiation, all is well. If it subclasses a UI instantiation, then the |
| // receivers should probably be @UI in both new and override methods, so calls to polymorphic |
| // methods of the parent class will work correctly. In which case for proving anything, the |
| // qualifier on sublasses of UI instantiations would always have to be @UI... Need to write down |
| // |- t for this system! And the judgments for method overrides and inheritance! Those are |
| // actually the hardest part of the system. |
| |
| ExecutableElement methElt = TreeUtils.elementFromDeclaration(node); |
| if (debugSpew) { |
| System.err.println("Visiting method " + methElt + " of " + methElt.getEnclosingElement()); |
| } |
| |
| // Check for conflicting (multiple) annotations |
| assert (methElt != null); |
| // TypeMirror scratch = methElt.getReturnType(); |
| AnnotationMirror targetUIP = atypeFactory.getDeclAnnotation(methElt, UIEffect.class); |
| AnnotationMirror targetSafeP = atypeFactory.getDeclAnnotation(methElt, SafeEffect.class); |
| AnnotationMirror targetPolyP = atypeFactory.getDeclAnnotation(methElt, PolyUIEffect.class); |
| TypeElement targetClassElt = (TypeElement) methElt.getEnclosingElement(); |
| |
| if ((targetUIP != null && (targetSafeP != null || targetPolyP != null)) |
| || (targetSafeP != null && targetPolyP != null)) { |
| checker.reportError(node, "annotations.conflicts"); |
| } |
| if (targetPolyP != null && !atypeFactory.isPolymorphicType(targetClassElt)) { |
| checker.reportError(node, "polymorphism"); |
| } |
| if (targetUIP != null && atypeFactory.isUIType(targetClassElt)) { |
| checker.reportWarning(node, "effects.redundant.uitype"); |
| } |
| |
| // TODO: Report an error for polymorphic method bodies??? Until we fix the receiver |
| // defaults, it won't really be correct |
| @SuppressWarnings("unused") // call has side effects |
| Effect.EffectRange range = |
| atypeFactory.findInheritedEffectRange( |
| ((TypeElement) methElt.getEnclosingElement()), methElt, true, node); |
| // if (targetUIP == null && targetSafeP == null && targetPolyP == null) { |
| // implicitly annotate this method with the LUB of the effects of the methods it overrides |
| // atypeFactory.fromElement(methElt).addAnnotation(range != null ? range.min.getAnnot() |
| // : (isUIType(((TypeElement)methElt.getEnclosingElement())) ? UI.class : |
| // AlwaysSafe.class)); |
| // TODO: This line does nothing! AnnotatedTypeMirror.addAnnotation |
| // silently ignores non-qualifier annotations! |
| // System.err.println("ERROR: TREE ANNOTATOR SHOULD HAVE ADDED EXPLICIT ANNOTATION! (" |
| // +node.getName()+")"); |
| // atypeFactory |
| // .fromElement(methElt) |
| // .addAnnotation(atypeFactory.getDeclaredEffect(methElt).getAnnot()); |
| // } |
| |
| // We hang onto the current method here for ease. We back up the old |
| // current method because this code is reentrant when we traverse methods of an inner class |
| currentMethods.addFirst(node); |
| // effStack.push(targetSafeP != null ? new Effect(AlwaysSafe.class) : |
| // (targetPolyP != null ? new Effect(PolyUI.class) : |
| // (targetUIP != null ? new Effect(UI.class) : |
| // (range != null ? range.min : |
| // (isUIType(((TypeElement)methElt.getEnclosingElement())) ? new Effect(UI.class) : new |
| // Effect(AlwaysSafe.class)))))); |
| effStack.addFirst(atypeFactory.getDeclaredEffect(methElt)); |
| if (debugSpew) { |
| System.err.println("Pushing " + effStack.peek() + " onto the stack when checking " + methElt); |
| } |
| |
| Void ret = super.visitMethod(node, p); |
| currentMethods.removeFirst(); |
| effStack.removeFirst(); |
| return ret; |
| } |
| |
| @Override |
| @SuppressWarnings("interning:not.interned") // comparing AST nodes |
| public Void visitNewClass(NewClassTree node, Void p) { |
| Void v = super.visitNewClass(node, p); |
| // If this is an anonymous inner class inferred to be @UI, scan up the path and re-check any |
| // assignments involving it. |
| if (atypeFactory.isDirectlyMarkedUIThroughInference(node)) { |
| // Backtrack path to the new class expression itself |
| TreePath path = visitorState.getPath(); |
| while (path.getLeaf() != node) { |
| assert path.getLeaf().getKind() != Tree.Kind.COMPILATION_UNIT; |
| path = path.getParentPath(); |
| } |
| scanUp(visitorState.getPath().getParentPath()); |
| } |
| return v; |
| } |
| |
| /** |
| * This method is called to traverse the path back up from any anonymous inner class or lambda |
| * which has been inferred to be UI affecting and re-run {@code commonAssignmentCheck} as needed |
| * on places where the class declaration or lambda expression are being assigned to a variable, |
| * passed as a parameter or returned from a method. This is necessary because the normal visitor |
| * traversal only checks assignments on the way down the AST, before inference has had a chance to |
| * run. |
| * |
| * @param path the path to traverse up from a UI-affecting class |
| */ |
| private void scanUp(TreePath path) { |
| Tree tree = path.getLeaf(); |
| switch (tree.getKind()) { |
| case ASSIGNMENT: |
| AssignmentTree assignmentTree = (AssignmentTree) tree; |
| commonAssignmentCheck( |
| atypeFactory.getAnnotatedType(assignmentTree.getVariable()), |
| atypeFactory.getAnnotatedType(assignmentTree.getExpression()), |
| assignmentTree.getExpression(), |
| "assignment"); |
| break; |
| case VARIABLE: |
| VariableTree variableTree = (VariableTree) tree; |
| commonAssignmentCheck( |
| atypeFactory.getAnnotatedType(variableTree), |
| atypeFactory.getAnnotatedType(variableTree.getInitializer()), |
| variableTree.getInitializer(), |
| "assignment"); |
| break; |
| case METHOD_INVOCATION: |
| MethodInvocationTree invocationTree = (MethodInvocationTree) tree; |
| List<? extends ExpressionTree> args = invocationTree.getArguments(); |
| ParameterizedExecutableType mType = atypeFactory.methodFromUse(invocationTree); |
| AnnotatedExecutableType invokedMethod = mType.executableType; |
| ExecutableElement method = invokedMethod.getElement(); |
| CharSequence methodName = ElementUtils.getSimpleNameOrDescription(method); |
| List<? extends VariableElement> methodParams = method.getParameters(); |
| List<AnnotatedTypeMirror> argsTypes = |
| AnnotatedTypes.expandVarArgs( |
| atypeFactory, invokedMethod, invocationTree.getArguments()); |
| for (int i = 0; i < args.size(); ++i) { |
| if (args.get(i).getKind() == Tree.Kind.NEW_CLASS |
| || args.get(i).getKind() == Tree.Kind.LAMBDA_EXPRESSION) { |
| commonAssignmentCheck( |
| argsTypes.get(i), |
| atypeFactory.getAnnotatedType(args.get(i)), |
| args.get(i), |
| "argument", |
| methodParams.get(i), |
| methodName); |
| } |
| } |
| break; |
| case RETURN: |
| ReturnTree returnTree = (ReturnTree) tree; |
| if (returnTree.getExpression().getKind() == Tree.Kind.NEW_CLASS |
| || returnTree.getExpression().getKind() == Tree.Kind.LAMBDA_EXPRESSION) { |
| Tree enclosing = TreePathUtil.enclosingMethodOrLambda(path); |
| AnnotatedTypeMirror ret = null; |
| if (enclosing.getKind() == Tree.Kind.METHOD) { |
| MethodTree enclosingMethod = (MethodTree) enclosing; |
| boolean valid = validateTypeOf(enclosing); |
| if (valid) { |
| ret = atypeFactory.getMethodReturnType(enclosingMethod, returnTree); |
| } |
| } else { |
| ret = |
| atypeFactory |
| .getFunctionTypeFromTree((LambdaExpressionTree) enclosing) |
| .getReturnType(); |
| } |
| |
| if (ret != null) { |
| Pair<Tree, AnnotatedTypeMirror> preAssignmentContext = |
| visitorState.getAssignmentContext(); |
| try { |
| visitorState.setAssignmentContext(Pair.of((Tree) returnTree, ret)); |
| commonAssignmentCheck( |
| ret, |
| atypeFactory.getAnnotatedType(returnTree.getExpression()), |
| returnTree.getExpression(), |
| "return"); |
| } finally { |
| visitorState.setAssignmentContext(preAssignmentContext); |
| } |
| } |
| } |
| break; |
| case METHOD: |
| // Stop scanning at method boundaries, since the expression can't escape the method |
| // without either being assigned to a field or returned. |
| return; |
| case CLASS: |
| // Can't ever happen, because we stop scanning at either method or field initializer |
| // boundaries |
| assert false; |
| return; |
| default: |
| scanUp(path.getParentPath()); |
| } |
| } |
| |
| // @Override |
| // public Void visitMemberSelect(MemberSelectTree node, Void p) { |
| // TODO: Same effect checks as for methods |
| // return super.visitMemberSelect(node, p); |
| // } |
| |
| // @Override |
| // public void processClassTree(ClassTree node) { |
| // TODO: Check constraints on this class decl vs. parent class decl., and interfaces |
| // TODO: This has to wait for now: maybe this will be easier with the isValidUse on the |
| // TypeFactory. |
| // AnnotatedTypeMirror.AnnotatedDeclaredType atype = atypeFactory.fromClass(node); |
| |
| // Push a null method and UI effect onto the stack for static field initialization |
| // TODO: Figure out if this is safe! For static data, almost certainly, |
| // but for statically initialized instance fields, I'm assuming those |
| // are implicitly moved into each constructor, which must then be @UI. |
| // currentMethods.addFirst(null); |
| // effStack.addFirst(new Effect(UIEffect.class)); |
| // super.processClassTree(node); |
| // currentMethods.removeFirst(); |
| // effStack.removeFirst(); |
| // } |
| } |
