8073372: Redundant CONSTANT_Class entry not generated for inlined constant

Reviewed-by: jjg

src/share/classes/com/sun/tools/javac/jvm/Gen.java

@@ -514,6 +514,10 @@ public class Gen extends JCTree.Visitor {
                         clinitTAs.addAll(getAndRemoveNonFieldTAs(sym));
                     } else {
                         checkStringConstant(vdef.init.pos(), sym.getConstValue());
+                        /* if the init contains a reference to an external class, add it to the
+                         * constant's pool
+                         */
+                        vdef.init.accept(classReferenceVisitor);
                     }
                 }
                 break;
@@ -2431,9 +2435,12 @@ public class Gen extends JCTree.Visitor {
                 && !allowGenerics // no Miranda methods available with generics
                 )
                 implementInterfaceMethods(c);
-            cdef.defs = normalizeDefs(cdef.defs, c);
             c.pool = pool;
             pool.reset();
+            /* method normalizeDefs() can add references to external classes into the constant pool
+             * so it should be called after pool.reset()
+             */
+            cdef.defs = normalizeDefs(cdef.defs, c);
             generateReferencesToPrunedTree(c, pool);
             Env<GenContext> localEnv =
                 new Env<GenContext>(cdef, new GenContext());

test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java

 /*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,9 +25,9 @@
 
 /*
  * @test
- * @bug 7153958
+ * @bug 7153958 8073372
  * @summary add constant pool reference to class containing inlined constants
- * @compile pkg/ClassToBeStaticallyImported.java CPoolRefClassContainingInlinedCts.java
+ * @compile pkg/ClassToBeStaticallyImportedA.java pkg/ClassToBeStaticallyImportedB.java CPoolRefClassContainingInlinedCts.java
  * @run main CPoolRefClassContainingInlinedCts
  */
 
@@ -38,7 +38,8 @@ import com.sun.tools.classfile.ConstantPoolException;
 import java.io.File;
 import java.io.IOException;
 
-import static pkg.ClassToBeStaticallyImported.staticField;
+import static pkg.ClassToBeStaticallyImportedA.staticFieldA;
+import static pkg.ClassToBeStaticallyImportedB.staticFieldB;
 
 public class CPoolRefClassContainingInlinedCts {
 
@@ -54,10 +55,14 @@ public class CPoolRefClassContainingInlinedCts {
 
     void checkClassName(String className) {
         switch (className) {
-            case "SimpleAssignClass" : case "BinaryExpClass":
-            case "UnaryExpClass" : case "CastClass":
-            case "ParensClass" : case "CondClass":
-            case "IfClass" : case "pkg/ClassToBeStaticallyImported":
+            case "SimpleAssignClassA" : case "BinaryExpClassA":
+            case "UnaryExpClassA" : case "CastClassA":
+            case "ParensClassA" : case "CondClassA":
+            case "IfClassA" : case "pkg/ClassToBeStaticallyImportedA":
+            case "SimpleAssignClassB" : case "BinaryExpClassB":
+            case "UnaryExpClassB" : case "CastClassB":
+            case "ParensClassB" : case "CondClassB":
+            case "IfClassB" : case "pkg/ClassToBeStaticallyImportedB":
                 numberOfReferencedClassesToBeChecked++;
         }
     }
@@ -76,59 +81,111 @@ public class CPoolRefClassContainingInlinedCts {
             }
             i += cpInfo.size();
         }
-        if (numberOfReferencedClassesToBeChecked != 8) {
+        if (numberOfReferencedClassesToBeChecked != 16) {
             throw new AssertionError("Class reference missing in the constant pool");
         }
     }
 
-    private int assign = SimpleAssignClass.x;
-    private int binary = BinaryExpClass.x + 1;
-    private int unary = -UnaryExpClass.x;
-    private int cast = (int)CastClass.x;
-    private int parens = (ParensClass.x);
-    private int cond = (CondClass.x == 1) ? 1 : 2;
-    private static int ifConstant;
-    private static int importStatic;
+    private int assignA = SimpleAssignClassA.x;
+    private int binaryA = BinaryExpClassA.x + 1;
+    private int unaryA = -UnaryExpClassA.x;
+    private int castA = (int)CastClassA.x;
+    private int parensA = (ParensClassA.x);
+    private int condA = (CondClassA.x == 1) ? 1 : 2;
+    private static int ifConstantA;
+    private static int importStaticA;
     static {
-        if (IfClass.x == 1) {
-            ifConstant = 1;
+        if (IfClassA.x == 1) {
+            ifConstantA = 1;
         } else {
-            ifConstant = 2;
+            ifConstantA = 2;
         }
     }
     static {
-        if (staticField == 1) {
-            importStatic = 1;
+        if (staticFieldA == 1) {
+            importStaticA = 1;
         } else {
-            importStatic = 2;
+            importStaticA = 2;
         }
     }
+
+    // now as final constants
+    private static final int assignB = SimpleAssignClassB.x;
+    private static final int binaryB = BinaryExpClassB.x + 1;
+    private static final int unaryB = -UnaryExpClassB.x;
+    private static final int castB = (int)CastClassB.x;
+    private static final int parensB = (ParensClassB.x);
+    private static final int condB = (CondClassB.x == 1) ? 1 : 2;
+    private static final int ifConstantB;
+    private static final int importStaticB;
+    static {
+        if (IfClassB.x == 1) {
+            ifConstantB = 1;
+        } else {
+            ifConstantB = 2;
+        }
+    }
+    static {
+        if (staticFieldB == 1) {
+            importStaticB = 1;
+        } else {
+            importStaticB = 2;
+        }
+    }
+}
+
+class SimpleAssignClassA {
+    public static final int x = 1;
+}
+
+class SimpleAssignClassB {
+    public static final int x = 1;
+}
+
+class BinaryExpClassA {
+    public static final int x = 1;
+}
+
+class BinaryExpClassB {
+    public static final int x = 1;
+}
+
+class UnaryExpClassA {
+    public static final int x = 1;
+}
+
+class UnaryExpClassB {
+    public static final int x = 1;
+}
+
+class CastClassA {
+    public static final int x = 1;
 }
 
-class SimpleAssignClass {
+class CastClassB {
     public static final int x = 1;
 }
 
-class BinaryExpClass {
+class ParensClassA {
     public static final int x = 1;
 }
 
-class UnaryExpClass {
+class ParensClassB {
     public static final int x = 1;
 }
 
-class CastClass {
+class CondClassA {
     public static final int x = 1;
 }
 
-class ParensClass {
+class CondClassB {
     public static final int x = 1;
 }
 
-class CondClass {
+class IfClassA {
     public static final int x = 1;
 }
 
-class IfClass {
+class IfClassB {
     public static final int x = 1;
 }

test/tools/javac/7153958/pkg/ClassToBeStaticallyImported.java → test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedA.java

 /*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,6 +24,6 @@
  */
 package pkg;
 
-public class ClassToBeStaticallyImported {
-    public static final int staticField = 1;
+public class ClassToBeStaticallyImportedA {
+    public static final int staticFieldA = 1;
 }

test/tools/javac/7153958/pkg/ClassToBeStaticallyImportedB.java

+/*
+ * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package pkg;
+
+public class ClassToBeStaticallyImportedB {
+    public static final int staticFieldB = 1;
+}