Mercurial > jdk8-mips64-public > langtools / file revision

 /*

  * Copyright (c) 2013, 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.

  *

  * 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.

  */

 /*

  * @test

  * @bug 8010737

  * @summary javac, known parameter's names should be copied to automatically

  * generated constructors for inner classes

  * @run main ParameterNamesAreNotCopiedToAnonymousInitTest check_class_file check_init_symbol

  */

 import java.io.File;

 import java.io.IOException;

 import java.lang.annotation.ElementType;

 import java.lang.annotation.Target;

 import java.nio.file.Paths;

 import java.util.Arrays;

 import javax.tools.JavaCompiler;

 import javax.tools.JavaFileObject;

 import javax.tools.StandardJavaFileManager;

 import javax.tools.ToolProvider;

 import com.sun.source.tree.CompilationUnitTree;

 import com.sun.source.tree.Tree;

 import com.sun.source.util.JavacTask;

 import com.sun.source.util.TaskEvent;

 import com.sun.source.util.TaskListener;

 import com.sun.tools.classfile.ClassFile;

 import com.sun.tools.classfile.Method;

 import com.sun.tools.javac.api.BasicJavacTask;

 import com.sun.tools.javac.code.Attribute.Compound;

 import com.sun.tools.javac.code.Symbol.ClassSymbol;

 import com.sun.tools.javac.code.Symbol.VarSymbol;

 import com.sun.tools.javac.tree.JCTree;

 import com.sun.tools.javac.tree.TreeScanner;

 import com.sun.tools.javac.util.Assert;

 import com.sun.tools.javac.util.Context;

 import com.sun.tools.javac.util.List;

 import com.sun.tools.javac.util.Names;

 public class ParameterNamesAreNotCopiedToAnonymousInitTest {

     static final String noParamsErrorMsg =

             "Test most be invoked with at least one parameter: check_class_file " +

             "and/or check_init_symbol";

     static final String wrongParamsErrorMsg =

             "Accepted arguments are: check_class_file and check_init_symbol";

     static final String paramNameNotCopiedAssertionMsg =

             "The param name hasn't been copied to the init method";

     static final String noAnnotationsForParameterMsg =

             "No annotations for seek parameter";

     static final String seekMethodNotFound =

             "The seek init method was not found or conditions were not met";

     static final String nonNullParamPositionsMsg =

             "Parameter positions shold not be null";

     static final String compilationFailed =

             "Compilation failed";

     static final String seekMethodNotFoundMsg =

         "The seek method was not found";

     static final String ParamAnnotationClassName =

             ParameterNamesAreNotCopiedToAnonymousInitTest.class.getSimpleName() + "." +

             ParamAnnotation.class.getSimpleName();

     public static void main(String[] args) throws Exception {

         if (args.length == 0) {

             throw new Error(noParamsErrorMsg);

         }

         new ParameterNamesAreNotCopiedToAnonymousInitTest().run(args);

     }

     void run(String[] args) throws Exception {

         for (String arg : args) {

             if (arg.equals("check_class_file")) {

                 checkClassFile(new File(Paths.get(System.getProperty("test.classes"),

                         this.getClass().getName() + "$initParams$1.class").toUri()), 1);

                 checkClassFile(new File(Paths.get(System.getProperty("test.classes"),

                         this.getClass().getName() + "$Generics$1.class").toUri()), 2);

             } else if (arg.equals("check_init_symbol")) {

                 checkInitSymbol("m1", Arrays.asList(0), Arrays.asList("i"));

                 checkInitSymbol("m2", Arrays.asList(0, 1), Arrays.asList("t1", "t2"));

             } else {

                 error(wrongParamsErrorMsg);

             }

         }

     }

     void checkClassFile(final File cfile, int numberOfParams) throws Exception {

         ClassFile classFile = ClassFile.read(cfile);

         boolean methodFound = false;

         for (Method method : classFile.methods) {

             if (method.getName(classFile.constant_pool).equals("<init>")) {

                 methodFound = true;

             }

         }

         Assert.check(methodFound, seekMethodNotFoundMsg);

     }

     /*  This method expect a non-null ordered list of integers, listing the

      *  position of the parameters to be checked on the init method. Position 0

      *  corresponds to the first parameter.

      *

      *  As we are looking for a constructor of an anonymous class, the

      *  classOwnerName parameter must be the name of the method where the

      *  anonymous class is declared.

      */

     void checkInitSymbol(

             final String classOwnerName,

             final java.util.List<Integer> paramsToCheck,

             final java.util.List<String> paramNames)

             throws IOException {

         Assert.checkNonNull(paramsToCheck, nonNullParamPositionsMsg);

         JavaCompiler c = ToolProvider.getSystemJavaCompiler();

         StandardJavaFileManager fm = c.getStandardFileManager(null, null, null);

         Iterable<? extends JavaFileObject> fos =

                 fm.getJavaFileObjectsFromFiles(

                 Arrays.asList(new File(System.getProperty("test.src"),

                 this.getClass().getName() + ".java")));

         JavacTask task = (JavacTask) c.getTask(null, fm, null,

                 Arrays.asList("-d", System.getProperty("user.dir")), null, fos);

         BasicJavacTask impl = (BasicJavacTask)task;

         Context context = impl.getContext();

         final Names names = Names.instance(context);

         task.addTaskListener(new TaskListener() {

             @Override

             public void started(TaskEvent e) {}

             @Override

             public void finished(TaskEvent e) {

                 class TheTreeScanner extends TreeScanner {

                     boolean foundAndCorrect = false;

                     @Override

                     public void visitMethodDef(JCTree.JCMethodDecl tree) {

                         ClassSymbol clazz = (ClassSymbol)tree.sym.owner;

                         if (clazz.owner.name.toString().equals(classOwnerName) &&

                             tree.sym.name == names.init) {

                             int currentParamPos = 0;

                             int paramArrayIndex = 0;

                             List<VarSymbol> params = tree.sym.params;

                             while (params.nonEmpty() && paramArrayIndex < paramsToCheck.size()) {

                                 VarSymbol param = params.head;

                                 if (currentParamPos == paramsToCheck.get(paramArrayIndex)) {

                                     if (!param.name.toString()

                                             .equals(paramNames.get(paramArrayIndex))) {

                                         error(paramNameNotCopiedAssertionMsg);

                                     }

                                     paramArrayIndex++;

                                 }

                                 currentParamPos++;

                                 params = params.tail;

                             }

                             foundAndCorrect = paramArrayIndex >= paramsToCheck.size();

                         }

                         super.visitMethodDef(tree);

                     }

                 }

                 if (e.getKind() == TaskEvent.Kind.ANALYZE) {

                     CompilationUnitTree compUnitTree = e.getCompilationUnit();

                     boolean foundAndCorrect = false;

                     for (Tree tree : compUnitTree.getTypeDecls()) {

                         TheTreeScanner scanner = new TheTreeScanner();

                         scanner.scan((JCTree) tree);

                         foundAndCorrect = foundAndCorrect | scanner.foundAndCorrect;

                     }

                     if (!foundAndCorrect) {

                         error(seekMethodNotFound);

                     }

                 }

             }

         });

         if (!task.call()) {

             error(compilationFailed);

         }

     }

     void error(String msg) {

         throw new AssertionError(msg);

     }

     @Target(value = {ElementType.PARAMETER})

     @interface ParamAnnotation {}

     /*  If more cases are added in the future, it should be taken into account

      *  that method checkInitSymbol locates the inner class looking for its

      *  container method, which in the cases below are m1 and m2. So new cases

      *  must have different names for container methods or method checkInitSymbol

      *  should be changed.

      */

     public class initParams {

         public initParams(@ParamAnnotation int i) {}

         public void m1() {

             new initParams(2) {};

         }

     }

     class Generics<T1> {

         T1 obj1;

         Object obj2;

         <T2> Generics(@ParamAnnotation T1 t1, @ParamAnnotation T2 t2) {

             obj1 = t1;

             obj2 = t2;

         }

         void m2() {

             Generics<Integer> a = new <String>Generics<Integer>(

                     new Integer(11), "foo") {};

         }

     }

 }