Fix Class literals default and add class literal node in CFG

checker/jtreg/nullness/EISOPissue548/ConservativeClassLiteral.java

@@ -0,0 +1,15 @@
+/*
+ * @test
+ * @summary Test class literals in CFGs and their type with conservative nullness.
+ *
+ * @compile MyEnum.java
+ * @compile -processor org.checkerframework.checker.nullness.NullnessChecker -AuseConservativeDefaultsForUncheckedCode=bytecode,-source ConservativeClassLiteral.java
+ */
+
+import java.util.EnumSet;
+
+class ConservativeClassLiteral {
+    EnumSet<MyEnum> none() {
+        return EnumSet.noneOf(MyEnum.class);
+    }
+}

checker/jtreg/nullness/EISOPissue548/MyEnum.java

@@ -0,0 +1,3 @@
+enum MyEnum {
+    VALUE;
+}

checker/src/main/java/org/checkerframework/checker/initialization/InitializationParentAnnotatedTypeFactory.java

@@ -793,7 +793,7 @@ public Void visitNewArray(NewArrayTree tree, AnnotatedTypeMirror type) {
         @Override
         public Void visitMemberSelect(
                 MemberSelectTree tree, AnnotatedTypeMirror annotatedTypeMirror) {
-            if (TreeUtils.isArrayLengthAccess(tree)) {
+            if (TreeUtils.isArrayLengthAccess(tree) || TreeUtils.isClassLiteral(tree)) {
                 annotatedTypeMirror.replaceAnnotation(INITIALIZED);
             }
             return super.visitMemberSelect(tree, annotatedTypeMirror);

checker/src/main/java/org/checkerframework/checker/nullness/NullnessNoInitAnnotatedTypeFactory.java

@@ -667,9 +667,10 @@ public Void visitMemberSelect(MemberSelectTree tree, AnnotatedTypeMirror type) {
             Element elt = TreeUtils.elementFromUse(tree);
             assert elt != null;
 
-            // Make primitive variable @NonNull in case the Initialization Checker
+            // Make primitive variable and class literal @NonNull in case the Initialization Checker
             // considers it uninitialized.
-            if (TypesUtils.isPrimitive(type.getUnderlyingType())) {
+            if (TypesUtils.isPrimitive(type.getUnderlyingType())
+                    || TreeUtils.isClassLiteral(tree)) {
                 type.replaceAnnotation(NONNULL);
             }
 

dataflow/src/main/java/org/checkerframework/dataflow/cfg/builder/CFGTranslationPhaseOne.java

@@ -77,6 +77,7 @@
 import org.checkerframework.dataflow.cfg.node.CatchMarkerNode;
 import org.checkerframework.dataflow.cfg.node.CharacterLiteralNode;
 import org.checkerframework.dataflow.cfg.node.ClassDeclarationNode;
+import org.checkerframework.dataflow.cfg.node.ClassLiteralNode;
 import org.checkerframework.dataflow.cfg.node.ClassNameNode;
 import org.checkerframework.dataflow.cfg.node.ConditionalAndNode;
 import org.checkerframework.dataflow.cfg.node.ConditionalNotNode;
@@ -3671,6 +3672,11 @@ public Node visitMemberSelect(MemberSelectTree tree, Void p) {
                 Node result = new PackageNameNode(tree, (PackageNameNode) expr);
                 extendWithNode(result);
                 return result;
+            } else if (element.getKind() == ElementKind.FIELD
+                    && element.toString().equals("class")) {
+                Node result = new ClassLiteralNode(tree, expr);
+                extendWithNode((ClassLiteralNode) result);
+                return result;
             } else {
                 throw new BugInCF("Unexpected element kind: " + element.getKind());
             }

dataflow/src/main/java/org/checkerframework/dataflow/cfg/node/AbstractNodeVisitor.java

@@ -358,6 +358,11 @@ public R visitPrimitiveType(PrimitiveTypeNode n, P p) {
         return visitNode(n, p);
     }
 
+    @Override
+    public R visitClassLiteral(ClassLiteralNode n, P p) {
+        return visitNode(n, p);
+    }
+
     @Override
     public R visitClassName(ClassNameNode n, P p) {
         return visitNode(n, p);

dataflow/src/main/java/org/checkerframework/dataflow/cfg/node/ClassLiteralNode.java

@@ -0,0 +1,60 @@
+package org.checkerframework.dataflow.cfg.node;
+
+import com.sun.source.tree.MemberSelectTree;
+import com.sun.source.tree.Tree;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.checkerframework.javacutil.TreeUtils;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/** A node for a class literal. For example: {@code String.class}. */
+public class ClassLiteralNode extends Node {
+    /** The tree for the class literal. */
+    protected final MemberSelectTree tree;
+
+    /** The class name of class literal */
+    protected final Node className;
+
+    /**
+     * Create a new ClassLiteralNode.
+     *
+     * @param tree the class literal
+     * @param className the class name for the class literal
+     */
+    public ClassLiteralNode(MemberSelectTree tree, Node className) {
+        super(TreeUtils.typeOf(tree));
+        this.tree = tree;
+        this.className = className;
+    }
+
+    @Override
+    public @Nullable Tree getTree() {
+        return tree;
+    }
+
+    /**
+     * Get the class name of the class literal.
+     *
+     * @return the class name of the class literal
+     */
+    public Node getClassName() {
+        return className;
+    }
+
+    @Override
+    public <R, P> R accept(NodeVisitor<R, P> visitor, P p) {
+        return visitor.visitClassLiteral(this, p);
+    }
+
+    @Override
+    public String toString() {
+        return tree.toString();
+    }
+
+    @Override
+    public Collection<Node> getOperands() {
+        return Collections.emptyList();
+    }
+}