Special handling of explicit annotations on anonymous class instantiation (#343)

Author: d367wang

src/checkers/inference/InferenceAnnotatedTypeFactory.java

@@ -576,6 +576,19 @@ public Set<AnnotationMirror> getTypeDeclarationBounds(TypeMirror type) {
             return Collections.singleton(vAnno);
         }
 
+        // This is to handle the special case of anonymous classes when the super class (or interface)
+        // identifier is explicit annotated, e.g.
+        //      A a1 = new @OsUntrusted A() {};
+        // In such cases, the declaration bound of the anonymous class is the explicit annotation on
+        // the super class (or interface) identifier.
+        final List<? extends AnnotationMirror> annos = type.getAnnotationMirrors();
+        AnnotationMirror realAnno = qualHierarchy.findAnnotationInHierarchy(annos, realTop);
+        if (realAnno != null) {
+            Slot slot = slotManager.getSlot(realAnno);
+            vAnno = slotManager.getAnnotation(slot);
+            return Collections.singleton(vAnno);
+        }
+
         // If the declaration bound of the underlying type is not cached, use default
         return (Set<AnnotationMirror>) getDefaultTypeDeclarationBounds();
     }
@@ -592,5 +605,6 @@ public Set<AnnotationMirror> getTypeDeclarationBounds(TypeMirror type) {
     public AnnotatedTypeMirror getTypeOfExtendsImplements(Tree clause) {
         return getAnnotatedTypeFromTypeTree(clause);
     }
+
 }
 

src/checkers/inference/InferenceTreeAnnotator.java

@@ -3,6 +3,7 @@
 import checkers.inference.model.ConstraintManager;
 import checkers.inference.model.SourceVariableSlot;
 import checkers.inference.model.Slot;
+
 import org.checkerframework.framework.type.AnnotatedTypeFactory;
 import org.checkerframework.framework.type.AnnotatedTypeFactory.ParameterizedExecutableType;
 import org.checkerframework.framework.type.AnnotatedTypeMirror;
@@ -23,6 +24,7 @@
 import javax.lang.model.type.TypeKind;
 
 import com.sun.source.tree.AnnotatedTypeTree;
+import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.AssignmentTree;
 import com.sun.source.tree.BinaryTree;
 import com.sun.source.tree.ClassTree;
@@ -182,16 +184,28 @@ public Void visitIdentifier(IdentifierTree node, AnnotatedTypeMirror identifierT
 
                 } else if (parentNode.getKind() == Kind.NEW_CLASS
                         && ((NewClassTree) parentNode).getIdentifier() == node) {
-                    // This can happen at two locations in a NewClassTree:
-                    // (1) The type identifier of the NewClassTree, as `A` of `new A() {}`,
-                    // (2) The type identifier on the anonymous class's extends/implements clause.
-                    // Note that the identifiers trees described in the two cases above are identical
-                    // for one NewClassTree, i.e. they share the same slot
-                    // TODO: A NewClassTree should be handled in visitNewClass method exclusively 
+                    // This can happen in two cases related to NewClassTrees:
+                    // (1) The type identifier of non-anonymous class instantiations, without explict
+                    //     annotations, such as `A` of `new A()`;
+                    // (2) The type identifier of anonymous class instantiations, with or without
+                    //     explicit annotations.
+                    // TODO: A NewClassTree should be handled in visitNewClass method exclusively
                     // without messing around with the IdentifierTree or ClassTree, see issue:
                     // https://github.com/opprop/checker-framework-inference/issues/332
-                    variableAnnotator.visit(identifierType, node);
 
+                    NewClassTree newClassTree = (NewClassTree) parentNode;
+                    if (newClassTree.getClassBody() != null) {
+                        // For case 2, get the explicit annotation if any exists so that no variable slot
+                        // is created. Note the annotation cannot be retrieved from the identifier, but
+                        // from the modifier of the anonymous class body. e.g. for the following case
+                        //      new @HERE Class() {}
+                        // @HERE is on the modifier of the anonymous class body, instead of on the type identifier.
+                        List<? extends AnnotationTree> annos =
+                                newClassTree.getClassBody().getModifiers().getAnnotations();
+                        identifierType.addAnnotations(TreeUtils.annotationsFromTypeAnnotationTrees(annos));
+                        ((InferenceAnnotatedTypeFactory) atypeFactory).getConstantToVariableAnnotator().visit(identifierType);
+                    }
+                    variableAnnotator.visit(identifierType, node);
                 }
             }
         }

testdata/ostrusted-inferrable-test/Anonymous.java

@@ -0,0 +1,7 @@
+import ostrusted.qual.OsUntrusted;
+
+class Anonymous {
+    A a1 = new @OsUntrusted A() {};
+
+    class A {}
+}