| /******************************************************************************* |
| * Copyright (c) 2014, 2018 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.core.tests.model; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.util.HashMap; |
| |
| import junit.framework.Test; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jdt.core.IClassFile; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IMethod; |
| import org.eclipse.jdt.core.IPackageFragment; |
| import org.eclipse.jdt.core.IPackageFragmentRoot; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.ITypeHierarchy; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.dom.AST; |
| import org.eclipse.jdt.core.dom.ASTParser; |
| import org.eclipse.jdt.core.dom.IBinding; |
| import org.eclipse.jdt.core.dom.IMethodBinding; |
| import org.eclipse.jdt.core.dom.ITypeBinding; |
| import org.eclipse.jdt.core.tests.util.AbstractCompilerTest; |
| import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; |
| import org.eclipse.jdt.internal.core.LambdaExpression; |
| import org.eclipse.jdt.internal.core.LambdaMethod; |
| import org.eclipse.jdt.internal.core.SourceMethod; |
| |
| @SuppressWarnings({"rawtypes", "unchecked"}) |
| public class JavaElement8Tests extends AbstractJavaModelTests { |
| |
| static { |
| // TESTS_NAMES = new String[] {"testBug428178"}; |
| } |
| |
| public JavaElement8Tests(String name) { |
| super(name); |
| this.endChar = ""; |
| } |
| public static Test suite() { |
| return buildModelTestSuite(AbstractCompilerTest.F_1_8, JavaElement8Tests.class); |
| } |
| @Deprecated |
| static int getJSL9() { |
| return AST.JLS9; |
| } |
| public void testBug428178() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug428178", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = "package p;\n" + |
| "public interface Test {\n" + |
| " static void main(String[] args) {\n" + |
| " System.out.println(\"Hello\");\n" + |
| " }\n" + |
| "}"; |
| createFolder("/Bug428178/src/p"); |
| createFile( "/Bug428178/src/p/Test.java", fileContent); |
| |
| ICompilationUnit unit = getCompilationUnit("/Bug428178/src/p/Test.java"); |
| IMethod method = unit.getTypes()[0].getMethods()[0]; |
| assertNotNull("Method should not be null", method); |
| assertTrue("Should be a main method", method.isMainMethod()); |
| } |
| finally { |
| deleteProject("Bug428178"); |
| } |
| } |
| public void testBug428178a() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug428178", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = "package p;\n" + |
| "public interface Test {\n" + |
| " static void main(String[] args) {\n" + |
| " System.out.println(\"Hello\");\n" + |
| " }\n" + |
| "}"; |
| addLibrary(project, |
| "lib.jar", |
| "src.zip", new |
| String[] {"p/Test.java", fileContent}, |
| JavaCore.VERSION_1_8); |
| IType type = getPackageFragmentRoot("Bug428178", "lib.jar").getPackageFragment("p").getOrdinaryClassFile("Test.class").getType(); |
| IMethod method = type.getMethods()[0]; |
| assertNotNull("Method should not be null", method); |
| assertTrue("Should be a main method", method.isMainMethod()); |
| } |
| finally { |
| deleteProject("Bug428178"); |
| } |
| } |
| public void testBug429641() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug429641", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = "package p;\n" + |
| "public interface Test {\n" + |
| " static void main(String[] args) {\n" + |
| " I i = (x) -> {};\n" + |
| " }\n" + |
| "}\n" + |
| "interface I {\n" + |
| " public void foo(int x);\n" + |
| "}"; |
| createFolder("/Bug429641/src/p"); |
| createFile( "/Bug429641/src/p/Test.java", fileContent); |
| ICompilationUnit unit = getCompilationUnit("/Bug429641/src/p/Test.java"); |
| int start = fileContent.indexOf("x) ->"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertEquals("Incorrect no of elements", 1, elements.length); |
| assertEquals("Incorrect element type", IJavaElement.LOCAL_VARIABLE, elements[0].getElementType()); |
| IMethod method = (IMethod) elements[0].getParent(); |
| assertTrue("Should be a lambda method", method.isLambdaMethod()); |
| } |
| finally { |
| deleteProject("Bug429641"); |
| } |
| } |
| public void testBug429641a() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug429641", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = "package p;\n" + |
| "public interface Test {\n" + |
| " static void main(String[] args) {\n" + |
| " I i = (x) -> {};\n" + |
| " }\n" + |
| "}\n" + |
| "interface I {\n" + |
| " public void foo(int x);\n" + |
| "}"; |
| createFolder("/Bug429641/src/p"); |
| createFile( "/Bug429641/src/p/Test.java", fileContent); |
| ICompilationUnit unit = getCompilationUnit("/Bug429641/src/p/Test.java"); |
| int start = fileContent.lastIndexOf("x"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertEquals("Incorrect no of elements", 1, elements.length); |
| assertEquals("Incorrect element type", IJavaElement.LOCAL_VARIABLE, elements[0].getElementType()); |
| IMethod method = (IMethod) elements[0].getParent(); |
| assertTrue("Should not be a lambda method", !method.isLambdaMethod()); |
| } |
| finally { |
| deleteProject("Bug429641"); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=429948, Unhandled event loop exception is thrown when a lambda expression is nested |
| public void test429948() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug429948", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface Supplier<T> {\n" + |
| " T get();\n" + |
| "}\n" + |
| "interface Runnable {\n" + |
| " public abstract void run();\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " execute(() -> {\n" + |
| " executeInner(() -> {\n" + |
| " });\n" + |
| " return null;\n" + |
| " });\n" + |
| " System.out.println(\"done\");\n" + |
| " }\n" + |
| " static <R> R execute(Supplier<R> supplier) {\n" + |
| " return null;\n" + |
| " }\n" + |
| " static void executeInner(Runnable callback) {\n" + |
| " }\n" + |
| "}\n"; |
| createFile( "/Bug429948/src/X.java", fileContent); |
| IType type = getCompilationUnit("/Bug429948/src/X.java").getType("X"); |
| ITypeHierarchy h = type.newSupertypeHierarchy(null); |
| assertHierarchyEquals( |
| "Focus: X [in X.java [in <default> [in src [in Bug429948]]]]\n" + |
| "Super types:\n" + |
| " Object [in Object.class [in java.lang [in "+ getExternalPath() + "jclMin1.8.jar]]]\n" + |
| "Sub types:\n", |
| h); |
| } |
| finally { |
| deleteProject("Bug429948"); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=429948, Unhandled event loop exception is thrown when a lambda expression is nested |
| public void test429948a() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug429948", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface Supplier<T> {\n" + |
| " T get();\n" + |
| "}\n" + |
| "interface Runnable {\n" + |
| " public abstract void run();\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " execute(() -> {\n" + |
| " executeOuter(() -> {\n" + |
| " executeInner(() -> {\n" + |
| " });\n" + |
| " return null;\n" + |
| " });\n" + |
| " });\n" + |
| " System.out.println(\"done\");\n" + |
| " }\n" + |
| " static <R> R execute(Supplier<R> supplier) {\n" + |
| " return null;\n" + |
| " }\n" + |
| " static void executeInner(Runnable callback) {\n" + |
| " }\n" + |
| " static void executeOuter(Runnable callback) {\n" + |
| " }\n" + |
| "}\n"; |
| createFile( "/Bug429948/src/X.java", fileContent); |
| IType type = getCompilationUnit("/Bug429948/src/X.java").getType("X"); |
| ITypeHierarchy h = type.newSupertypeHierarchy(null); |
| assertHierarchyEquals( |
| "Focus: X [in X.java [in <default> [in src [in Bug429948]]]]\n" + |
| "Super types:\n" + |
| " Object [in Object.class [in java.lang [in "+ getExternalPath() + "jclMin1.8.jar]]]\n" + |
| "Sub types:\n", |
| h); |
| } |
| finally { |
| deleteProject("Bug429948"); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=429966, [1.8] CUD#functionalExpressions may record lambda copies in nested lambda situations |
| public void test429966() throws CoreException { |
| String projectName = "Bug429966"; |
| try { |
| IJavaProject project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface Supplier<T> {\n" + |
| " T get();\n" + |
| "}\n" + |
| "interface Runnable {\n" + |
| " public abstract void run();\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " execute(() -> {\n" + |
| " executeOuter(() -> {\n" + |
| " executeInner(() -> {\n" + |
| " });\n" + |
| " });\n" + |
| " return null;\n" + |
| " });\n" + |
| " }\n" + |
| " static <R> R execute(Supplier<R> supplier) {\n" + |
| " return null;\n" + |
| " }\n" + |
| " static void executeInner(Runnable callback) {\n" + |
| " }\n" + |
| " static void executeOuter(Runnable callback) {\n" + |
| " }\n" + |
| "}\n"; |
| String fileName = "/" + projectName + "/src/X.java"; |
| createFile(fileName, fileContent); |
| IType type = getCompilationUnit(fileName).getType("Runnable"); |
| ITypeHierarchy h = type.newTypeHierarchy(null); |
| assertHierarchyEquals( |
| "Focus: Runnable [in X.java [in <default> [in src [in Bug429966]]]]\n" + |
| "Super types:\n" + |
| "Sub types:\n" + |
| " <lambda #1> [in get() [in <lambda #1> [in main(String[]) [in X [in X.java [in <default> [in src [in Bug429966]]]]]]]]\n" + |
| " <lambda #1> [in run() [in <lambda #1> [in get() [in <lambda #1> [in main(String[]) [in X [in X.java [in <default> [in src [in Bug429966]]]]]]]]]]\n", |
| h); |
| } |
| finally { |
| deleteProject(projectName); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=429910 |
| public void testBug429910() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug429910", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = "package p;\n" + |
| "import java.util.List;\n" + |
| "public interface Test {\n" + |
| " static void main(String[] args) {\n" + |
| " I<String> i = (x) -> {};\n" + |
| " }\n" + |
| "}\n" + |
| "interface I<T> {\n" + |
| " public void foo(List<T> x);\n" + |
| "}"; |
| createFolder("/Bug429910/src/p"); |
| createFile( "/Bug429910/src/p/Test.java", fileContent); |
| ICompilationUnit unit = getCompilationUnit("/Bug429910/src/p/Test.java"); |
| int start = fileContent.indexOf("x) ->"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertEquals("Incorrect no of elements", 1, elements.length); |
| assertEquals("Incorrect element type", IJavaElement.LOCAL_VARIABLE, elements[0].getElementType()); |
| IMethod method = (IMethod) elements[0].getParent(); |
| assertTrue("Should be a lambda method",method.isLambdaMethod()); |
| IJavaElement parent = method.getParent(); |
| assertTrue("Should be a lambda expression", (parent instanceof LambdaExpression)); |
| LambdaExpression lambda = (LambdaExpression) parent; |
| String sigs = lambda.getSuperInterfaceTypeSignatures()[0]; |
| assertEquals("Incorrect super interface signature", "Lp.I<Ljava.lang.String;>;", sigs); |
| } |
| finally { |
| deleteProject("Bug429910"); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=429910 [1.8][model] Superinterfaces of lambda element's IType are missing type arguments |
| public void testBug429910a() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug429910", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = "package p;\n" + |
| "public interface MyFunction<T, R> {\n" + |
| " R apply(T t);\n" + |
| " default <V> MyFunction<V, R> compose(MyFunction<? super V, ? extends T> before) {\n" + |
| " return (V v) -> apply(before.apply(v));" + |
| " }" + |
| "}"; |
| createFolder("/Bug429910/src/p"); |
| createFile( "/Bug429910/src/p/MyFunction.java", fileContent); |
| ICompilationUnit unit = getCompilationUnit("/Bug429910/src/p/MyFunction.java"); |
| int start = fileContent.indexOf("v))"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertEquals("Incorrect no of elements", 1, elements.length); |
| assertEquals("Incorrect element type", IJavaElement.LOCAL_VARIABLE, elements[0].getElementType()); |
| IMethod method = (IMethod) elements[0].getParent(); |
| assertTrue("Should be a lambda method",method.isLambdaMethod()); |
| assertEquals("Incorrect lambda method signature", "(TV;)TR;", method.getSignature()); |
| IJavaElement parent = method.getParent(); |
| assertTrue("Should be a lambda expression", (parent instanceof LambdaExpression)); |
| LambdaExpression lambda = (LambdaExpression) parent; |
| String sigs = lambda.getSuperInterfaceTypeSignatures()[0]; |
| assertEquals("Incorrect super interface signature", "Lp.MyFunction<TV;TR;>;", sigs); |
| } |
| finally { |
| deleteProject("Bug429910"); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=430026, [1.8] Lambda parameter has wrong parent if it declares its type |
| public void test430026() throws CoreException { |
| String projectName = "Bug429966"; |
| try { |
| IJavaProject project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface MyFunction<T, R> {\n" + |
| " R apply(T t);\n" + |
| " default <V> MyFunction<V, R> compose(MyFunction<? super V, ? extends T> before) {\n" + |
| " return (V v) -> apply(before.apply(v));\n" + |
| " }\n" + |
| "}\n"; |
| String fileName = "/" + projectName + "/src/X.java"; |
| createFile(fileName, fileContent); |
| |
| ICompilationUnit unit = getCompilationUnit(fileName); |
| int start = fileContent.indexOf("v"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertElementEquals("Wrong element", "v [in apply(V) [in <lambda #1> [in compose(MyFunction<? super V,? extends T>) [in MyFunction [in X.java [in <default> [in src [in Bug429966]]]]]]]]", elements[0]); |
| } |
| finally { |
| deleteProject(projectName); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=430026, [1.8] Lambda parameter has wrong parent if it declares its type |
| public void test430026a() throws CoreException { |
| String projectName = "Bug429966"; |
| try { |
| IJavaProject project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface MyFunction<T, R> {\n" + |
| " R apply(T t);\n" + |
| " default <V> MyFunction<V, R> compose(MyFunction<? super V, ? extends T> before) {\n" + |
| " return v -> apply(before.apply(v));\n" + |
| " }\n" + |
| "}\n"; |
| String fileName = "/" + projectName + "/src/X.java"; |
| createFile(fileName, fileContent); |
| |
| ICompilationUnit unit = getCompilationUnit(fileName); |
| int start = fileContent.indexOf("v"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertElementEquals("Wrong element", "v [in apply(V) [in <lambda #1> [in compose(MyFunction<? super V,? extends T>) [in MyFunction [in X.java [in <default> [in src [in Bug429966]]]]]]]]", elements[0]); |
| } |
| finally { |
| deleteProject(projectName); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=430033, [1.8][model] Lambda elements missing in ancestry for binary elements |
| public void test430033() throws CoreException, IOException { |
| |
| String jarName = "Elements.jar"; |
| String srcName = "Elements_src.zip"; |
| String projectName = "Bug430033"; |
| IJavaProject project = null; |
| try { |
| project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| |
| String[] pathAndContents = new String[] { |
| "IntPredicate.java", |
| "public interface IntPredicate {\n" + |
| " boolean test(int value);\n" + |
| " default IntPredicate and(IntPredicate other) {\n" + |
| " return (value) -> test(value) && other.test(value);\n" + |
| " }\n" + |
| "}\n" |
| }; |
| |
| HashMap libraryOptions = new HashMap(project.getOptions(true)); |
| libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); |
| addLibrary(project, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); |
| |
| |
| IPackageFragmentRoot[] packageFragmentRoots = project.getPackageFragmentRoots(); |
| IPackageFragment packageFragment = packageFragmentRoots[2].getPackageFragment(""); |
| IClassFile classFile = packageFragment.getClassFile("IntPredicate.class"); |
| IJavaElement[] elements = classFile.codeSelect(128, 5); |
| assertElementEquals("Wrong element", "value [in test(int) [in <lambda #1> [in and(IntPredicate) [in IntPredicate [in IntPredicate.class [in <default> [in Elements.jar [in Bug430033]]]]]]]]", elements[0]); |
| } |
| finally { |
| if (project != null) { |
| removeLibrary(project, jarName, srcName); |
| deleteProject(projectName); |
| } |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=430141, [1.8][hierarchy] Incorrect hierarchy with lambda elements missing |
| public void test430141() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug430141", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface I {\n" + |
| " void doit();\n" + |
| "}\n" + |
| "interface J extends I {\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " J j = () -> { System.out.println(\"Lambda\"); };\n" + |
| " j.doit();\n" + |
| " }\n" + |
| "}\n"; |
| createFile( "/Bug430141/src/X.java", fileContent); |
| IType type = getCompilationUnit("/Bug430141/src/X.java").getType("I"); |
| ITypeHierarchy h = type.newTypeHierarchy(null); |
| assertHierarchyEquals( |
| "Focus: I [in X.java [in <default> [in src [in Bug430141]]]]\n" + |
| "Super types:\n" + |
| "Sub types:\n" + |
| " J [in X.java [in <default> [in src [in Bug430141]]]]\n" + |
| " <lambda #1> [in main(String[]) [in X [in X.java [in <default> [in src [in Bug430141]]]]]]\n", |
| h); |
| } |
| finally { |
| deleteProject("Bug430141"); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=430141, [1.8][hierarchy] Incorrect hierarchy with lambda elements missing |
| public void test430141a() throws Exception { |
| try { |
| IJavaProject project = createJavaProject("Bug430141", new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface I {\n" + |
| " void doit();\n" + |
| "}\n" + |
| "interface J extends I {\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " J j = () -> { System.out.println(\"Lambda\"); };\n" + |
| " j.doit();\n" + |
| " }\n" + |
| "}\n"; |
| createFile( "/Bug430141/src/X.java", fileContent); |
| IType type = getCompilationUnit("/Bug430141/src/X.java").getType("J"); |
| ITypeHierarchy h = type.newTypeHierarchy(null); |
| assertHierarchyEquals( |
| "Focus: J [in X.java [in <default> [in src [in Bug430141]]]]\n" + |
| "Super types:\n" + |
| " I [in X.java [in <default> [in src [in Bug430141]]]]\n" + |
| "Sub types:\n" + |
| " <lambda #1> [in main(String[]) [in X [in X.java [in <default> [in src [in Bug430141]]]]]]\n", |
| h); |
| } |
| finally { |
| deleteProject("Bug430141"); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=430136 |
| public void test430136() throws CoreException { |
| String projectName = "([Bug430136])"; |
| try { |
| IJavaProject project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface MyFunction<T, R> {\n" + |
| " R apply(T t);\n" + |
| " default <V> MyFunction<V, R> compose(MyFunction<? super V, ? extends T> before) {\n" + |
| " return v -> apply(before.apply(v));\n" + |
| " }\n" + |
| "}\n"; |
| String fileName = "/" + projectName + "/src/X.java"; |
| createFile(fileName, fileContent); |
| |
| ICompilationUnit unit = getCompilationUnit(fileName); |
| int start = fileContent.indexOf("v"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertEquals("Incorrect java element", IJavaElement.LOCAL_VARIABLE, elements[0].getElementType()); |
| IType lambda = (IType) elements[0].getParent().getParent(); |
| String mem = lambda.getHandleIdentifier(); |
| String expected = "=\\(\\[Bug430136\\])/src<{X.java[MyFunction~compose~QMyFunction\\<-QV;+QT;>;=)=\"LMyFunction\\<TV;TR;>;!148!174!151=&apply!1=\"TV;=\"v=\"TR;=\"LX\\~MyFunction\\<LX\\~MyFunction;:1TV;LX\\~MyFunction;:TR;>;.apply\\(TV;)TR;@v!148!148!148!148!Ljava\\/lang\\/Object;!0!true=)"; |
| assertEquals("Incorrect memento", expected, mem); |
| IJavaElement result = JavaCore.create(expected); |
| assertEquals("Incorrect element created", lambda, result); |
| } |
| finally { |
| deleteProject(projectName); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=431716 |
| public void test431716() throws CoreException { |
| String projectName = "Bug431716"; |
| try { |
| IJavaProject project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "public interface X<T> {\n" + |
| " default void asIntStream() {\n" + |
| " mapToInt((long l) -> (int) l);" + |
| " }\n" + |
| " default void mapToInt(ToIntFunction<? super T> mapper) {}\n" + |
| "interface ToIntFunction<T> {\n" + |
| " int applyAsInt(T value);\n" + |
| "}\n"; |
| String fileName = "/" + projectName + "/src/X.java"; |
| createFile(fileName, fileContent); |
| |
| ICompilationUnit unit = getCompilationUnit(fileName); |
| int start = fileContent.indexOf("l)"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertEquals("Incorrect java element", IJavaElement.LOCAL_VARIABLE, elements[0].getElementType()); |
| String mem = elements[0].getHandleIdentifier(); |
| String expected = "=Bug431716/src<{X.java[X~asIntStream" + |
| "=)=\"LX$ToIntFunction\\<TT;>;!71!89!81=&" + |
| "applyAsInt!1=\"TT;=\"l=\"I=\"LX$ToIntFunction\\<LX;:TT;>;." + |
| "applyAsInt\\(TT;)I@l!72!77!77!77!Ljava\\/lang\\/Object;!0!true=&" + |
| "@l!72!77!77!77!J!0!true"; |
| assertEquals("Incorrect memento", expected, mem); |
| |
| IJavaElement parent = elements[0].getParent(); |
| mem = parent.getHandleIdentifier(); |
| expected = "=Bug431716/src<{X.java[X~asIntStream" + |
| "=)=\"LX$ToIntFunction\\<TT;>;!71!89!81=&" + |
| "applyAsInt!1=\"TT;=\"l=\"I=\"LX$ToIntFunction\\<LX;:TT;>;." + |
| "applyAsInt\\(TT;)I@l!72!77!77!77!Ljava\\/lang\\/Object;!0!true=&"; |
| assertEquals("Incorrect memento", expected, mem); |
| assertTrue("Parent should be LambdaMethod", parent instanceof LambdaMethod); |
| |
| parent = parent.getParent(); |
| mem = parent.getHandleIdentifier(); |
| expected = "=Bug431716/src<{X.java[X~asIntStream" + |
| "=)=\"LX$ToIntFunction\\<TT;>;!71!89!81=&" + |
| "applyAsInt!1=\"TT;=\"l=\"I=\"LX$ToIntFunction\\<LX;:TT;>;." + |
| "applyAsInt\\(TT;)I@l!72!77!77!77!Ljava\\/lang\\/Object;!0!true=)"; |
| assertEquals("Incorrect memento", expected, mem); |
| assertTrue("Grand-parent should be LambdaExpression", parent instanceof LambdaExpression); |
| |
| parent = parent.getParent(); |
| mem = parent.getHandleIdentifier(); |
| expected = "=Bug431716/src<{X.java[X~asIntStream"; |
| assertEquals("Incorrect memento", expected, mem); |
| assertTrue("Great-grand-parent should be SourceMethod", parent instanceof SourceMethod); |
| } |
| finally { |
| deleteProject(projectName); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=430195 |
| public void test430195() throws CoreException { |
| String projectName = "Bug430195"; |
| try { |
| IJavaProject project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| String fileContent = |
| "interface MyFunction<T, R> {\n" + |
| " R apply(T t);\n" + |
| " default <V> MyFunction<V, R> compose(MyFunction<? super V, ? extends T> before) {\n" + |
| " return v -> apply(before.apply(v));\n" + |
| " }\n" + |
| "}\n"; |
| String fileName = "/" + projectName + "/src/X.java"; |
| createFile(fileName, fileContent); |
| |
| ICompilationUnit unit = getCompilationUnit(fileName); |
| int start = fileContent.indexOf("v"); |
| IJavaElement[] elements = unit.codeSelect(start, 1); |
| assertEquals("Incorrect java element", IJavaElement.LOCAL_VARIABLE, elements[0].getElementType()); |
| IType lambda = (IType) elements[0].getParent().getParent(); |
| assertEquals("Incorrect qualified type name", "MyFunction$1", lambda.getTypeQualifiedName()); |
| } |
| finally { |
| deleteProject(projectName); |
| } |
| } |
| |
| public void testBug485080() throws Exception { |
| String projectName = "Bug485080"; |
| try { |
| IJavaProject project = createJavaProject(projectName, new String[] {"src"}, new String[] {"JCL18_LIB"}, "bin", "1.8"); |
| project.open(null); |
| |
| // create a .java file in a folder that's not on the build path: |
| IFolder folder= project.getProject().getFolder("nosrc"); |
| folder.create(0, true, null); |
| IFile file= folder.getFile("X.java"); |
| StringBuilder buf= new StringBuilder(); |
| buf.append("public class X {\n"); |
| buf.append(" public <T> void meth(T s) {\n"); |
| buf.append(" }\n"); |
| buf.append("}\n"); |
| String content= buf.toString(); |
| file.create(new ByteArrayInputStream(content.getBytes("UTF-8")), 0, null); |
| |
| // create a CU from that file: |
| ICompilationUnit cu = JavaCore.createCompilationUnitFrom(file); |
| cu.becomeWorkingCopy(null); |
| |
| // create the binding for the CU's main type, and drill down to details: |
| ASTParser parser= ASTParser.newParser(getJSL9()); |
| parser.setProject(project); |
| IBinding[] bindings = parser.createBindings(new IJavaElement[] { cu.findPrimaryType() }, null); |
| IMethodBinding methodBinding= ((ITypeBinding) bindings[0]).getDeclaredMethods()[1]; |
| assertEquals("method name", "meth", methodBinding.getName()); |
| ITypeBinding typeParameter = methodBinding.getTypeParameters()[0]; |
| |
| // fetch and inspect the corresponding java element: |
| IJavaElement javaElement = typeParameter.getJavaElement(); |
| assertNotNull("java element", javaElement); |
| assertEquals("element kind", IJavaElement.TYPE_PARAMETER, javaElement.getElementType()); |
| assertEquals("element name", "T", javaElement.getElementName()); |
| } finally { |
| deleteProject(projectName); |
| } |
| } |
| } |
