1 /*

     2  * Copyright (c) 2011-2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @bug 7101822

    27  * @summary static import fails to resolve interfaces on nested enums via import statements

    28  */

    29 

    30 import com.sun.source.util.JavacTask;

    31 import java.net.URI;

    32 import java.util.Arrays;

    33 import javax.tools.Diagnostic;

    34 import javax.tools.JavaCompiler;

    35 import javax.tools.JavaFileObject;

    36 import javax.tools.SimpleJavaFileObject;

    37 import javax.tools.StandardJavaFileManager;

    38 import javax.tools.ToolProvider;

    39 

    40 public class TestLazyImportScope {

    41 

    42     static int checkCount = 0;

    43 

    44     enum ImportOrder {

    45         NORMAL("import a.C.D;\n" +

    46                "#I"),

    47         REVERSE("#I\n" +

    48                "import a.C.D;");

    49 

    50         String importLayout;

    51 

    52         ImportOrder(String importLayout) {

    53             this.importLayout = importLayout;

    54         }

    55 

    56         String getImportString(ImportKind ik) {

    57             return importLayout.replaceAll("#I", ik.importStr);

    58         }

    59     }

    60 

    61     enum ImportKind {

    62         NAMED("import a.A.B.E;"),

    63         ON_DEMAND("import a.A.B.*;"),

    64         STATIC_NAMED_TYPE("import static a.A.B.E;"),

    65         STATIC_NAMED_MEMBER("import static a.A.B.bm;"),

    66         STATIC_ON_DEMAND("import static a.A.B.*;");

    67 

    68         String importStr;

    69 

    70         private ImportKind(String importStr) {

    71             this.importStr = importStr;

    72         }

    73     }

    74 

    75     enum TypeRefKind {

    76         NONE(""),

    77         E("E e = null;"),

    78         F("F f = null;"),

    79         BOTH("E e = null; F f = null;");

    80 

    81         String typeRefStr;

    82 

    83         private TypeRefKind(String typeRefStr) {

    84             this.typeRefStr = typeRefStr;

    85         }

    86 

    87         boolean isImported(ImportKind ik) {

    88             switch (ik) {

    89                 case NAMED:

    90                 case STATIC_NAMED_TYPE: return this == NONE || this == E;

    91                 case ON_DEMAND:

    92                 case STATIC_ON_DEMAND: return true;

    93                 default: return this == NONE;

    94             }

    95         }

    96     }

    97 

    98     enum MemberRefKind {

    99         NONE(""),

   100         FIELD("Object o = bf;"),

   101         METHOD("bm();"),

   102         BOTH("Object o = bf; bm();");

   103 

   104         String memberRefStr;

   105 

   106         private MemberRefKind(String memberRefStr) {

   107             this.memberRefStr = memberRefStr;

   108         }

   109 

   110         boolean isImported(ImportKind ik) {

   111             switch (ik) {

   112                 case STATIC_NAMED_MEMBER: return this == NONE || this == METHOD;

   113                 case STATIC_ON_DEMAND: return true;

   114                 default: return this == NONE;

   115             }

   116         }

   117     }

   118 

   119     public static void main(String... args) throws Exception {

   120 

   121         //create default shared JavaCompiler - reused across multiple compilations

   122         JavaCompiler comp = ToolProvider.getSystemJavaCompiler();

   123         StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);

   124 

   125         for (ImportOrder ord : ImportOrder.values()) {

   126             for (ImportKind ik : ImportKind.values()) {

   127                 for (TypeRefKind tk : TypeRefKind.values()) {

   128                     for (MemberRefKind mk : MemberRefKind.values()) {

   129                         new TestLazyImportScope(ord, ik, tk, mk).run(comp, fm);

   130                     }

   131                 }

   132             }

   133         }

   134         System.out.println("Total check executed: " + checkCount);

   135     }

   136 

   137     ImportOrder ord;

   138     ImportKind ik;

   139     TypeRefKind tk;

   140     MemberRefKind mk;

   141     JavaSource source;

   142     DiagnosticChecker diagChecker;

   143 

   144     TestLazyImportScope(ImportOrder ord, ImportKind ik, TypeRefKind tk, MemberRefKind mk) {

   145         this.ord = ord;

   146         this.ik = ik;

   147         this.tk = tk;

   148         this.mk = mk;

   149         this.source = new JavaSource();

   150         this.diagChecker = new DiagnosticChecker();

   151     }

   152 

   153     class JavaSource extends SimpleJavaFileObject {

   154 

   155         String bodyTemplate = "package a;\n" +

   156                               "#I\n" +

   157                               "class A {\n" +

   158                               "   static class B extends D {\n" +

   159                               "      static class E { }\n" +

   160                               "      static class F { }\n" +

   161                               "      static Object bf;\n" +

   162                               "      static void bm() { }\n" +

   163                               "   }\n" +

   164                               "}\n" +

   165                               "class C {\n" +

   166                               "   static class D { }\n" +

   167                               "}\n" +

   168                               "class Test {\n" +

   169                               "   void test() {\n" +

   170                               "      #T\n" +

   171                               "      #M\n" +

   172                               "   }\n" +

   173                               "}";

   174 

   175         String source;

   176 

   177         public JavaSource() {

   178             super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);

   179             source = bodyTemplate.replaceAll("#I", ord.getImportString(ik))

   180                     .replaceAll("#T", tk.typeRefStr)

   181                     .replaceAll("#M", mk.memberRefStr);

   182         }

   183 

   184         @Override

   185         public CharSequence getCharContent(boolean ignoreEncodingErrors) {

   186             return source;

   187         }

   188     }

   189 

   190     void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {

   191         JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,

   192                 null, null, Arrays.asList(source));

   193         try {

   194             ct.analyze();

   195         } catch (Throwable ex) {

   196             throw new AssertionError("Error thrown when compiling the following code:\n" + source.getCharContent(true));

   197         }

   198         check();

   199     }

   200 

   201     void check() {

   202         checkCount++;

   203 

   204         boolean errorExpected = !tk.isImported(ik) || !mk.isImported(ik);

   205 

   206         if (errorExpected != diagChecker.errorFound) {

   207             throw new Error("invalid diagnostics for source:\n" +

   208                 source.getCharContent(true) +

   209                 "\nFound error: " + diagChecker.errorFound +

   210                 "\nExpected error: " + errorExpected);

   211         }

   212     }

   213 

   214     static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {

   215 

   216         boolean errorFound;

   217 

   218         public void report(Diagnostic<? extends JavaFileObject> diagnostic) {

   219             if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {

   220                 errorFound = true;

   221             }

   222         }

   223     }

   224 }