source: java2python/core/src/test/java/javaparser/ArraysResolveTest.java

package javaparser;

import java.util.Arrays;
import java.util.List;

import org.junit.Ignore;
import org.junit.Test;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ParserConfiguration;
import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.BodyDeclaration;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.expr.MethodCallExpr;
import com.github.javaparser.ast.expr.NameExpr;
import com.github.javaparser.ast.expr.VariableDeclarationExpr;
import com.github.javaparser.ast.stmt.ExpressionStmt;
import com.github.javaparser.symbolsolver.JavaSymbolSolver;
import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;

public class ArraysResolveTest {

        public static void main(String[] args) {
                Integer v = 3;
                List<Integer> x = Arrays.asList(1, 2, v);
        }

        String CODE = "import java.util.Arrays;\n"
                        + "public class ArraysResolveTest {\n" + "\n"
                        + "     public static void main(String[] args) {\n"
                        + "                             List<Integer> x = Arrays.asList(1, 2);\n"//
                        + "     }\n" + "}";

        @Ignore // nonworking version replicating issue in our code
        @Test
        public void testResolve() {
                ParserConfiguration conf = new ParserConfiguration();
                CombinedTypeSolver typeSolver = new CombinedTypeSolver();
                typeSolver.add(new ReflectionTypeSolver(false));
                // FIXME add sources of jars source code etc
                // typeSolver.add(new JavaParserTypeSolver(new File(SOURCE_PATH)));
                // typeSolver.add(new JarTypeSolver(jarSourceFile));
                JavaSymbolSolver symbolSolver = new JavaSymbolSolver(typeSolver);
                conf.setSymbolResolver(symbolSolver);
                JavaParser parser = new JavaParser(conf);

                CompilationUnit res = parser.parse(CODE).getResult().get();

                BodyDeclaration<?> mainmethod = res.getType(0).getMembers().get(0);
                ExpressionStmt statement = (ExpressionStmt) ((MethodDeclaration) mainmethod)
                                .getBody().get().getStatements().get(0);
                VariableDeclarationExpr exp = (VariableDeclarationExpr) statement
                                .getExpression();
                MethodCallExpr initvalue = (MethodCallExpr) exp.getVariable(0)
                                .getInitializer().get();
                NameExpr scope = (NameExpr) initvalue.getScope().get();
                scope.resolve();
        }

        @Test
        public void testResolveFixed() {
                ParserConfiguration conf = new ParserConfiguration();
                CombinedTypeSolver typeSolver = new CombinedTypeSolver();
                typeSolver.add(new ReflectionTypeSolver(false));
                // FIXME add sources of jars source code etc
                // typeSolver.add(new JavaParserTypeSolver(new File(SOURCE_PATH)));
                // typeSolver.add(new JarTypeSolver(jarSourceFile));
                JavaSymbolSolver symbolSolver = new JavaSymbolSolver(typeSolver);
                conf.setSymbolResolver(symbolSolver);
                JavaParser parser = new JavaParser(conf);

                CompilationUnit res = parser.parse(CODE).getResult().get();

                BodyDeclaration<?> mainmethod = res.getType(0).getMembers().get(0);
                ExpressionStmt statement = (ExpressionStmt) ((MethodDeclaration) mainmethod)
                                .getBody().get().getStatements().get(0);
                VariableDeclarationExpr exp = (VariableDeclarationExpr) statement
                                .getExpression();
                MethodCallExpr initvalue = (MethodCallExpr) exp.getVariable(0)
                                .getInitializer().get();
                NameExpr scope = (NameExpr) initvalue.getScope().get();
                System.out.println(scope.calculateResolvedType());
        }

        /**
         * Solution proposed by https://github.com/javaparser/javaparser/issues/3689
         */
        @Test
        public void test3689() {
                String CODE = "import java.util.Arrays;\n"
                                + "public class ArraysResolveTest {\n" + "\n"
                                + " public static void main(String[] args) {\n"
                                + "             List<Integer> x = Arrays.asList(1, 2);\n"//
                                + " }\n" + "}";

                ParserConfiguration configuration = new ParserConfiguration()
                                .setSymbolResolver(new JavaSymbolSolver(
                                                new CombinedTypeSolver(new ReflectionTypeSolver())));
                StaticJavaParser.setConfiguration(configuration);

                CompilationUnit cu = StaticJavaParser.parse(CODE);

                List<MethodCallExpr> mces = cu.findAll(MethodCallExpr.class);

                for (MethodCallExpr mce : mces) {
                        System.out.println(mce.toString());
                        System.out.println(">>" + mce.resolve().toString());
                        // find the/ method declaration
                        System.out.println(">>"
                                        + mce.getScope().get().calculateResolvedType().describe());
                        // find the type of the scope of the method call expression
                }
        }

        @Test
        public void modifiedTest() {
                String CODE = "import java.util.Arrays;\n"
                                + "public class ArraysResolveTest {\n"
                                + "     public static void main(String[] args) {\n"
                                + "             Integer v = 3;\n"
                                + "             List<Integer> x = Arrays.asList(1, 2, v);\n"///
                                + "     }\n}";
                ParserConfiguration configuration = new ParserConfiguration()
                                .setSymbolResolver(new JavaSymbolSolver(
                                                new CombinedTypeSolver(new ReflectionTypeSolver())));
                StaticJavaParser.setConfiguration(configuration);

                CompilationUnit cu = StaticJavaParser.parse(CODE);

                List<NameExpr> names = cu.findAll(NameExpr.class);

                for (NameExpr ne : names) {
                        System.out.println(ne.toString());
                        String type = "???";
                        try {
                                type = ne.resolve().toString();
                        } catch (Exception e) {
                        }
                        System.out.println(">>" + type);
                }
        }

}