/*

 * Copyright (c) 2009, 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 6889255

 * @summary ClassReader does not read parameter names correctly

 */

import java.io.*;

import java.util.*;

import javax.tools.StandardLocation;

import com.sun.tools.javac.code.Flags;

import com.sun.tools.javac.code.Kinds;

import com.sun.tools.javac.code.Scope;

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

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.code.Type.ClassType;

import com.sun.tools.javac.code.TypeTag;

import com.sun.tools.javac.file.JavacFileManager;

import com.sun.tools.javac.jvm.ClassReader;

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

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

public class T6889255 {

    boolean testInterfaces = true;

    boolean testSyntheticMethods = true;

    // The following enums control the generation of the test methods to be compiled.

    enum GenericKind {

        NOT_GENERIC,

        GENERIC

    };

    enum ClassKind {

        CLASS("Clss"),

        INTERFACE("Intf"),

        ENUM("Enum");

        final String base;

        ClassKind(String base) { this.base = base; }

    };

    enum NestedKind {

        /** Declare methods inside the outermost container. */

        NONE,

        /** Declare methods inside a container with a 'static' modifier. */

        NESTED,

        /** Declare methods inside a container without a 'static' modifier. */

        INNER,

        /** Declare methods inside a local class in an initializer. */

        INIT_LOCAL,

        /** Declare methods inside an anonymous class in an initializer. */

        INIT_ANON,

        /** Declare methods inside a local class in a method. */

        METHOD_LOCAL,

        /** Declare methods inside an anonymous class in a method. */

        METHOD_ANON

    };

    enum MethodKind {

        ABSTRACT,

        CONSTRUCTOR,

        METHOD,

        STATIC_METHOD,

        BRIDGE_METHOD

    };

    enum FinalKind {

        /** Method body does not reference external final variables. */

        NO_FINAL,

        /** Method body references external final variables. */

        USE_FINAL

    };

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

        new T6889255().run();

    }

    void run() throws Exception {

        genTest();

        test("no-args", false);

        test("g",       true,  "-g");

        if (errors > 0)

            throw new Exception(errors + " errors found");

    }

    /**

     * Create a file containing lots of method definitions to be tested.

     * There are 3 sets of nested loops that generate the methods.

     * 1. The outermost set declares [generic] (class | interface | enum)

     * 2. The middle set declares [(nested | inner | anon | local)] class

     * 3. The innermost set declares

     *      [generic] (constructor|method|static-method|bridge-method) [using final variables in outer scope]

     * Invalid combinations are filtered out.

     */

    void genTest() throws Exception {

        BufferedWriter out = new BufferedWriter(new FileWriter("Test.java"));

        // This interface is used to force bridge methods to be generated, by

        // implementing its methods with subtypes of Object

        out.write("interface Base {\n");

        out.write("    Object base_m1(int i1);\n");

        out.write("    Object base_m2(int i1);\n");

        out.write("}\n");

        int outerNum = 0;

        // Outermost set of loops, to generate a top level container

        for (GenericKind outerGenericKind: GenericKind.values()) {

            for (ClassKind outerClassKind: ClassKind.values()) {

                if (outerGenericKind == GenericKind.GENERIC && outerClassKind == ClassKind.ENUM)

                    continue;

                String outerClassName = outerClassKind.base + (outerNum++);

                String outerTypeArg = outerClassKind.toString().charAt(0) + "T";

                if (outerClassKind == ClassKind.CLASS)

                    out.write("abstract ");

                out.write(outerClassKind.toString().toLowerCase() + " " + outerClassName);

                if (outerGenericKind == GenericKind.GENERIC)

                    out.write("<" + outerTypeArg + ">");

                if (outerClassKind == ClassKind.INTERFACE)

                    out.write(" extends Base");

                else

                    out.write(" implements Base");

                out.write(" {\n");

                if (outerClassKind == ClassKind.ENUM) {

                    out.write("    E1(0,0,0), E2(0,0,0), E3(0,0,0);\n");

                    out.write("    " + outerClassName + "(int i1, int i2, int i3) { }\n");

                }

                // Middle set of loops, to generate an optional nested container

                int nestedNum = 0;

                int methodNum = 0;

                for (GenericKind nestedGenericKind: GenericKind.values()) {

                    nextNestedKind:

                    for (NestedKind nestedKind: NestedKind.values()) {

                        // if the nested kind is none, there is no point iterating over all

                        // nested generic kinds, so arbitarily limit it to just one kind

                        if (nestedKind == NestedKind.NONE && nestedGenericKind != GenericKind.NOT_GENERIC)

                            continue;

                        if ((nestedKind == NestedKind.METHOD_ANON || nestedKind == NestedKind.INIT_ANON)

                                && nestedGenericKind == GenericKind.GENERIC)

                            continue;

                        String indent = "    ";

                        boolean haveFinal = false;

                        switch (nestedKind) {

                            case METHOD_ANON: case METHOD_LOCAL:

                                if (outerClassKind == ClassKind.INTERFACE)

                                    continue nextNestedKind;

                                out.write(indent + "void m" +  + (nestedNum++) + "() {\n");

                                indent += "    ";

                                out.write(indent + "final int fi1 = 0;\n");

                                haveFinal = true;

                                break;

                            case INIT_ANON: case INIT_LOCAL:

                                if (outerClassKind == ClassKind.INTERFACE)

                                    continue nextNestedKind;

                                out.write(indent + "{\n");

                                indent += "    ";

                                break;

                        }

                        for (ClassKind nestedClassKind: ClassKind.values()) {

                            if ((nestedGenericKind == GenericKind.GENERIC)

                                    && (nestedClassKind == ClassKind.ENUM))

                                continue;

                            if ((nestedKind == NestedKind.METHOD_ANON || nestedKind == NestedKind.METHOD_LOCAL

                                    || nestedKind == NestedKind.INIT_ANON || nestedKind == NestedKind.INIT_LOCAL)

                                    && nestedClassKind != ClassKind.CLASS)

                                continue;

                            // if the nested kind is none, there is no point iterating over all

                            // nested class kinds, so arbitarily limit it to just one kind

                            if (nestedKind == NestedKind.NONE && nestedClassKind != ClassKind.CLASS)

                                continue;

                            ClassKind methodClassKind;

                            String methodClassName;

                            boolean allowAbstractMethods;

                            boolean allowStaticMethods;

                            switch (nestedKind) {

                                case NONE:

                                    methodClassKind = outerClassKind;

                                    methodClassName = outerClassName;

                                    allowAbstractMethods = (outerClassKind == ClassKind.CLASS);

                                    allowStaticMethods = (outerClassKind != ClassKind.INTERFACE);

                                    break;

                                case METHOD_ANON:

                                case INIT_ANON:

                                    out.write(indent + "new Base() {\n");

                                    indent += "    ";

                                    methodClassKind = ClassKind.CLASS;

                                    methodClassName = null;

                                    allowAbstractMethods = false;

                                    allowStaticMethods = false;

                                    break;

                                default: { // INNER, NESTED, LOCAL

                                    String nestedClassName = "N" + nestedClassKind.base + (nestedNum++);

                                    String nestedTypeArg = nestedClassKind.toString().charAt(0) + "T";

                                    out.write(indent);

                                    if (nestedKind == NestedKind.NESTED)

                                        out.write("static ");

                                    if (nestedClassKind == ClassKind.CLASS)

                                        out.write("abstract ");

                                    out.write(nestedClassKind.toString().toLowerCase() + " " + nestedClassName);

                                    if (nestedGenericKind == GenericKind.GENERIC)

                                        out.write("<" + nestedTypeArg + ">");

                                    if (nestedClassKind == ClassKind.INTERFACE)

                                        out.write(" extends Base ");

                                    else

                                        out.write(" implements Base ");

                                    out.write(" {\n");

                                    indent += "    ";

                                    if (nestedClassKind == ClassKind.ENUM) {

                                        out.write(indent + "E1(0,0,0), E2(0,0,0), E3(0,0,0);\n");

                                        out.write(indent + nestedClassName + "(int i1, int i2, int i3) { }\n");

                                    }

                                    methodClassKind = nestedClassKind;

                                    methodClassName = nestedClassName;

                                    allowAbstractMethods = (nestedClassKind == ClassKind.CLASS);

                                    allowStaticMethods = (nestedKind == NestedKind.NESTED && nestedClassKind != ClassKind.INTERFACE);

                                    break;

                                }

                            }

                            // Innermost loops, to generate methods

                            for (GenericKind methodGenericKind: GenericKind.values()) {

                                for (FinalKind finalKind: FinalKind.values()) {

                                    for (MethodKind methodKind: MethodKind.values()) {

//                                        out.write("// " + outerGenericKind

//                                                + " " + outerClassKind

//                                                + " " + nestedKind

//                                                + " " + nestedGenericKind

//                                                + " " + nestedClassKind

//                                                + " " + methodGenericKind

//                                                + " " + finalKind

//                                                + " " + methodKind

//                                                + "\n");

                                        switch (methodKind) {

                                            case CONSTRUCTOR:

                                                if (nestedKind == NestedKind.METHOD_ANON || nestedKind == NestedKind.INIT_ANON)

                                                    break;

                                                if (methodClassKind != ClassKind.CLASS)

                                                    break;

                                                if (finalKind == FinalKind.USE_FINAL && !haveFinal)

                                                    break;

                                                out.write(indent);

                                                if (methodGenericKind == GenericKind.GENERIC) {

                                                    out.write("<CT> " + methodClassName + "(CT c1, CT c2");

                                                } else {

                                                    out.write(methodClassName + "(boolean b1, char c2");

                                                }

                                                if (finalKind == FinalKind.USE_FINAL) {

                                                    // add a dummy parameter to avoid duplicate declaration

                                                    out.write(", int i3) { int i = fi1; }\n");

                                                } else

                                                    out.write(") { }\n");

                                                break;

                                            case ABSTRACT:

                                                if (!allowAbstractMethods)

                                                    continue;

                                                // fallthrough

                                            case METHOD:

                                                if (finalKind == FinalKind.USE_FINAL && !haveFinal)

                                                    break;

                                                out.write(indent);

                                                if (methodKind == MethodKind.ABSTRACT)

                                                    out.write("abstract ");

                                                if (methodGenericKind == GenericKind.GENERIC)

                                                    out.write("<MT> ");

                                                out.write("void m" + (methodNum++) + "(int i1, long l2, float f3)");

                                                if (methodKind == MethodKind.ABSTRACT || methodClassKind == ClassKind.INTERFACE)

                                                    out.write(";\n");

                                                else {

                                                    out.write(" {");

                                                    if (finalKind == FinalKind.USE_FINAL)

                                                        out.write(" int i = fi1;");

                                                    out.write(" }\n");

                                                }

                                                break;

                                            case BRIDGE_METHOD:

                                                if (methodGenericKind == GenericKind.GENERIC)

                                                    break;

                                                out.write(indent);

                                                // methods Base.base_m1 and Base.base_m2 are declared for the

                                                // benefit of bridge methods. They need to be implemented

                                                // whether or not a final variable is used.

                                                String methodName = (finalKind == FinalKind.NO_FINAL ? "base_m1" : "base_m2");

                                                out.write("public String " + methodName + "(int i1)");

                                                if (methodClassKind == ClassKind.INTERFACE)

                                                    out.write(";\n");

                                                else {

                                                    out.write(" {");

                                                    if (finalKind == FinalKind.USE_FINAL && haveFinal)

                                                        out.write(" int i = fi1;");

                                                    out.write(" return null; }\n");

                                                }

                                                break;

                                            case STATIC_METHOD:

                                                if (!allowStaticMethods)

                                                    break;

                                                if (finalKind == FinalKind.USE_FINAL && !haveFinal)

                                                    break;

                                                out.write(indent + "static ");

                                                if (methodGenericKind == GenericKind.GENERIC)

                                                    out.write("<MT> ");

                                                out.write("void m" + (methodNum++) + "(int i1, long l2, float f3) {");

                                                if (finalKind == FinalKind.USE_FINAL)

                                                    out.write(" int i = fi1;");

                                                out.write(" }\n");

                                                break;

                                        }

                                    }

                                }

                            }

                            if (nestedKind != NestedKind.NONE) {

                                indent = indent.substring(0, indent.length() - 4);

                                out.write(indent + "};\n");

                            }

                        }

                        switch (nestedKind) {

                            case METHOD_ANON: case METHOD_LOCAL:

                            case INIT_ANON: case INIT_LOCAL:

                                indent = indent.substring(0, indent.length() - 4);

                                out.write(indent + "}\n\n");

                        }

                    }

                }

                out.write("}\n\n");

            }

        }

        out.close();

    }

    void test(String testName, boolean expectNames, String... opts) throws Exception {

        System.err.println("Test " + testName

                + ": expectNames:" + expectNames

                + " javacOpts:" + Arrays.asList(opts));

        File outDir = new File(testName);

        outDir.mkdirs();

        compile(outDir, opts);

        Context ctx = new Context();

        JavacFileManager fm = new JavacFileManager(ctx, true, null);

        fm.setLocation(StandardLocation.CLASS_PATH, Arrays.asList(outDir));

        ClassReader cr = ClassReader.instance(ctx);

        cr.saveParameterNames = true;

        Names names = Names.instance(ctx);

        Set<String> classes = getTopLevelClasses(outDir);

        Deque<String> work = new LinkedList<String>(classes);

        String classname;

        while ((classname = work.poll()) != null) {

            System.err.println("Checking class " + classname);

            ClassSymbol sym = cr.enterClass(names.table.fromString(classname));

            sym.complete();

            if ((sym.flags() & Flags.INTERFACE) != 0 && !testInterfaces)

                continue;

            for (Scope.Entry e = sym.members_field.elems; e != null; e = e.sibling) {

                System.err.println("Checking member " + e.sym);

                switch (e.sym.kind) {

                    case Kinds.TYP: {

                        String name = e.sym.flatName().toString();

                        if (!classes.contains(name)) {

                            classes.add(name);

                            work.add(name);

                        }

                        break;

                    }

                    case Kinds.MTH:

                        verify((MethodSymbol) e.sym, expectNames);

                        break;

                }

            }

        }

    }

    void verify(MethodSymbol m, boolean expectNames) {

        if ((m.flags() & Flags.SYNTHETIC) != 0 && !testSyntheticMethods)

            return;

        //System.err.println("verify: " + m.params());

        int i = 1;

        for (VarSymbol v: m.params()) {

            String expectName;

            if (expectNames)

                expectName = getExpectedName(v, i);

            else

                expectName = "arg" + (i - 1);

            checkEqual(expectName, v.name.toString());

            i++;

        }

    }

    String getExpectedName(VarSymbol v, int i) {

        // special cases:

        // synthetic method

        if (((v.owner.owner.flags() & Flags.ENUM) != 0)

                && v.owner.name.toString().equals("valueOf"))

            return "name";

        // interfaces don't have saved names

        // -- no Code attribute for the LocalVariableTable attribute

        if ((v.owner.owner.flags() & Flags.INTERFACE) != 0)

            return "arg" + (i - 1);

        // abstract methods don't have saved names

        // -- no Code attribute for the LocalVariableTable attribute

        if ((v.owner.flags() & Flags.ABSTRACT) != 0)

            return "arg" + (i - 1);

        // bridge methods use argN. No LVT for them anymore

        if ((v.owner.flags() & Flags.BRIDGE) != 0)

            return "arg" + (i - 1);

        // The rest of this method assumes the local conventions in the test program

        Type t = v.type;

        String s;

        if (t.hasTag(TypeTag.CLASS))

            s = ((ClassType) t).tsym.name.toString();

        else

            s = t.toString();

        return String.valueOf(Character.toLowerCase(s.charAt(0))) + i;

    }

    void compile(File outDir, String... opts) throws Exception {

        //File testSrc = new File(System.getProperty("test.src"), ".");

        List<String> args = new ArrayList<String>();

        args.add("-d");

        args.add(outDir.getPath());

        args.addAll(Arrays.asList(opts));

        //args.add(new File(testSrc, "Test.java").getPath());

        args.add("Test.java");

        StringWriter sw = new StringWriter();

        PrintWriter pw = new PrintWriter(sw);

        int rc = com.sun.tools.javac.Main.compile(args.toArray(new String[args.size()]), pw);

        pw.close();

        if (rc != 0) {

            System.err.println(sw.toString());

            throw new Exception("compilation failed unexpectedly");

        }

    }

    Set<String> getTopLevelClasses(File outDir) {

        Set<String> classes = new HashSet<String>();

        for (String f: outDir.list()) {

            if (f.endsWith(".class") && !f.contains("$"))

                classes.add(f.replace(".class", ""));

        }

        return classes;

    }

    void checkEqual(String expect, String found) {

        if (!expect.equals(found))

            error("mismatch: expected:" + expect + " found:" + found);

    }

    void error(String msg) {

        System.err.println(msg);

        errors++;

        throw new Error();

    }

    int errors;

}