Merge branch 'master' into BETA_JAVA9
Conflicts:
org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors.jar
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/APTProblem.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/APTProblem.java
index 1eb5b18..ac7043b 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/APTProblem.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/APTProblem.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2005, 2008 BEA Systems, Inc.
+ * Copyright (c) 2005, 2015 BEA Systems, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -101,6 +101,10 @@
public boolean isWarning() {
return _severity == Severity.WARNING;
}
+
+ public boolean isInfo() {
+ return _severity == Severity.INFO;
+ }
public String toString()
{
diff --git a/org.eclipse.jdt.apt.pluggable.core/src/org/eclipse/jdt/internal/apt/pluggable/core/dispatch/IdeAnnotationProcessorManager.java b/org.eclipse.jdt.apt.pluggable.core/src/org/eclipse/jdt/internal/apt/pluggable/core/dispatch/IdeAnnotationProcessorManager.java
index a640b71..12cfc0c 100644
--- a/org.eclipse.jdt.apt.pluggable.core/src/org/eclipse/jdt/internal/apt/pluggable/core/dispatch/IdeAnnotationProcessorManager.java
+++ b/org.eclipse.jdt.apt.pluggable.core/src/org/eclipse/jdt/internal/apt/pluggable/core/dispatch/IdeAnnotationProcessorManager.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2007 BEA Systems, Inc.
+ * Copyright (c) 2007, 2015 BEA Systems, Inc and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -7,6 +7,7 @@
*
* Contributors:
* wharley@bea.com - initial API and implementation
+ * IBM Corporation - Bug 478427
*
*******************************************************************************/
@@ -97,7 +98,7 @@
}
_processors.add(pi);
return pi;
- } catch (CoreException e) {
+ } catch (CoreException | NoClassDefFoundError e) {
Apt6Plugin.log(e, "Unable to create instance of annotation processor " + entry.getKey()); //$NON-NLS-1$
}
}
diff --git a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors.jar b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors.jar
index 9faff6b..e97fd1d 100644
--- a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors.jar
+++ b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors.jar
Binary files differ
diff --git a/org.eclipse.jdt.compiler.apt.tests/processors/org/eclipse/jdt/compiler/apt/tests/processors/typeutils/TypeUtilsProc.java b/org.eclipse.jdt.compiler.apt.tests/processors/org/eclipse/jdt/compiler/apt/tests/processors/typeutils/TypeUtilsProc.java
index 73130a8..b0b4a36 100644
--- a/org.eclipse.jdt.compiler.apt.tests/processors/org/eclipse/jdt/compiler/apt/tests/processors/typeutils/TypeUtilsProc.java
+++ b/org.eclipse.jdt.compiler.apt.tests/processors/org/eclipse/jdt/compiler/apt/tests/processors/typeutils/TypeUtilsProc.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2007 - 2012 BEA Systems, Inc. and others
+ * Copyright (c) 2007 - 2015 BEA Systems, Inc. and others
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -7,6 +7,7 @@
*
* Contributors:
* Walter Harley - initial API and implementation
+ * IBM Corporation - Bug 382590
*******************************************************************************/
package org.eclipse.jdt.compiler.apt.tests.processors.typeutils;
@@ -405,10 +406,6 @@
return false;
}
ExecutableType etm = (ExecutableType)tm;
- if (!etm.getParameterTypes().isEmpty()) {
- reportError(method + ": member m() should be void, but it had parameters");
- return false;
- }
if (!_typeUtils.isSameType(etm.getReturnType(), longType)) {
reportError(method + ": member m() should have Long return type, but found " + etm.getReturnType());
return false;
diff --git a/org.eclipse.jdt.compiler.apt.tests/resources/targets/model/pc/AsMemberOf.java b/org.eclipse.jdt.compiler.apt.tests/resources/targets/model/pc/AsMemberOf.java
index 5df21e7..473887c 100644
--- a/org.eclipse.jdt.compiler.apt.tests/resources/targets/model/pc/AsMemberOf.java
+++ b/org.eclipse.jdt.compiler.apt.tests/resources/targets/model/pc/AsMemberOf.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2012 Walter Harley and others
+ * Copyright (c) 2015 Walter Harley and others
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -15,7 +15,7 @@
*/
public class AsMemberOf<T> {
private T f;
- private T m() { return f; }
+ protected T m(T[] t1, T t2) { return f; }
E<Integer> e = new E<Integer>();
// Type parameter 'T' of static class is unrelated to 'T' of containing class
@@ -39,7 +39,7 @@
// even when accesed through a subclass; this is not explicitly specified, but
// is true for javac 1.6.
T publicize() {
- return (m() == null) ? new C<T>().x() : new D().x();
+ return (m(null, null) == null) ? new C<T>().x() : new D().x();
}
}
diff --git a/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java b/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
index dabeb0e..820a899 100644
--- a/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
+++ b/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
@@ -7,7 +7,7 @@
*
* Contributors:
* Walter Harley - initial API and implementation
- * IBM Corporation - fix for 342598
+ * IBM Corporation - fix for 342598, 382590
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.apt.model;
@@ -85,8 +85,8 @@
MethodBinding methodBinding = (MethodBinding) elementImpl._binding;
while (referenceBinding != null) {
for (MethodBinding method : referenceBinding.methods()) {
- if (CharOperation.equals(method.selector, methodBinding.selector)
- && method.areParameterErasuresEqual(methodBinding)) {
+ if (CharOperation.equals(method.selector, methodBinding.selector) &&
+ (method.original() == methodBinding || method.areParameterErasuresEqual(methodBinding))) {
return this._env.getFactory().newTypeMirror(method);
}
}
diff --git a/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java b/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java
index 3ebc172..3da8163 100644
--- a/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java
+++ b/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java
@@ -69,6 +69,7 @@
public int getSourceLineNumber() { return 1; }
public boolean isError() { return true; }
public boolean isWarning() { return false; }
+ public boolean isInfo() { return false; }
public void setSourceEnd(int sourceEnd) {/* not needed */}
public void setSourceLineNumber(int lineNumber) {/* not needed */}
public void setSourceStart(int sourceStart) {/* not needed */}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractRegressionTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractRegressionTest.java
index 69a4f05..f7501d8 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractRegressionTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractRegressionTest.java
@@ -103,14 +103,6 @@
long compliance;
public static final long EXIT_VALUE_MASK = 0x00000000FFFFFFFFL;
public static final long ERROR_LOG_MASK = 0xFFFFFFFF00000000L;
- private static final String[] jarsNames = new String[] {
- "/lib/vm.jar",
- "/lib/rt.jar",
- "/lib/core.jar",
- "/lib/security.jar",
- "/lib/xml.jar",
- "/lib/graphics.jar"
- };
private String classpath;
JavacCompiler(String rootDirectoryPath) throws IOException, InterruptedException {
this(rootDirectoryPath, null);
@@ -163,11 +155,6 @@
this.minor = minorFromRawVersion(this.version, rawVersion);
this.rawVersion = rawVersion;
StringBuffer classpathBuffer = new StringBuffer(" -classpath ");
- for (int i = 0, l = jarsNames.length; i < l; i++) {
- classpathBuffer.append(rootDirectoryPath);
- classpathBuffer.append(jarsNames[i]);
- classpathBuffer.append(File.pathSeparator);
- }
this.classpath = classpathBuffer.toString();
}
// projects known raw versions to minors; minors should grow with time, so
@@ -206,6 +193,12 @@
if ("1.8.0-ea".equals(rawVersion) || ("1.8.0".equals(rawVersion))) {
return 0000;
}
+ if ("1.8.0_40".equals(rawVersion)) {
+ return 1000; // corresponds to JLS maintenance release 2015-02-13
+ }
+ if ("1.8.0_60".equals(rawVersion)) {
+ return 1500;
+ }
}
throw new RuntimeException("unknown raw javac version: " + rawVersion);
}
@@ -1734,6 +1727,9 @@
if (newOptions.indexOf(" -d ") < 0) {
options.setCompilerOptions(newOptions.concat(" -d ."));
}
+ if (newOptions.indexOf(" -Xlint") < 0) {
+ options.setCompilerOptions(newOptions.concat(" -Xlint"));
+ }
String testName = testName();
Iterator compilers = javacCompilers.iterator();
while (compilers.hasNext()) {
@@ -3011,7 +3007,7 @@
version = version.substring(0, eol);
cmdLineHeader.append(" -d ");
cmdLineHeader.append(JAVAC_OUTPUT_DIR_NAME.indexOf(" ") != -1 ? "\"" + JAVAC_OUTPUT_DIR_NAME + "\"" : JAVAC_OUTPUT_DIR_NAME);
- cmdLineHeader.append(" -source 1.5 -deprecation -Xlint:unchecked "); // enable recommended warnings
+ cmdLineHeader.append(" -source 1.5 -deprecation -Xlint "); // enable recommended warnings
// WORK new javac system does not do that... reconsider
// REVIEW consider enabling all warnings instead? Philippe does not see
// this as ez to use (too many changes in logs)
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AnnotationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AnnotationTest.java
index 2bdac0c..2efbb3e 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AnnotationTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AnnotationTest.java
@@ -11480,4 +11480,174 @@
"Type mismatch: cannot convert from RetentionPolicy[] to RetentionPolicy\n" +
"----------\n");
}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=472178
+public void test472178() throws Exception {
+ if (this.complianceLevel < ClassFileConstants.JDK1_8) {
+ return; // Enough to run in 3 levels rather!
+ }
+ String source =
+ "import java.lang.annotation.ElementType;\n" +
+ "import java.lang.annotation.Retention;\n" +
+ "import java.lang.annotation.RetentionPolicy;\n" +
+ "import java.lang.annotation.Target;\n" +
+ "import java.util.ArrayList;\n" +
+ "import java.util.Iterator;\n" +
+ " \n" +
+ "/**\n" +
+ " * @author gglab\n" +
+ " */\n" +
+ "public class Test<X> extends ArrayList<X> {\n" +
+ " public void iterateRemove()\n" +
+ " {\n" +
+ " for (Iterator<X> iter = this.iterator(); iter.hasNext();) {\n" +
+ " Object key = iter.next();\n" +
+ " @Flowannotation\n" +
+ " Foo<@Flowannotation String> f = new Foo<String>();\n" +
+ " @Flowannotation long l = (@Flowannotation long)f.getI(); // this line causes parse error\n" +
+ " iter.remove();\n" +
+ " }\n" +
+ " }\n" +
+ " \n" +
+ " @Flowannotation\n" +
+ " class Foo<@Flowannotation T>\n" +
+ " {\n" +
+ " @Flowannotation\n" +
+ " public int getI()\n" +
+ " {\n" +
+ " return 3;\n" +
+ " }\n" +
+ " }\n" +
+ " \n" +
+ " @Target({ ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.METHOD, ElementType.LOCAL_VARIABLE, ElementType.TYPE, ElementType.FIELD,\n" +
+ " ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})\n" +
+ " @Retention(RetentionPolicy.RUNTIME)\n" +
+ " @interface Flowannotation {}\n" +
+ " public static void main(String[] args) {}\n" +
+ "}";
+ String expectedOutput =
+ " // Method descriptor #6 ()V\n" +
+ " // Stack: 3, Locals: 6\n" +
+ " public void iterateRemove();\n" +
+ " 0 aload_0 [this]\n" +
+ " 1 invokevirtual Test.iterator() : Iterator [17]\n" +
+ " 4 astore_1 [iter]\n" +
+ " 5 goto 37\n" +
+ " 8 aload_1 [iter]\n" +
+ " 9 invokeinterface Iterator.next() : Object [21] [nargs: 1]\n" +
+ " 14 astore_2 [key]\n" +
+ " 15 new Test$Foo [27]\n" +
+ " 18 dup\n" +
+ " 19 aload_0 [this]\n" +
+ " 20 invokespecial Test$Foo(Test) [29]\n" +
+ " 23 astore_3 [f]\n" +
+ " 24 aload_3 [f]\n" +
+ " 25 invokevirtual Test$Foo.getI() : int [32]\n" +
+ " 28 i2l\n" +
+ " 29 lstore 4 [l]\n" +
+ " 31 aload_1 [iter]\n" +
+ " 32 invokeinterface Iterator.remove() : void [36] [nargs: 1]\n" +
+ " 37 aload_1 [iter]\n" +
+ " 38 invokeinterface Iterator.hasNext() : boolean [39] [nargs: 1]\n" +
+ " 43 ifne 8\n" +
+ " 46 return\n" +
+ " Line numbers:\n" +
+ " [pc: 0, line: 14]\n" +
+ " [pc: 8, line: 15]\n" +
+ " [pc: 15, line: 17]\n" +
+ " [pc: 24, line: 18]\n" +
+ " [pc: 31, line: 19]\n" +
+ " [pc: 37, line: 14]\n" +
+ " [pc: 46, line: 21]\n" +
+ " Local variable table:\n" +
+ " [pc: 0, pc: 47] local: this index: 0 type: Test\n" +
+ " [pc: 5, pc: 46] local: iter index: 1 type: Iterator\n" +
+ " [pc: 15, pc: 37] local: key index: 2 type: Object\n" +
+ " [pc: 24, pc: 37] local: f index: 3 type: Foo\n" +
+ " [pc: 31, pc: 37] local: l index: 4 type: long\n" +
+ " Local variable type table:\n" +
+ " [pc: 0, pc: 47] local: this index: 0 type: Test<X>\n" +
+ " [pc: 5, pc: 46] local: iter index: 1 type: Iterator<X>\n" +
+ " [pc: 24, pc: 37] local: f index: 3 type: String>\n" +
+ " Stack map table: number of frames 2\n" +
+ " [pc: 8, append: {Iterator}]\n" +
+ " [pc: 37, same]\n" +
+ " RuntimeVisibleTypeAnnotations: \n" +
+ " #55 @Flowannotation(\n" +
+ " target type = 0x47 CAST\n" +
+ " offset = 24\n" +
+ " type argument index = 0\n" +
+ " )\n" +
+ " #55 @Flowannotation(\n" +
+ " target type = 0x40 LOCAL_VARIABLE\n" +
+ " local variable entries:\n" +
+ " [pc: 24, pc: 37] index: 3\n" +
+ " location = [INNER_TYPE]\n" +
+ " )\n" +
+ " #55 @Flowannotation(\n" +
+ " target type = 0x40 LOCAL_VARIABLE\n" +
+ " local variable entries:\n" +
+ " [pc: 24, pc: 37] index: 3\n" +
+ " location = [INNER_TYPE, TYPE_ARGUMENT(0)]\n" +
+ " )\n" +
+ " #55 @Flowannotation(\n" +
+ " target type = 0x40 LOCAL_VARIABLE\n" +
+ " local variable entries:\n" +
+ " [pc: 31, pc: 37] index: 4\n" +
+ " )\n";
+ checkClassFile("Test", source, expectedOutput, ClassFileBytesDisassembler.DETAILED | ClassFileBytesDisassembler.COMPACT);
+}
+//https://bugs.eclipse.org/bugs/show_bug.cgi?id=470665
+public void testBug470665() throws Exception {
+ if (this.complianceLevel <= ClassFileConstants.JDK1_7) {
+ return; // Enough to run in the last two levels!
+ }
+ boolean apt = this.enableAPT;
+ String[] sources = new String[] {
+ "A.java",
+ "public final class A {\n" +
+ " String myString;\n" +
+ " public interface B {\n" +
+ " void test();\n" +
+ " }\n" +
+ " private final B b = new B() {\n" +
+ " @Override\n" +
+ " public void test() {}\n" +
+ " }\n" +
+ "};\n" +
+ "}",
+ "B.java",
+ "public class B {\n" +
+ " private static class X {\n" +
+ " static final Object instance1;\n" +
+ " static {\n" +
+ " try {\n" +
+ " instance1 = new Object();\n" +
+ " } catch (Throwable e) {\n" +
+ " throw new AssertionError(e);\n" +
+ " }\n" +
+ " }\n" +
+ " }\n" +
+ " X x = new X();\n" +
+ " Object o = X.instance1;\n" +
+ "}"
+ };
+ try {
+ this.enableAPT = true;
+ runNegativeTest(sources,
+ "----------\n" +
+ "1. ERROR in A.java (at line 10)\n" +
+ " };\n" +
+ " ^\n" +
+ "Syntax error on token \"}\", delete this token\n" +
+ "----------\n" +
+ "----------\n" +
+ "1. WARNING in B.java (at line 12)\n" +
+ " X x = new X();\n" +
+ " ^^^^^^^\n" +
+ "Access to enclosing constructor B.X() is emulated by a synthetic accessor method\n" +
+ "----------\n");
+ } finally {
+ this.enableAPT = apt;
+ }
+}
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FieldAccessTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FieldAccessTest.java
index d8afbee..6953309 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FieldAccessTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FieldAccessTest.java
@@ -14,6 +14,7 @@
import junit.framework.Test;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
@SuppressWarnings({ "unchecked", "rawtypes" })
@@ -769,6 +770,26 @@
"The field B.field is hiding a field from type Interface\n" +
"----------\n");
}
+public void testBug361039() {
+ if (this.complianceLevel < ClassFileConstants.JDK1_5) return; // to leverage autounboxing
+ runNegativeTest(
+ new String[] {
+ "Bug361039.java",
+ "public class Bug361039 {\n" +
+ " public Bug361039(boolean b) {\n" +
+ " }\n" +
+ " private Object foo() {\n" +
+ " return new Bug361039(!((Boolean)this.f));\n" +
+ " }\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in Bug361039.java (at line 5)\n" +
+ " return new Bug361039(!((Boolean)this.f));\n" +
+ " ^\n" +
+ "f cannot be resolved or is not a field\n" +
+ "----------\n");
+}
public static Class testClass() {
return FieldAccessTest.class;
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java
index 60fbfd6..c230094 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java
@@ -16827,7 +16827,9 @@
"6. WARNING in X.java (at line 10)\n" +
" EnumSet<Enum> eSet = EnumSet.allOf(c);\n" +
" ^\n" +
- "Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum>\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ? "Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum>\n"
+ : "Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum<Enum<E>>>\n") +
"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=86838 - variation
@@ -32091,7 +32093,9 @@
"5. WARNING in X.java (at line 7)\n" +
" Comparable c = newInstance2(x);\n" +
" ^\n" +
- "Type safety: The expression of type X needs unchecked conversion to conform to X<Comparable>\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ? "Type safety: The expression of type X needs unchecked conversion to conform to X<Comparable>\n"
+ : "Type safety: The expression of type X needs unchecked conversion to conform to X<Comparable<Comparable<B>>>\n") +
"----------\n" +
"6. ERROR in X.java (at line 9)\n" +
" Zork z;\n" +
@@ -33467,7 +33471,9 @@
"4. WARNING in X.java (at line 9)\n" +
" Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: The expression of type Iterator[] needs unchecked conversion to conform to Iterator<Number>[]\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ? "Type safety: The expression of type Iterator[] needs unchecked conversion to conform to Iterator<Number>[]\n"
+ : "Type safety: The expression of type Iterator[] needs unchecked conversion to conform to Iterator<Object>[]\n") +
"----------\n" +
"5. ERROR in X.java (at line 14)\n" +
" Iterator<Number> it2 = X.chain(l1.iterator(), l2.iterator());\n" +
@@ -33605,7 +33611,7 @@
"4. WARNING in X.java (at line 9)\n" +
" Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: The expression of type Iterator[] needs unchecked conversion to conform to Iterator<? extends Number>[]\n" +
+ "Type safety: The expression of type Iterator[] needs unchecked conversion to conform to Iterator<? extends Object>[]\n" +
"----------\n" +
"5. WARNING in X.java (at line 14)\n" +
" Iterator<Number> it2 = X.chain(l1.iterator(), l2.iterator());\n" +
@@ -50350,10 +50356,23 @@
" ^^^^^^^^^^^\n" +
"Type safety: Unchecked invocation foo(List, IllegalArgumentException) of the generic method foo(List<U>, T) of type X\n" +
"----------\n" +
- "3. WARNING in X.java (at line 8)\n" +
- " foo(l, iae);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ?
+ "3. WARNING in X.java (at line 8)\n" +
+ " foo(l, iae);\n" +
+ " ^\n" +
+ "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n"
+ :
+ "3. ERROR in X.java (at line 8)\n" +
+ " foo(l, iae);\n" +
+ " ^^^^^^^^^^^\n" +
+ "Unhandled exception type Throwable\n" + // new error since 1.8 (bug 473657)
+ "----------\n" +
+ "4. WARNING in X.java (at line 8)\n" +
+ " foo(l, iae);\n" +
+ " ^\n" +
+ "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n"
+ ) +
"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
@@ -50385,10 +50404,23 @@
" ^^^^^^^^^^^^^\n" +
"Type safety: Unchecked invocation X(List, IllegalArgumentException) of the generic constructor X(List<U>, T) of type X\n" +
"----------\n" +
- "3. WARNING in X.java (at line 8)\n" +
- " new X(l, iae);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ?
+ "3. WARNING in X.java (at line 8)\n" +
+ " new X(l, iae);\n" +
+ " ^\n" +
+ "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n"
+ :
+ "3. ERROR in X.java (at line 8)\n" +
+ " new X(l, iae);\n" +
+ " ^^^^^^^^^^^^^\n" +
+ "Unhandled exception type Throwable\n" + // new error since 1.8 (bug 473657)
+ "----------\n" +
+ "4. WARNING in X.java (at line 8)\n" +
+ " new X(l, iae);\n" +
+ " ^\n" +
+ "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n"
+ ) +
"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
@@ -50420,10 +50452,23 @@
" ^^^^^^^^^^^^^^^\n" +
"Type safety: Unchecked invocation X(List, IllegalArgumentException) of the generic constructor X(List<U>, T) of type X\n" +
"----------\n" +
- "3. WARNING in X.java (at line 8)\n" +
- " new X(l, iae){};\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ?
+ "3. WARNING in X.java (at line 8)\n" +
+ " new X(l, iae){};\n" +
+ " ^\n" +
+ "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n"
+ :
+ "3. ERROR in X.java (at line 8)\n" +
+ " new X(l, iae){};\n" +
+ " ^^^^^^^^^^^^^^^\n" +
+ "Unhandled exception type Throwable\n" + // new error since 1.8 (bug 473657)
+ "----------\n" +
+ "4. WARNING in X.java (at line 8)\n" +
+ " new X(l, iae){};\n" +
+ " ^\n" +
+ "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n"
+ ) +
"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
@@ -50446,7 +50491,6 @@
" }\n" +
"}\n",//-----------------------------------------------------------------------
},
- (this.complianceLevel < ClassFileConstants.JDK1_8 ?
"----------\n" +
"1. WARNING in X.java (at line 7)\n" +
" this((List) null, null);\n" +
@@ -50487,44 +50531,7 @@
" super((List)lu, t);\n" +
" ^^^^\n" +
"List is a raw type. References to generic type List<E> should be parameterized\n" +
- "----------\n"
- : // 1.8 infers T in this((List) null, null) to RuntimeException, hence no error here (2. above)
- "----------\n" +
- "1. WARNING in X.java (at line 7)\n" +
- " this((List) null, null);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation X(List, null) of the generic constructor X(List<U>, T) of type X\n" +
- "----------\n" +
- "2. WARNING in X.java (at line 7)\n" +
- " this((List) null, null);\n" +
- " ^^^^^^^^^^^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" +
- "----------\n" +
- "3. WARNING in X.java (at line 7)\n" +
- " this((List) null, null);\n" +
- " ^^^^\n" +
- "List is a raw type. References to generic type List<E> should be parameterized\n" +
- "----------\n" +
- "4. WARNING in X.java (at line 12)\n" +
- " super((List)lu, t);\n" +
- " ^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation X(List, T) of the generic constructor X(List<U>, T) of type X\n" +
- "----------\n" +
- "5. ERROR in X.java (at line 12)\n" +
- " super((List)lu, t);\n" +
- " ^^^^^^^^^^^^^^^^^^^\n" +
- "Unhandled exception type Throwable\n" +
- "----------\n" +
- "6. WARNING in X.java (at line 12)\n" +
- " super((List)lu, t);\n" +
- " ^^^^^^^^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" +
- "----------\n" +
- "7. WARNING in X.java (at line 12)\n" +
- " super((List)lu, t);\n" +
- " ^^^^\n" +
- "List is a raw type. References to generic type List<E> should be parameterized\n" +
- "----------\n"));
+ "----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=260567
public void test1440() {
@@ -50762,7 +50769,6 @@
"\n" +
"}\n",
},
- (this.complianceLevel < ClassFileConstants.JDK1_8 ?
"----------\n" +
"1. WARNING in X.java (at line 8)\n" +
" static void bar(List l) {\n" +
@@ -50792,12 +50798,16 @@
"6. WARNING in X.java (at line 9)\n" +
" new X(l).foo(l);\n" +
" ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<Throwable>\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ? "Type safety: The expression of type List needs unchecked conversion to conform to List<Throwable>\n"
+ : "Type safety: The expression of type List needs unchecked conversion to conform to List<RuntimeException>\n" ) +
"----------\n" +
"7. WARNING in X.java (at line 9)\n" +
" new X(l).foo(l);\n" +
" ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<Throwable>\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ? "Type safety: The expression of type List needs unchecked conversion to conform to List<Throwable>\n"
+ : "Type safety: The expression of type List needs unchecked conversion to conform to List<RuntimeException>\n" ) +
"----------\n" +
"8. WARNING in X.java (at line 11)\n" +
" static void baz(List l) throws IOException {\n" +
@@ -50863,100 +50873,7 @@
" new <IOException> X(l){}. <IOException> foo(l);\n" +
" ^\n" +
"Type safety: The expression of type List needs unchecked conversion to conform to List<IOException>\n" +
- "----------\n"
- : // 1.8 infers type parameters in throws clauses to RuntimeException, hence no errors
- "----------\n" +
- "1. WARNING in X.java (at line 8)\n" +
- " static void bar(List l) {\n" +
- " ^^^^\n" +
- "List is a raw type. References to generic type List<E> should be parameterized\n" +
- "----------\n" +
- "2. WARNING in X.java (at line 9)\n" +
- " new X(l).foo(l);\n" +
- " ^^^^^^^^\n" +
- "Type safety: Unchecked invocation X(List) of the generic constructor X(List<T>) of type X\n" +
- "----------\n" +
- "3. WARNING in X.java (at line 9)\n" +
- " new X(l).foo(l);\n" +
- " ^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation foo(List) of the generic method foo(List<T>) of type X\n" +
- "----------\n" +
- "4. WARNING in X.java (at line 9)\n" +
- " new X(l).foo(l);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<RuntimeException>\n" +
- "----------\n" +
- "5. WARNING in X.java (at line 9)\n" +
- " new X(l).foo(l);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<RuntimeException>\n" +
- "----------\n" +
- "6. WARNING in X.java (at line 11)\n" +
- " static void baz(List l) throws IOException {\n" +
- " ^^^^\n" +
- "List is a raw type. References to generic type List<E> should be parameterized\n" +
- "----------\n" +
- "7. WARNING in X.java (at line 12)\n" +
- " new <IOException> X(l). <IOException> foo(l);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation X(List) of the generic constructor X(List<T>) of type X\n" +
- "----------\n" +
- "8. WARNING in X.java (at line 12)\n" +
- " new <IOException> X(l). <IOException> foo(l);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation foo(List) of the generic method foo(List<T>) of type X\n" +
- "----------\n" +
- "9. WARNING in X.java (at line 12)\n" +
- " new <IOException> X(l). <IOException> foo(l);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<IOException>\n" +
- "----------\n" +
- "10. WARNING in X.java (at line 12)\n" +
- " new <IOException> X(l). <IOException> foo(l);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<IOException>\n" +
- "----------\n" +
- "11. WARNING in X.java (at line 15)\n" +
- " X(List l, long l2) throws IOException {\n" +
- " ^^^^\n" +
- "List is a raw type. References to generic type List<E> should be parameterized\n" +
- "----------\n" +
- "12. WARNING in X.java (at line 16)\n" +
- " <IOException> this(l);\n" +
- " ^^^^^^^^\n" +
- "Type safety: Unchecked invocation X(List) of the generic constructor X(List<T>) of type X\n" +
- "----------\n" +
- "13. WARNING in X.java (at line 16)\n" +
- " <IOException> this(l);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<IOException>\n" +
- "----------\n" +
- "14. WARNING in X.java (at line 19)\n" +
- " static void baz2(List l) throws IOException {\n" +
- " ^^^^\n" +
- "List is a raw type. References to generic type List<E> should be parameterized\n" +
- "----------\n" +
- "15. WARNING in X.java (at line 20)\n" +
- " new <IOException> X(l){}. <IOException> foo(l);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation X(List) of the generic constructor X(List<T>) of type X\n" +
- "----------\n" +
- "16. WARNING in X.java (at line 20)\n" +
- " new <IOException> X(l){}. <IOException> foo(l);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation foo(List) of the generic method foo(List<T>) of type X\n" +
- "----------\n" +
- "17. WARNING in X.java (at line 20)\n" +
- " new <IOException> X(l){}. <IOException> foo(l);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<IOException>\n" +
- "----------\n" +
- "18. WARNING in X.java (at line 20)\n" +
- " new <IOException> X(l){}. <IOException> foo(l);\n" +
- " ^\n" +
- "Type safety: The expression of type List needs unchecked conversion to conform to List<IOException>\n" +
- "----------\n"
- ));
+ "----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=202393
public void test1446() {
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest.java
index 30c5d06..3f85381 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest.java
@@ -5453,7 +5453,7 @@
"The method addUnique(Map.Entry) in the type EcoreEMap is not applicable for the arguments (Object)\n" +
"----------\n");
}
-public void testBug453253() {
+public void testBug454644() {
runNegativeTest(
new String[] {
"example/CollectionFactory.java",
@@ -5561,71 +5561,45 @@
"\n" +
"}\n"
},
- (this.complianceLevel < ClassFileConstants.JDK1_8 ?
- "----------\n" +
- "1. WARNING in example\\CollectionFactory.java (at line 42)\n" +
- " @SuppressWarnings({ \"unchecked\", \"cast\" })\n" +
- " ^^^^^^\n" +
- "Unnecessary @SuppressWarnings(\"cast\")\n" +
- "----------\n" +
- "2. WARNING in example\\CollectionFactory.java (at line 55)\n" +
- " return EnumSet.copyOf((EnumSet) collection);\n" +
- " ^^^^^^^\n" +
- "EnumSet is a raw type. References to generic type EnumSet<E> should be parameterized\n" +
- "----------\n" +
- "3. WARNING in example\\CollectionFactory.java (at line 87)\n" +
- " return EnumSet.noneOf((Class) elementType);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked invocation noneOf(Class) of the generic method noneOf(Class<E>) of type EnumSet\n" +
- "----------\n" +
- "4. WARNING in example\\CollectionFactory.java (at line 87)\n" +
- " return EnumSet.noneOf((Class) elementType);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: The expression of type EnumSet needs unchecked conversion to conform to Collection<E>\n" +
- "----------\n" +
- "5. WARNING in example\\CollectionFactory.java (at line 87)\n" +
- " return EnumSet.noneOf((Class) elementType);\n" +
- " ^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: The expression of type Class needs unchecked conversion to conform to Class<E>\n" +
- "----------\n" +
- "6. WARNING in example\\CollectionFactory.java (at line 87)\n" +
- " return EnumSet.noneOf((Class) elementType);\n" +
- " ^^^^^\n" +
- "Class is a raw type. References to generic type Class<T> should be parameterized\n" +
- "----------\n" +
- "7. WARNING in example\\CollectionFactory.java (at line 94)\n" +
- " return (Collection<E>) collectionClass.newInstance();\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked cast from capture#13-of ? to Collection<E>\n" +
- "----------\n"
- :
- "----------\n" +
- "1. ERROR in example\\CollectionFactory.java (at line 55)\n" +
- " return EnumSet.copyOf((EnumSet) collection);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type mismatch: cannot convert from EnumSet<Enum<Enum<E>>> to Collection<E>\n" +
- "----------\n" +
- "2. WARNING in example\\CollectionFactory.java (at line 55)\n" +
- " return EnumSet.copyOf((EnumSet) collection);\n" +
- " ^^^^^^^\n" +
- "EnumSet is a raw type. References to generic type EnumSet<E> should be parameterized\n" +
- "----------\n" +
- "3. ERROR in example\\CollectionFactory.java (at line 87)\n" +
- " return EnumSet.noneOf((Class) elementType);\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type mismatch: cannot convert from EnumSet<Enum<Enum<E>>> to Collection<E>\n" +
- "----------\n" +
- "4. WARNING in example\\CollectionFactory.java (at line 87)\n" +
- " return EnumSet.noneOf((Class) elementType);\n" +
- " ^^^^^\n" +
- "Class is a raw type. References to generic type Class<T> should be parameterized\n" +
- "----------\n" +
- "5. WARNING in example\\CollectionFactory.java (at line 94)\n" +
- " return (Collection<E>) collectionClass.newInstance();\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Type safety: Unchecked cast from capture#13-of ? to Collection<E>\n" +
- "----------\n"
- ));
+ "----------\n" +
+ "1. WARNING in example\\CollectionFactory.java (at line 42)\n" +
+ " @SuppressWarnings({ \"unchecked\", \"cast\" })\n" +
+ " ^^^^^^\n" +
+ "Unnecessary @SuppressWarnings(\"cast\")\n" +
+ "----------\n" +
+ "2. WARNING in example\\CollectionFactory.java (at line 55)\n" +
+ " return EnumSet.copyOf((EnumSet) collection);\n" +
+ " ^^^^^^^\n" +
+ "EnumSet is a raw type. References to generic type EnumSet<E> should be parameterized\n" +
+ "----------\n" +
+ "3. WARNING in example\\CollectionFactory.java (at line 87)\n" +
+ " return EnumSet.noneOf((Class) elementType);\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Type safety: Unchecked invocation noneOf(Class) of the generic method noneOf(Class<E>) of type EnumSet\n" +
+ "----------\n" +
+ "4. WARNING in example\\CollectionFactory.java (at line 87)\n" +
+ " return EnumSet.noneOf((Class) elementType);\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Type safety: The expression of type EnumSet needs unchecked conversion to conform to Collection<E>\n" +
+ "----------\n" +
+ "5. WARNING in example\\CollectionFactory.java (at line 87)\n" +
+ " return EnumSet.noneOf((Class) elementType);\n" +
+ " ^^^^^^^^^^^^^^^^^^^\n" +
+ (this.complianceLevel < ClassFileConstants.JDK1_8
+ ? "Type safety: The expression of type Class needs unchecked conversion to conform to Class<E>\n"
+ : "Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum<Enum<E>>>\n") +
+ "----------\n" +
+ "6. WARNING in example\\CollectionFactory.java (at line 87)\n" +
+ " return EnumSet.noneOf((Class) elementType);\n" +
+ " ^^^^^\n" +
+ "Class is a raw type. References to generic type Class<T> should be parameterized\n" +
+ "----------\n" +
+ "7. WARNING in example\\CollectionFactory.java (at line 94)\n" +
+ " return (Collection<E>) collectionClass.newInstance();\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Type safety: Unchecked cast from capture#13-of ? to Collection<E>\n" +
+ "----------\n"
+ );
}
// original test case, documenting existing compiler behavior
public void testBug456459a() {
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_8.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_8.java
index ea993b2..42089e6 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_8.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_8.java
@@ -5492,4 +5492,168 @@
"missing cannot be resolved\n" +
"----------\n");
}
+public void testBug471280_comment0() {
+ runConformTest(
+ new String[] {
+ "Test0.java",
+ "import java.util.*;\n" +
+ "import java.util.function.*;\n" +
+ "import java.util.concurrent.*;\n" +
+ "\n" +
+ "public class Test0 {\n" +
+ " public CompletableFuture<List<String>> does_not_compile() throws Exception {\n" +
+ " CompletableFuture<List<String>> firstAsync = new CompletableFuture<>();\n" +
+ " firstAsync.complete(Collections.singletonList(\"test\"));\n" +
+ " // The following line gives error \"Type mismatch: cannot convert from CompletableFuture<Object> to CompletableFuture<List<String>>\"\n" +
+ " return transform(firstAsync, first -> Collections.singletonList(first.get(0)));\n" +
+ " }\n" +
+ "\n" +
+ " public CompletableFuture<List<String>> does_compile() throws Exception {\n" +
+ " CompletableFuture<List<String>> firstAsync = new CompletableFuture<>();\n" +
+ " firstAsync.complete(Collections.singletonList(\"test\"));\n" +
+ " return transform(firstAsync, first -> {\n" +
+ " return Collections.singletonList(first.get(0));\n" +
+ " });\n" +
+ " }\n" +
+ "\n" +
+ " public <T, R> CompletableFuture<R> transform(CompletableFuture<T> future, Function<T, R> fun) throws Exception {\n" +
+ " return future.thenApply(fun);\n" +
+ " }\n" +
+ "}\n"
+ });
+}
+public void testBug471280_comment3() {
+ runConformTest(
+ new String[] {
+ "Test3.java",
+ "import java.util.*;\n" +
+ "import java.util.stream.*;\n" +
+ "\n" +
+ "public class Test3 {\n" +
+ " public <T> T generic(T value) {\n" +
+ " return value;\n" +
+ " }\n" +
+ "\n" +
+ " public void mapExample(Map<String, String> input) {\n" +
+ " // does not compile with ejc: Type mismatch: cannot convert from Map<Object,Object> to Map<String,String>\n" +
+ " Map<String, String> mapped = input.entrySet()\n" +
+ " .stream()\n" +
+ " .collect(Collectors.toMap(e -> e.getKey(), e -> generic(e.getValue())));\n" +
+ " }\n" +
+ "}\n"
+ });
+}
+public void testBug464496() {
+ runConformTest(
+ new String[] {
+ "Value.java",
+ "public class Value<V> {\n" +
+ " private final V value;\n" +
+ " public Value(V value) {\n" +
+ " this.value = value;\n" +
+ " }\n" +
+ " public V get() {\n" +
+ " return value;\n" +
+ " }\n" +
+ " public static <V> V getValue(Value<V> value) {\n" +
+ " return value.get();\n" +
+ " }\n" +
+ " public static void main(String[] args) {\n" +
+ " Value<Integer> intValue = new Value<>(42);\n" +
+ " long longPrimitive = getValue(intValue); // fails in 1.8 compiler \n" +
+ " System.out.println(longPrimitive);\n" +
+ " }\n" +
+ "}\n"
+ },
+ "42");
+}
+public void testBug473657() {
+ runConformTest(
+ new String[] {
+ "T2.java",
+ "interface I<T> {\n" +
+ "}\n" +
+ "\n" +
+ "@SuppressWarnings({\"unchecked\", \"rawtypes\"})\n" +
+ "abstract class T1<T> implements I<T> {\n" +
+ " public I<T> t(I<? extends Number> l2) {\n" +
+ " return T2.m((I) this, (I) l2);\n" +
+ " }\n" +
+ " public I<T> t(Number l2) {\n" +
+ " return T2.m((I) this, (I) T2.t(l2));\n" +
+ " }\n" +
+ "}\n" +
+ "\n" +
+ "public abstract class T2 {\n" +
+ " public static <T> I<T> t(T t) {\n" +
+ " return null;\n" +
+ " }\n" +
+ " public static <T extends Number> I<T> m(I<T> l1, I<? extends Number> l2) {\n" +
+ " return null;\n" +
+ " }\n" +
+ " public static <T extends Number> I<T> m(T l1, Number l2) {\n" +
+ " return null;\n" +
+ " }\n" +
+ "}\n"
+ });
+}
+public void testBug478848() {
+ runNegativeTest(
+ new String[] {
+ "InferenceBug.java",
+ "import java.util.Optional;\n" +
+ "public class InferenceBug {\n" +
+ " \n" +
+ " static class Wrapper<T> {\n" +
+ " T value;\n" +
+ " public T getValue() {\n" +
+ " return null;\n" +
+ " }\n" +
+ " }\n" +
+ " \n" +
+ " static class C1 {\n" +
+ " //an optional array of String wrappers\n" +
+ " public Optional<? extends Wrapper<String>[]> optionalArrayOfStringWrappers() {\n" +
+ " return Optional.empty();\n" +
+ " }\n" +
+ " }\n" +
+ " \n" +
+ " public static void main(String[] args) {\n" +
+ " C1 c1 = new C1();\n" +
+ " for (Wrapper<String> attribute: c1.optionalArrayOfStringWrappers().get()) {\n" +
+ " // error in previous line:\n" +
+ " // Can only iterate over an array or an instance of java.lang.Iterable\n" +
+ " }\n" +
+ " }\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in InferenceBug.java (at line 20)\n" +
+ " for (Wrapper<String> attribute: c1.optionalArrayOfStringWrappers().get()) {\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Can only iterate over an array or an instance of java.lang.Iterable\n" +
+ "----------\n");
+}
+public void testBug479167() {
+ runConformTest(
+ new String[] {
+ "ToArray.java",
+ "import java.io.Serializable;\n" +
+ "interface ArrayFunction<E> {\n" +
+ " <S extends E> E[] apply(@SuppressWarnings(\"unchecked\") S... es);\n" +
+ "}\n" +
+ "public class ToArray<E extends Cloneable & Serializable> implements ArrayFunction<E> {\n" +
+ " public final @SafeVarargs @Override <S extends E> E[] apply(S... es) {\n" +
+ " return es;\n" +
+ " }\n" +
+ "\n" +
+ " public static void main(String[] args) {\n" +
+ " ArrayFunction<String[]> toArray = new ToArray<>();\n" +
+ " String[][] array = toArray.apply(args);\n" +
+ " System.out.print(array.getClass().getName());\n" +
+ " }\n" +
+ "}\n"
+ },
+ "[[Ljava.lang.String;");
+}
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/InterfaceMethodsTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/InterfaceMethodsTest.java
index ca9fc45..bd96e34 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/InterfaceMethodsTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/InterfaceMethodsTest.java
@@ -2841,4 +2841,170 @@
"}"
});
}
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=477891, [1.8] regression caused by the fix for bug 438812: order dependencies in analysis of default method inheritance
+ public void test477891_comment0() throws Exception {
+ this.runNegativeTest(
+ new String[] {
+ "D.java",
+ "interface A {\n" +
+ " public default void display() {\n" +
+ " System.out.println(\"Display from A\");\n" +
+ " }\n" +
+ "}\n" +
+ "interface B extends A {\n" +
+ " @Override\n" +
+ " public default void display() {\n" +
+ " System.out.println(\"Display from B\");\n" +
+ " }\n" +
+ "}\n" +
+ "interface C extends A {\n" +
+ " @Override\n" +
+ " public void display();\n" +
+ "}\n" +
+ "public interface D extends B, C {\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in D.java (at line 16)\n" +
+ " public interface D extends B, C {\n" +
+ " ^\n" +
+ "The default method display() inherited from B conflicts with another method inherited from C\n" +
+ "----------\n");
+ }
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=477891, [1.8] regression caused by the fix for bug 438812: order dependencies in analysis of default method inheritance
+ public void test477891_comment0_a() throws Exception {
+ this.runNegativeTest(
+ new String[] {
+ "D.java",
+ "interface A {\n" +
+ " public default void display() {\n" +
+ " System.out.println(\"Display from A\");\n" +
+ " }\n" +
+ "}\n" +
+ "interface B extends A {\n" +
+ " @Override\n" +
+ " public default void display() {\n" +
+ " System.out.println(\"Display from B\");\n" +
+ " }\n" +
+ "}\n" +
+ "interface C extends A {\n" +
+ " @Override\n" +
+ " public void display();\n" +
+ "}\n" +
+ "public interface D extends C, B {\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in D.java (at line 16)\n" +
+ " public interface D extends C, B {\n" +
+ " ^\n" +
+ "The default method display() inherited from B conflicts with another method inherited from C\n" +
+ "----------\n");
+ }
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=477891, [1.8] regression caused by the fix for bug 438812: order dependencies in analysis of default method inheritance
+ public void test477891_comment3_a() throws Exception {
+ this.runNegativeTest(
+ new String[] {
+ "Z.java",
+ "import java.util.*;\n" +
+ "interface Z<E> extends X<E>, Y<E> {\n" +
+ "}\n" +
+ "interface Y<E> extends AB<E> {\n" +
+ " @Override\n" +
+ " default Spliterator<E> spliterator() { return null; };\n" +
+ "}\n" +
+ "interface X<E> extends AB<E> {\n" +
+ " @Override\n" +
+ " Spliterator<E> spliterator();\n" +
+ "}\n" +
+ "interface AB<E> {\n" +
+ " default Spliterator<E> spliterator() { return null; }\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in Z.java (at line 2)\n" +
+ " interface Z<E> extends X<E>, Y<E> {\n" +
+ " ^\n" +
+ "The default method spliterator() inherited from Y<E> conflicts with another method inherited from X<E>\n" +
+ "----------\n");
+ }
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=477891, [1.8] regression caused by the fix for bug 438812: order dependencies in analysis of default method inheritance
+ public void test477891_comment3_b() throws Exception {
+ this.runNegativeTest(
+ new String[] {
+ "Z.java",
+ "import java.util.*;\n" +
+ "interface Z<E> extends Y<E>, X<E> {\n" +
+ "}\n" +
+ "interface Y<E> extends AB<E> {\n" +
+ " @Override\n" +
+ " default Spliterator<E> spliterator() { return null; };\n" +
+ "}\n" +
+ "interface X<E> extends AB<E> {\n" +
+ " @Override\n" +
+ " Spliterator<E> spliterator();\n" +
+ "}\n" +
+ "interface AB<E> {\n" +
+ " default Spliterator<E> spliterator() { return null; }\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in Z.java (at line 2)\n" +
+ " interface Z<E> extends Y<E>, X<E> {\n" +
+ " ^\n" +
+ "The default method spliterator() inherited from Y<E> conflicts with another method inherited from X<E>\n" +
+ "----------\n");
+ }
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=477891, [1.8] regression caused by the fix for bug 438812: order dependencies in analysis of default method inheritance
+ public void test477891_comment3_c() throws Exception {
+ this.runNegativeTest(
+ new String[] {
+ "Z.java",
+ "import java.util.*;\n" +
+ "interface Z<E> extends X<E>, Y<E> {\n" +
+ "}\n" +
+ "interface Y<E> extends AB<E> {\n" +
+ " @Override\n" +
+ " default Spliterator<E> spliterator() { return null; };\n" +
+ "}\n" +
+ "interface X<E> {\n" +
+ " Spliterator<E> spliterator();\n" +
+ "}\n" +
+ "interface AB<E> {\n" +
+ " default Spliterator<E> spliterator() { return null; }\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in Z.java (at line 2)\n" +
+ " interface Z<E> extends X<E>, Y<E> {\n" +
+ " ^\n" +
+ "The default method spliterator() inherited from Y<E> conflicts with another method inherited from X<E>\n" +
+ "----------\n");
+ }
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=477891, [1.8] regression caused by the fix for bug 438812: order dependencies in analysis of default method inheritance
+ public void test477891_comment3_d() throws Exception {
+ this.runNegativeTest(
+ new String[] {
+ "Z.java",
+ "import java.util.*;\n" +
+ "interface Z<E> extends Y<E>, X<E> {\n" +
+ "}\n" +
+ "interface Y<E> extends AB<E> {\n" +
+ " @Override\n" +
+ " default Spliterator<E> spliterator() { return null; };\n" +
+ "}\n" +
+ "interface X<E> {\n" +
+ " Spliterator<E> spliterator();\n" +
+ "}\n" +
+ "interface AB<E> {\n" +
+ " default Spliterator<E> spliterator() { return null; }\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in Z.java (at line 2)\n" +
+ " interface Z<E> extends Y<E>, X<E> {\n" +
+ " ^\n" +
+ "The default method spliterator() inherited from Y<E> conflicts with another method inherited from X<E>\n" +
+ "----------\n");
+ }
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaRegressionTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaRegressionTest.java
index 7e1b888..ea3ac35 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaRegressionTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaRegressionTest.java
@@ -360,6 +360,11 @@
" .forEach(entry -> test() ? bad() : returnType());\n" +
" ^^^^^^^\n" +
"The method forEach(Consumer<? super Map.Entry<Object,Object>>) in the type Iterable<Map.Entry<Object,Object>> is not applicable for the arguments ((<no type> entry) -> {})\n" +
+ "----------\n" +
+ "2. ERROR in X.java (at line 6)\n" +
+ " .forEach(entry -> test() ? bad() : returnType());\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Invalid expression as statement\n" +
"----------\n");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=449824, [1.8] Difference in behaviour with method references and lambdas
@@ -810,6 +815,11 @@
" r.accept((l) -> (doItOnTheClass(new Object())));\n" +
" ^^^^^^\n" +
"The method accept(Test.Listener) in the type Test.Receiver is not applicable for the arguments ((<no type> l) -> {})\n" +
+ "----------\n" +
+ "2. ERROR in Test.java (at line 4)\n" +
+ " r.accept((l) -> (doItOnTheClass(new Object())));\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Invalid expression as statement\n" +
"----------\n");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=463526
@@ -912,6 +922,85 @@
},
"");
}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=477888
+// [1.8][compiler] Compiler silently produces garbage but editor shows no errors
+public void testBug477888() {
+ runNegativeTest(new String [] {
+ "Test.java",
+ "import java.io.IOException;\n" +
+ "import java.nio.file.Files;\n" +
+ "import java.nio.file.Paths;\n" +
+ "import java.util.function.Consumer;\n" +
+ "public class Test {\n" +
+ " public static void main(String[] args) throws IOException {\n" +
+ " Files.lines(Paths.get(args[0])).filter(x -> {return !x.startsWith(\".\");}).forEach(printMe());\n" +
+ " }\n" +
+ " private static Consumer<String> printMe() {\n" +
+ " return x -> x.isEmpty() ? System.out.println() : System.out.println(getIndex() + \" \" + x); // error must be reported here!\n" +
+ " }\n" +
+ " static int idx;\n" +
+ "\n" +
+ " private static int getIndex() {\n" +
+ " return ++idx;\n" +
+ " }\n" +
+ "}\n"
+ },
+ "----------\n" +
+ "1. ERROR in Test.java (at line 10)\n" +
+ " return x -> x.isEmpty() ? System.out.println() : System.out.println(getIndex() + \" \" + x); // error must be reported here!\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Invalid expression as statement\n" +
+ "----------\n");
+}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=472648
+// [compiler][1.8] Lambda expression referencing method with generic type has incorrect compile errors
+public void testBug472648() {
+ runNegativeTest(new String [] {
+ "Test.java",
+ "import java.util.ArrayList;\n" +
+ "import java.util.List;\n" +
+ "import java.util.function.Consumer;\n" +
+ "public class Test {\n" +
+ " public static void main(String argv[]) {\n" +
+ " new Test();\n" +
+ " }\n" +
+ " public Test() {\n" +
+ " List<Number> numList = new ArrayList<>();\n" +
+ " numList.add(1);\n" +
+ " numList.add(1.5);\n" +
+ " numList.add(2);\n" +
+ " numList.add(2.5);\n" +
+ " forEachValueOfType(numList, Integer.class, (Integer i) -> (System.out.println(Integer.toString(i))));\n" +
+ " }\n" +
+ " private <T> void forEachValueOfType(List<?> list, Class<T> type, Consumer<T> action) {\n" +
+ " \n" +
+ " for (Object o : list) {\n" +
+ " if (type.isAssignableFrom(o.getClass())) {\n" +
+ " @SuppressWarnings(\"unchecked\")\n" +
+ " T convertedObject = (T) o;\n" +
+ " action.accept(convertedObject);\n" +
+ " }\n" +
+ " }\n" +
+ " }\n" +
+ "}"
+ },
+ "----------\n" +
+ "1. ERROR in Test.java (at line 14)\n" +
+ " forEachValueOfType(numList, Integer.class, (Integer i) -> (System.out.println(Integer.toString(i))));\n" +
+ " ^^^^^^^^^^^^^^^^^^\n" +
+ "The method forEachValueOfType(List<?>, Class<T>, Consumer<T>) in the type Test is not applicable for the arguments (List<Number>, Class<Integer>, (Integer i) -> {})\n" +
+ "----------\n" +
+ "2. ERROR in Test.java (at line 14)\n" +
+ " forEachValueOfType(numList, Integer.class, (Integer i) -> (System.out.println(Integer.toString(i))));\n" +
+ " ^^^^^^^\n" +
+ "Incompatible type specified for lambda expression's parameter i\n" +
+ "----------\n" +
+ "3. ERROR in Test.java (at line 14)\n" +
+ " forEachValueOfType(numList, Integer.class, (Integer i) -> (System.out.println(Integer.toString(i))));\n" +
+ " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
+ "Invalid expression as statement\n" +
+ "----------\n");
+}
public static Class testClass() {
return LambdaRegressionTest.class;
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodParametersAttributeTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodParametersAttributeTest.java
index 2bb7707..dd5e3ea 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodParametersAttributeTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodParametersAttributeTest.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2013, 2014 Jesper Steen Moeller and others.
+ * Copyright (c) 2013, 2015 Jesper Steen Moeller and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -874,6 +874,65 @@
" final synthetic this$1\n";
assertSubstring(actualOutput, expectedOutput);
}
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=476528
+ public void test016() throws Exception {
+ // Test that the name argument of enum valueOf shows up as mandated
+
+ this.runParameterNameTest(
+ "Foo.java",
+ "public enum Foo {\n" +
+ " BAR;\n" +
+ " public static Foo valueOf(int intParameter) {\n" +
+ " return BAR;\n" +
+ " }\n" +
+ " public static Foo valueOf2(int intParameter) {\n" +
+ " return BAR;\n" +
+ " } \n" +
+ "}\n");
+
+ ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
+ String path = OUTPUT_DIR + File.separator + "Foo.class";
+ byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(new File(path));
+ String actualOutput =
+ disassembler.disassemble(
+ classFileBytes,
+ "\n",
+ ClassFileBytesDisassembler.DETAILED);
+
+ String expectedOutput =
+ " // Stack: 1, Locals: 1\n" +
+ " public static Foo valueOf(int intParameter);\n" +
+ " 0 getstatic Foo.BAR : Foo [17]\n" +
+ " 3 areturn\n" +
+ " Line numbers:\n" +
+ " [pc: 0, line: 4]\n" +
+ " Method Parameters:\n" +
+ " intParameter\n" +
+ " \n" +
+ " // Method descriptor #27 (I)LFoo;\n" +
+ " // Stack: 1, Locals: 1\n" +
+ " public static Foo valueOf2(int intParameter);\n" +
+ " 0 getstatic Foo.BAR : Foo [17]\n" +
+ " 3 areturn\n" +
+ " Line numbers:\n" +
+ " [pc: 0, line: 7]\n" +
+ " Method Parameters:\n" +
+ " intParameter\n";
+ assertSubstring(actualOutput, expectedOutput);
+ // Test that synthetic method gets the right parameter names
+ expectedOutput =
+ " public static Foo valueOf(java.lang.String name);\n" +
+ " 0 ldc <Class Foo> [1]\n" +
+ " 2 aload_0 [name]\n" +
+ " 3 invokestatic java.lang.Enum.valueOf(java.lang.Class, java.lang.String) : java.lang.Enum [39]\n" +
+ " 6 checkcast Foo [1]\n" +
+ " 9 areturn\n" +
+ " Line numbers:\n" +
+ " [pc: 0, line: 1]\n" +
+ " Method Parameters:\n" +
+ " mandated name\n";
+ assertSubstring(actualOutput, expectedOutput);
+ }
private void runParameterNameTest(String fileName, String body) {
Map compilerOptions = getCompilerOptions();
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java
index a0f73bc..1c11f10 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java
@@ -14134,4 +14134,75 @@
assertEquals("Wrong contents", expectedOutput, result);
}
}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=469454, The compiler generates wrong code during inheritance
+public void testBug469454() throws Exception {
+ this.runConformTest(
+ new String[] {
+ "TestClass.java",
+ "public class TestClass {\n" +
+ " public static class A {\n" +
+ " public static A method() {\n" +
+ " return null;\n" +
+ " }\n" +
+ " }\n" +
+ " public static class B extends A {\n" +
+ " public static B method() {\n" +
+ " return null;\n" +
+ " }\n" +
+ " }\n" +
+ " public static void main(String[] args) {\n" +
+ " System.out.println(B.class.getDeclaredMethods().length);\n" +
+ " }\n" +
+ "}\n",
+ },
+ "1");
+}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=469454, The compiler generates wrong code during inheritance
+public void testBug469454a() throws Exception {
+ this.runNegativeTest(
+ new String[] {
+ "TestClass.java",
+ "public class TestClass {\n" +
+ " public static class A {\n" +
+ " public final A method() {\n" +
+ " return null;\n" +
+ " }\n" +
+ " }\n" +
+ " public static class B extends A {\n" +
+ " @Override\n" +
+ " public B method() {\n" +
+ " return null;\n" +
+ " }\n" +
+ " }\n" +
+ " public static void main(String[] args) {\n" +
+ " System.out.println(B.class.getDeclaredMethods().length);\n" +
+ " }\n" +
+ "}\n",
+ },
+ "----------\n" +
+ "1. ERROR in TestClass.java (at line 9)\n" +
+ " public B method() {\n" +
+ " ^^^^^^^^\n" +
+ "Cannot override the final method from TestClass.A\n" +
+ "----------\n",
+ null,
+ true,
+ null,
+ true,
+ false,
+ false);
+ String expectedOutput = " public bridge synthetic TestClass.A method();";
+
+ File f = new File(OUTPUT_DIR + File.separator + "TestClass$B.class");
+ byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
+ ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
+ String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
+ int index = result.indexOf(expectedOutput);
+ if (index != -1 || expectedOutput.length() == 0) {
+ System.out.println(Util.displayString(result, 3));
+ }
+ if (index != -1) {
+ assertEquals("Wrong contents", expectedOutput, result);
+ }
+}
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java
index 5cc5e96..ef189dd 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java
@@ -8286,4 +8286,226 @@
getCompilerOptions(),
"");
}
+public void testBug474239() {
+ Map options = getCompilerOptions();
+ options.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
+ options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
+ runConformTestWithLibs(
+ new String[] {
+ "Test.java",
+ "public class Test {\n" +
+ " static String s1 = null, s2 = null;\n" +
+ "\n" +
+ " public static void main(String[] args) {\n" +
+ " int val = (int) System.currentTimeMillis();\n" +
+ " switch (val % 2) {\n" +
+ " case 0:\n" +
+ " if (s1 != null)\n" +
+ " s2 = \"\";\n" +
+ " break;\n" +
+ " case 1:\n" +
+ " if (s1 != null) // compiler thinks s1 is never null at this point\n" +
+ " throw new RuntimeException(\"\");\n" +
+ " break;\n" +
+ " }\n" +
+ " }\n" +
+ "}\n"
+ },
+ options,
+ "");
+}
+public void testBug474239b() {
+ Map options = getCompilerOptions();
+ options.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
+ options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
+ runConformTestWithLibs(
+ new String[] {
+ "Test.java",
+ "public class Test {\n" +
+ " static String s2 = null;\n" +
+ "\n" +
+ " public static void main(String[] args) {\n" +
+ " int val = (int) System.currentTimeMillis();\n" +
+ " switch (val % 2) {\n" +
+ " case 0:\n" +
+ " s2 = \"\";\n" +
+ " break;\n" +
+ " case 1:\n" +
+ " if (s2 != null)\n" +
+ " throw new RuntimeException(\"\");\n" +
+ " break;\n" +
+ " }\n" +
+ " }\n" +
+ "}\n"
+ },
+ options,
+ "");
+}
+public void testBug472663() {
+ runConformTestWithLibs(
+ new String[] {
+ "test/Callee.java",
+ "package test;\n" +
+ "\n" +
+ "import org.eclipse.jdt.annotation.NonNullByDefault;\n" +
+ "\n" +
+ "@NonNullByDefault\n" +
+ "public class Callee {\n" +
+ " public static String staticOtherClass(String foo) {\n" +
+ " return foo;\n" +
+ " }\n" +
+ "\n" +
+ " public String instanceOtherClass(String foo) {\n" +
+ " return foo;\n" +
+ " }\n" +
+ "}\n"
+ },
+ getCompilerOptions(),
+ "");
+ // and now consume Callee.class:
+ runConformTestWithLibs(
+ new String[] {
+ "test/Caller.java",
+ "package test;\n" +
+ "\n" +
+ "import java.util.function.Function;\n" +
+ "\n" +
+ "import org.eclipse.jdt.annotation.NonNullByDefault;\n" +
+ "\n" +
+ "@NonNullByDefault\n" +
+ "public class Caller {\n" +
+ " public void foo(final Callee callee) {\n" +
+ " Function<String, String> function;\n" +
+ "\n" +
+ " // assignments with warnings (wrong):\n" +
+ " function = Callee::staticOtherClass;\n" +
+ " function = callee::instanceOtherClass;\n" +
+ "\n" +
+ " // assignments with no warnings (ok):\n" +
+ " function = foo -> Callee.staticOtherClass(foo);\n" +
+ " function = foo -> callee.instanceOtherClass(foo);\n" +
+ " function = Caller::staticSameClass;\n" +
+ " function = this::instanceSameClass;\n" +
+ " }\n" +
+ "\n" +
+ " public static String staticSameClass(String foo) {\n" +
+ " return foo;\n" +
+ " }\n" +
+ "\n" +
+ " public String instanceSameClass(String foo) {\n" +
+ " return foo;\n" +
+ " }\n" +
+ "}\n"
+ },
+ getCompilerOptions(),
+ "");
+}
+public void testBug467094() {
+ runConformTestWithLibs(
+ new String[] {
+ "A.java",
+ "class A {;\n"+
+ " @org.eclipse.jdt.annotation.NonNull String @org.eclipse.jdt.annotation.Nullable [] x;\n"+
+ "}\n"
+ },
+ getCompilerOptions(),
+ "");
+}
+public void testBug467094_local() {
+ runNegativeTestWithLibs(
+ new String[] {
+ "X.java",
+ "public class X {\n"+
+ " void foo(@org.eclipse.jdt.annotation.NonNull Object[] o) {\n"+
+ " o.hashCode();\n"+
+ " if (o != null) {\n"+
+ " System.out.print(o.toString());\n"+
+ " }\n"+
+ " }\n"+
+ "}\n"
+ },
+ getCompilerOptions(),
+ "----------\n"+
+ "1. ERROR in X.java (at line 4)\n" +
+ " if (o != null) {\n" +
+ " ^\n" +
+ "Redundant null check: The variable o cannot be null at this location\n" +
+ "----------\n");
+}
+public void testBug467094_method() {
+ runConformTestWithLibs(
+ new String[] {
+ "A.java",
+ "class A {;\n"+
+ " @org.eclipse.jdt.annotation.NonNull String @org.eclipse.jdt.annotation.Nullable [] m(){\n" +
+ " return null;\n" +
+ " }\n" +
+ " int usage(){\n" +
+ " if(m() == null) return 1; \n" +
+ " return 0; \n" +
+ " }\n"+
+ "}\n"
+ }, getCompilerOptions(), "");
+}
+public void testBug440398() {
+ runConformTestWithLibs(
+ new String[] {
+ "NullTest.java",
+ "import org.eclipse.jdt.annotation.*;\n" +
+ "@NonNullByDefault({})\r\n" +
+ "public class NullTest {\r\n" +
+ " public static @NonNull Object[] obj = null;\r\n" +
+ " public static void main(String[] args) {\r\n" +
+ " obj = null;\r\n" +
+ " if (obj == null) { // WARNING 1\r\n" +
+ " System.out.println(\"NULL\"); // WARNING 2\r\n" +
+ " }\r\n" +
+ " }\r\n" +
+ "}\n"
+ },
+ getCompilerOptions(),
+ "",
+ "NULL");
+}
+public void testBug440398_comment2() {
+ runConformTestWithLibs(
+ new String[] {
+ "MyClass.java",
+ "import org.eclipse.jdt.annotation.*;\n" +
+ "\n" +
+ "@NonNullByDefault({DefaultLocation.FIELD})\n" +
+ "public class MyClass {\n" +
+ " private @NonNull String [] names = new @NonNull String[]{\"Alice\", \"Bob\", \"Charlie\"};\n" +
+ "\n" +
+ " public String getName(int index) {\n" +
+ " String name = names[index];\n" +
+ " return name; /* statement A */\n" +
+ " }\n" +
+ "}",
+ },
+ getCompilerOptions(),
+ "");
+}
+public void testBug440398_comment2a() {
+ runConformTestWithLibs(
+ new String[] {
+ "p/package-info.java",
+ "@org.eclipse.jdt.annotation.NonNullByDefault({org.eclipse.jdt.annotation.DefaultLocation.FIELD})\n" +
+ "package p;\n",
+ "p/MyClass.java",
+ "package p;\n" +
+ "import org.eclipse.jdt.annotation.*;\n" +
+ "\n" +
+ "public class MyClass {\n" +
+ " private @NonNull String [] names = new @NonNull String[]{\"Alice\", \"Bob\", \"Charlie\"};\n" +
+ "\n" +
+ " public String getName(int index) {\n" +
+ " String name = names[index];\n" +
+ " return name; /* statement A */\n" +
+ " }\n" +
+ "}",
+ },
+ getCompilerOptions(),
+ "");
+}
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/StaticImportTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/StaticImportTest.java
index b7b1910..9f6865c 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/StaticImportTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/StaticImportTest.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -3193,5 +3193,38 @@
"The type I is ambiguous\n" +
"----------\n");
}
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=479287
+ // erroneous compile error using static imports and generics
+ public void testBug479287() {
+ this.runConformTest(
+ new String[] {
+ "joetest/GenericsIssue.java",
+ "package joetest;\n" +
+ "import static joetest.GenericsIssueCollaborator.takesAnything;\n" +
+ "import java.util.Collection;\n" +
+ "import java.util.Collections;\n" +
+ "public class GenericsIssue {\n" +
+ " private void oddCompileError() {\n" +
+ " takesAnything(returnThings(\"works without wildcard in return value\"));\n" +
+ " GenericsIssueCollaborator.takesAnything(returnThingsWildcard(\"works without static import\"));\n" +
+ " takesAnything(returnThingsWildcard(\"doesn\'t work with static import\"));\n" +
+ " }\n" +
+ " private <T> Collection<T> returnThings(T thing) {\n" +
+ " return Collections.singleton(thing);\n" +
+ " }\n" +
+ " \n" +
+ " private <T> Collection<? extends T> returnThingsWildcard(T toReturn) {\n" +
+ " return Collections.singleton(toReturn);\n" +
+ " }\n" +
+ "}",
+ "joetest/GenericsIssueCollaborator.java",
+ "package joetest;\n" +
+ "public class GenericsIssueCollaborator {\n" +
+ " public static <T> void takesAnything(T thing) {\n" +
+ " System.out.println(\"TOOK IT: \" + thing);\n" +
+ " }\n" +
+ "}"
+ });
+ }
}
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
index c13eec8..a5410d3 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
@@ -5191,5 +5191,126 @@
IMethodBinding binding = lambdaExpression.resolveMethodBinding();
assertTrue("Should be a varargs", binding.isVarargs());
}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=463942
+public void testBug463942_001() throws JavaModelException {
+ String contents =
+ "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
+ "@interface Marker {\n" +
+ " String value() default \"\";\n" +
+ "}\n" +
+ "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
+ "@interface Marker2 {\n" +
+ " String value() default \"22\";\n" +
+ "}\n" +
+ "public class X {\n" +
+ " public String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str = null;\n" +
+ "}";
+
+ this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
+ ASTNode node = buildAST(contents, this.workingCopy);
+ assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+ CompilationUnit compilationUnit = (CompilationUnit) node;
+ assertProblemsSize(compilationUnit, 0);
+
+ /* public String @Marker("i0") @Marker2 [] [] @Marker("i1") [] str = null; */
+ node = getASTNode(compilationUnit, 2, 0);
+ assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
+ FieldDeclaration field = (FieldDeclaration) node;
+ List fragments = field.fragments();
+ assertEquals("Incorrect no of fragments", 1, fragments.size());
+ VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
+ IVariableBinding variable = fragment.resolveBinding();
+ assertNotNull("Should not be null", variable);
+ ITypeBinding typeBinding = variable.getType();
+ assertNotNull("Should not be null", typeBinding);
+ IAnnotationBinding[][] dimAnnotations = typeBinding.getTypeAnnotationsOnDimensions();
+
+ assertEquals("Incorrect type annotations", 3, dimAnnotations.length);
+ IAnnotationBinding[] annotations = dimAnnotations[0];
+ assertTrue("Incorrect number of annotations", annotations.length == 2);
+ assertEquals("Incorrect type annotations", "@Marker(value = i0)", annotations[0].toString());
+ assertEquals("Incorrect type annotations", "@Marker2()", annotations[1].toString());
+ annotations = dimAnnotations[1];
+ assertTrue("Incorrect number of annotations", annotations.length == 0);
+ annotations = dimAnnotations[2];
+ assertTrue("Incorrect number of annotations", annotations.length == 1);
+ assertEquals("Incorrect type annotations", "@Marker(value = i1)", annotations[0].toString());
+
+}
+
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=399792
+public void testBug470794_001() throws JavaModelException {
+ String content =
+ "public class X {\n" +
+ " Object o = (I & J) () -> {};" +
+ " public K main(Object o) {\n" +
+ " K oo = (I & J & K) o;\n" +
+ " return oo;\n" +
+ " }\n" +
+ "}\n" +
+ "interface I {\n" +
+ " public void foo();\n" +
+ "}\n" +
+ "interface J {\n" +
+ " public void foo();\n" +
+ " public void bar();\n" +
+ "}\n" +
+ "interface K {\n" +
+ " public void foo();\n" +
+ " public void bar();\n" +
+ "}\n";
+
+ this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
+ ASTNode node = buildAST(content, this.workingCopy, true);
+ assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+ CompilationUnit unit = (CompilationUnit) node;
+ TypeDeclaration type = (TypeDeclaration) unit.types().get(0);
+ node = (ASTNode) type.bodyDeclarations().get(0);
+ assertEquals("Not a field Declaration", ASTNode.FIELD_DECLARATION, node.getNodeType());
+ FieldDeclaration field = (FieldDeclaration) node;
+ assertEquals("Field should not be malformed", 0, (field.getFlags() & ASTNode.MALFORMED));
+
+ List fragments = field.fragments();
+ assertEquals("Incorrect no of fragments", 1, fragments.size());
+ VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
+ CastExpression cast = (CastExpression) fragment.getInitializer();
+ Type castType = cast.getType();
+ assertEquals("Not an intersection cast type", ASTNode.INTERSECTION_TYPE, castType.getNodeType());
+ assertTrue("Not an intersection cast type", castType.isIntersectionType());
+ assertEquals("Type should not be malformed", 0, (castType.getFlags() & ASTNode.MALFORMED));
+ ITypeBinding binding = castType.resolveBinding();
+ assertNotNull("binding is null", binding);
+ assertTrue("Not an intersection type binding", binding.isIntersectionType());
+ {
+ ITypeBinding [] intersectionBindings = binding.getTypeBounds();
+ String[] expectedTypes = new String[]{"I", "J"};
+ assertTrue("Incorrect number of intersection bindings", intersectionBindings.length == expectedTypes.length);
+ for (int i = 0, l = intersectionBindings.length; i < l; ++i) {
+ assertTrue("Unexpected Intersection Type", expectedTypes[i].equals(intersectionBindings[i].getName()));
+ }
+ }
+
+ node = (ASTNode) type.bodyDeclarations().get(1);
+ assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
+ MethodDeclaration method = (MethodDeclaration) node;
+ assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED));
+
+ List statements = method.getBody().statements();
+ VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0);
+ fragment = (VariableDeclarationFragment) statement.fragments().get(0);
+ cast = (CastExpression) fragment.getInitializer();
+ castType = cast.getType();
+ binding = castType.resolveBinding();
+ assertNotNull("binding is null", binding);
+ assertTrue("Not an intersection type binding", binding.isIntersectionType());
+ {
+ ITypeBinding [] intersectionBindings = binding.getTypeBounds();
+ String[] expectedTypes = new String[]{"I", "J", "K"};
+ assertTrue("Incorrect number of intersection bindings", intersectionBindings.length == expectedTypes.length);
+ for (int i = 0, l = intersectionBindings.length; i < l; ++i) {
+ assertTrue("Unexpected Intersection Type", expectedTypes[i].equals(intersectionBindings[i].getName()));
+ }
+ }
+}
}
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterBugsTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterBugsTests.java
index 4e357e8..9893639 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterBugsTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterBugsTests.java
@@ -11174,4 +11174,638 @@
"}";
formatSource(source);
}
+/**
+ * https://bugs.eclipse.org/474629 - [save actions][clean up] Exceptions thrown
+ */
+public void testBug474629() {
+ this.formatterPrefs.alignment_for_binary_expression |= Alignment.M_INDENT_ON_COLUMN;
+ String source = "aaaaa + bbbb";
+ formatSource(source, source, CodeFormatter.K_EXPRESSION, 0, true);
}
+/**
+ * https://bugs.eclipse.org/467618 - [formatter] Empty lines should not affect indentation of wrapped elements
+ */
+public void testBug467618() {
+ this.formatterPrefs.alignment_for_enum_constants = Alignment.M_NEXT_PER_LINE_SPLIT + Alignment.M_INDENT_ON_COLUMN + Alignment.M_FORCE;
+ String source =
+ "public enum E2 {\r\n" +
+ "\r\n" +
+ " FOOBAR,\r\n" +
+ "\r\n" +
+ " FOOBARBAZ,\r\n" +
+ "\r\n" +
+ " FOO;\r\n" +
+ "}";
+ formatSource(source,
+ "public enum E2 {\r\n" +
+ "\r\n" +
+ " FOOBAR,\r\n" +
+ "\r\n" +
+ " FOOBARBAZ,\r\n" +
+ "\r\n" +
+ " FOO;\r\n" +
+ "}"
+ );
+}
+/**
+ * @bug 474916: [formatter] Formatting GridBagLayout from Java 8 takes too long
+ * @test test that formatting finishes in reasonable time
+ * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=474916"
+ */
+public void testBug474916() {
+ String source =
+ "/**\r\n" +
+ " * < \r\n" +
+ " * > <p style='color:red'> Test </p>\r\n" +
+ " * <a title=\"I like to 'quote' it\" \r\n" +
+ "href = 'http://www.eclipse.org'>Toast</a> */\r\n" +
+ "class A {}";
+ formatSource(source,
+ "/**\r\n" +
+ " * < >\r\n" +
+ " * <p style='color:red'>\r\n" +
+ " * Test\r\n" +
+ " * </p>\r\n" +
+ " * <a title=\"I like to 'quote' it\" href = 'http://www.eclipse.org'>Toast</a>\r\n" +
+ " */\r\n" +
+ "class A {\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/474918 - [formatter] doesn't align fields in declarations of annotations, enums and anonymous classes
+ */
+public void testBug474918() {
+ this.formatterPrefs.align_type_members_on_columns = true;
+ String source =
+ "import java.util.function.Function;\r\n" +
+ "\r\n" +
+ "public class A {\r\n" +
+ " private Function mapper = (Object a) -> {\r\n" +
+ " return a.toString().equals(\"test\");\r\n" +
+ " };\r\n" +
+ " String ssssssssssssssss = \"dsadaaaaaaaaaaaaaaaaaaaaaaaaa\"; //$NON-NLS-1$ // B // A\r\n" +
+ "\r\n" +
+ " int bb = 4;\r\n" +
+ "\r\n" +
+ " Object c = new Object() {\r\n" +
+ " int a = 55;\r\n" +
+ " Object cdddddddddddd = null;\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " private enum E {\r\n" +
+ " AAA, BBB;\r\n" +
+ " int a = 55;\r\n" +
+ " String sssss = \"ssssss\";\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " private @interface II {\r\n" +
+ " int aaaaaa = 1;\r\n" +
+ " String bbbbbbbbb = \"default\";\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source,
+ "import java.util.function.Function;\r\n" +
+ "\r\n" +
+ "public class A {\r\n" +
+ " private Function mapper = (Object a) -> {\r\n" +
+ " return a.toString().equals(\"test\");\r\n" +
+ " };\r\n" +
+ " String ssssssssssssssss = \"dsadaaaaaaaaaaaaaaaaaaaaaaaaa\"; //$NON-NLS-1$ //\r\n" +
+ " // B\r\n" +
+ " // //\r\n" +
+ " // A\r\n" +
+ "\r\n" +
+ " int bb = 4;\r\n" +
+ "\r\n" +
+ " Object c = new Object() {\r\n" +
+ " int a = 55;\r\n" +
+ " Object cdddddddddddd = null;\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " private enum E {\r\n" +
+ " AAA, BBB;\r\n" +
+ " int a = 55;\r\n" +
+ " String sssss = \"ssssss\";\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " private @interface II {\r\n" +
+ " int aaaaaa = 1;\r\n" +
+ " String bbbbbbbbb = \"default\";\r\n" +
+ " }\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/474918 - [formatter] doesn't align fields in declarations of annotations, enums and anonymous classes
+ */
+public void testBug474918b() {
+ this.formatterPrefs.align_type_members_on_columns = true;
+ this.formatterPrefs.tab_char = DefaultCodeFormatterOptions.SPACE;
+ String source =
+ "import java.util.function.Function;\r\n" +
+ "\r\n" +
+ "public class A {\r\n" +
+ " private Function mapper = (Object a) -> {\r\n" +
+ " return a.toString().equals(\"test\");\r\n" +
+ " };\r\n" +
+ " String ssssssssssssssss = \"dsadaaaaaaaaaaaaaaaaaaaaaaaaa\"; //$NON-NLS-1$ // B // A\r\n" +
+ "\r\n" +
+ " int bb = 4;\r\n" +
+ "\r\n" +
+ " Object c = new Object() {\r\n" +
+ " int a = 55;\r\n" +
+ " Object cdddddddddddd = null;\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " private enum E {\r\n" +
+ " AAA, BBB;\r\n" +
+ " int a = 55;\r\n" +
+ " String sssss = \"ssssss\";\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " private @interface II {\r\n" +
+ " int aaaaaa = 1;\r\n" +
+ " String bbbbbbbbb = \"default\";\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source,
+ "import java.util.function.Function;\r\n" +
+ "\r\n" +
+ "public class A {\r\n" +
+ " private Function mapper = (Object a) -> {\r\n" +
+ " return a.toString().equals(\"test\");\r\n" +
+ " };\r\n" +
+ " String ssssssssssssssss = \"dsadaaaaaaaaaaaaaaaaaaaaaaaaa\"; //$NON-NLS-1$ //\r\n" +
+ " // B\r\n" +
+ " // //\r\n" +
+ " // A\r\n" +
+ "\r\n" +
+ " int bb = 4;\r\n" +
+ "\r\n" +
+ " Object c = new Object() {\r\n" +
+ " int a = 55;\r\n" +
+ " Object cdddddddddddd = null;\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " private enum E {\r\n" +
+ " AAA, BBB;\r\n" +
+ " int a = 55;\r\n" +
+ " String sssss = \"ssssss\";\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " private @interface II {\r\n" +
+ " int aaaaaa = 1;\r\n" +
+ " String bbbbbbbbb = \"default\";\r\n" +
+ " }\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/474918 - [formatter] doesn't align fields in declarations of annotations, enums and anonymous classes
+ */
+public void testBug474918c() {
+ this.formatterPrefs.align_type_members_on_columns = true;
+ this.formatterPrefs.use_tabs_only_for_leading_indentations = true;
+ String source =
+ "import java.util.function.Function;\r\n" +
+ "\r\n" +
+ "public class A {\r\n" +
+ " private Function mapper = (Object a) -> {\r\n" +
+ " return a.toString().equals(\"test\");\r\n" +
+ " };\r\n" +
+ " String ssssssssssssssss = \"dsadaaaaaaaaaaaaaaaaaaaaaaaaa\"; //$NON-NLS-1$ // B // A\r\n" +
+ "\r\n" +
+ " int bb = 4;\r\n" +
+ "\r\n" +
+ " Object c = new Object() {\r\n" +
+ " int a = 55;\r\n" +
+ " Object cdddddddddddd = null;\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " private enum E {\r\n" +
+ " AAA, BBB;\r\n" +
+ " int a = 55;\r\n" +
+ " String sssss = \"ssssss\";\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " private @interface II {\r\n" +
+ " int aaaaaa = 1;\r\n" +
+ " String bbbbbbbbb = \"default\";\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source,
+ "import java.util.function.Function;\r\n" +
+ "\r\n" +
+ "public class A {\r\n" +
+ " private Function mapper = (Object a) -> {\r\n" +
+ " return a.toString().equals(\"test\");\r\n" +
+ " };\r\n" +
+ " String ssssssssssssssss = \"dsadaaaaaaaaaaaaaaaaaaaaaaaaa\"; //$NON-NLS-1$ //\r\n" +
+ " // B\r\n" +
+ " // //\r\n" +
+ " // A\r\n" +
+ "\r\n" +
+ " int bb = 4;\r\n" +
+ "\r\n" +
+ " Object c = new Object() {\r\n" +
+ " int a = 55;\r\n" +
+ " Object cdddddddddddd = null;\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " private enum E {\r\n" +
+ " AAA, BBB;\r\n" +
+ " int a = 55;\r\n" +
+ " String sssss = \"ssssss\";\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " private @interface II {\r\n" +
+ " int aaaaaa = 1;\r\n" +
+ " String bbbbbbbbb = \"default\";\r\n" +
+ " }\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/475865 - JDT deletes code
+ */
+public void testBug475865() {
+ String source =
+ "public class Snippet {\r\n" +
+ "\r\n" +
+ " Runnable disposeRunnable = this::dispose();\r\n" +
+ "\r\n" +
+ " void dispose() {\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source);
+}
+/**
+ * https://bugs.eclipse.org/435241 - [1.8][lambda][formatter] if/else within lambda is incorrectly formatted
+ */
+public void testBug435241() {
+ this.formatterPrefs.brace_position_for_block = DefaultCodeFormatterConstants.NEXT_LINE;
+ this.formatterPrefs.insert_new_line_before_else_in_if_statement = true;
+ String source =
+ "public class Snippet {\r\n" +
+ " public static void main(String[] args) {\r\n" +
+ " Executors.newSingleThreadExecutor().execute(() -> {\r\n" +
+ " if (true)\r\n" +
+ " {\r\n" +
+ " System.err.println(\"foo\");\r\n" +
+ " }\r\n" +
+ " else\r\n" +
+ " {\r\n" +
+ " System.err.println(\"bar\");\r\n" +
+ " }\r\n" +
+ " });\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source);
+}
+/**
+ * https://bugs.eclipse.org/472815 - [formatter] 'Indent Empty lines' option doesn't work inside empty blocks
+ */
+public void testBug472815() {
+ this.formatterPrefs.number_of_empty_lines_to_preserve = 2;
+ String source =
+ "public class Snippet {\r\n" +
+ "\r\n" +
+ " int[] a1 = { };\r\n" +
+ " int[] a2 = {\r\n" +
+ " };\r\n" +
+ " int[] a3 = {\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ " int[] a4 = {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ " int[] a5 = {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " void f1() { }\r\n" +
+ " void f2() {\r\n" +
+ " }\r\n" +
+ " void f3() {\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ " void f4() {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ " void f5() {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source,
+ "public class Snippet {\r\n" +
+ "\r\n" +
+ " int[] a1 = {};\r\n" +
+ " int[] a2 = {};\r\n" +
+ " int[] a3 = {\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ " int[] a4 = {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ " int[] a5 = {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " void f1() {\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void f2() {\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void f3() {\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void f4() {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void f5() {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/472815 - [formatter] 'Indent Empty lines' option doesn't work inside empty blocks
+ */
+public void testBug472815b() {
+ this.formatterPrefs.number_of_empty_lines_to_preserve = 2;
+ this.formatterPrefs.indent_empty_lines = true;
+ String source =
+ "public class Snippet {\r\n" +
+ "\r\n" +
+ " int[] a1 = { };\r\n" +
+ " int[] a2 = {\r\n" +
+ " };\r\n" +
+ " int[] a3 = {\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ " int[] a4 = {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ " int[] a5 = {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " void f1() { }\r\n" +
+ " void f2() {\r\n" +
+ " }\r\n" +
+ " void f3() {\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ " void f4() {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ " void f5() {\r\n" +
+ "\r\n" +
+ "\r\n" +
+ "\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source,
+ "public class Snippet {\r\n" +
+ " \r\n" +
+ " int[] a1 = {};\r\n" +
+ " int[] a2 = {};\r\n" +
+ " int[] a3 = {\r\n" +
+ " \r\n" +
+ " };\r\n" +
+ " int[] a4 = {\r\n" +
+ " \r\n" +
+ " \r\n" +
+ " };\r\n" +
+ " int[] a5 = {\r\n" +
+ " \r\n" +
+ " \r\n" +
+ " };\r\n" +
+ " \r\n" +
+ " void f1() {\r\n" +
+ " }\r\n" +
+ " \r\n" +
+ " void f2() {\r\n" +
+ " }\r\n" +
+ " \r\n" +
+ " void f3() {\r\n" +
+ " \r\n" +
+ " }\r\n" +
+ " \r\n" +
+ " void f4() {\r\n" +
+ " \r\n" +
+ " \r\n" +
+ " }\r\n" +
+ " \r\n" +
+ " void f5() {\r\n" +
+ " \r\n" +
+ " \r\n" +
+ " }\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/472413 - [formatter] Wrap all arguments on new lines and prefer outer expressions result is inconsistent
+ */
+public void testBug472413() {
+ this.formatterPrefs.alignment_for_arguments_in_method_invocation =
+ DefaultCodeFormatterOptions.Alignment.M_ONE_PER_LINE_SPLIT
+ + DefaultCodeFormatterOptions.Alignment.M_INDENT_BY_ONE;
+ this.formatterPrefs.page_width = 80;
+ String source =
+ "class Snippet {\r\n" +
+ "\r\n" +
+ " void foo1() {\r\n" +
+ " Other.bar(\r\n" +
+ " 100,\r\n" +
+ " nestedMethod2Arg(\r\n" +
+ " nestedMethod1Arg(\r\n" +
+ " nestedMethod2Arg(nestedMethod1Arg(nestedMethod2Arg(\r\n" +
+ " nestedMethod1Arg(nestedMethod1Arg(nestedMethod1Arg(\r\n" +
+ " nested(200, 300, 400, 500, 600, 700, 800, 900)))),\r\n" +
+ " null)), null)),\r\n" +
+ " null),\r\n" +
+ " 100);\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void foo2() {\r\n" +
+ " nestedMethodAAAA(\r\n" +
+ " nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null));\r\n" +
+ " nestedMethodAAAA(nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null));\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void foo3() {\r\n" +
+ " nestedMethodAAAA(\r\n" +
+ " nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null),\r\n" +
+ " null);\r\n" +
+ " nestedMethodAAAA(nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null), null);\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source,
+ "class Snippet {\r\n" +
+ "\r\n" +
+ " void foo1() {\r\n" +
+ " Other.bar(\r\n" +
+ " 100,\r\n" +
+ " nestedMethod2Arg(\r\n" +
+ " nestedMethod1Arg(\r\n" +
+ " nestedMethod2Arg(\r\n" +
+ " nestedMethod1Arg(\r\n" +
+ " nestedMethod2Arg(\r\n" +
+ " nestedMethod1Arg(\r\n" +
+ " nestedMethod1Arg(\r\n" +
+ " nestedMethod1Arg(\r\n" +
+ " nested(\r\n" +
+ " 200,\r\n" +
+ " 300,\r\n" +
+ " 400,\r\n" +
+ " 500,\r\n" +
+ " 600,\r\n" +
+ " 700,\r\n" +
+ " 800,\r\n" +
+ " 900)))),\r\n" +
+ " null)),\r\n" +
+ " null)),\r\n" +
+ " null),\r\n" +
+ " 100);\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void foo2() {\r\n" +
+ " nestedMethodAAAA(\r\n" +
+ " nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null));\r\n" +
+ " nestedMethodAAAA(\r\n" +
+ " nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null));\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ " void foo3() {\r\n" +
+ " nestedMethodAAAA(\r\n" +
+ " nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null),\r\n" +
+ " null);\r\n" +
+ " nestedMethodAAAA(\r\n" +
+ " nestedMethodBBBB(\r\n" +
+ " nestedMethodCCC(dddddd(200, 300, 400, 500, 600, 700, 800, 900)),\r\n" +
+ " null),\r\n" +
+ " null);\r\n" +
+ " }\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/475793 - [formatter] Incorrect whitespace after lambda block
+ */
+public void testBug475793() {
+ this.formatterPrefs.insert_new_line_in_empty_block = false;
+ String source =
+ "public class C {\r\n" +
+ " public void f() {\r\n" +
+ " Foo.bar(() -> {} , IllegalArgumentException.class);\r\n" +
+ " }\r\n" +
+ "}";
+ formatSource(source,
+ "public class C {\r\n" +
+ " public void f() {\r\n" +
+ " Foo.bar(() -> {}, IllegalArgumentException.class);\r\n" +
+ " }\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/475746 - [formatter] insert-space rules sometimes ignored with anonymous subclass or when Annotations present
+ */
+public void testBug475746() {
+ this.formatterPrefs.insert_new_line_in_empty_block = false;
+ this.formatterPrefs.insert_space_after_opening_paren_in_method_invocation = true;
+ this.formatterPrefs.insert_space_before_closing_paren_in_method_invocation = true;
+ this.formatterPrefs.insert_space_after_opening_paren_in_method_declaration = true;
+ this.formatterPrefs.insert_space_before_closing_paren_in_method_declaration = true;
+ this.formatterPrefs.insert_space_after_opening_paren_in_constructor_declaration = true;
+ this.formatterPrefs.insert_space_before_closing_paren_in_constructor_declaration = true;
+ this.formatterPrefs.insert_space_after_opening_paren_in_annotation = true;
+ this.formatterPrefs.insert_space_before_closing_paren_in_annotation = true;
+ String source =
+ "import java.awt.*;\r\n" +
+ "\r\n" +
+ "public class MyClass {\r\n" +
+ "\r\n" +
+ " @Annotation( Arrays.asList( \"\" ))\r\n" +
+ " static Point p = new Point( x, y) {\r\n" +
+ " @Override\r\n" +
+ " public int hashCode( ) {\r\n" +
+ " return 42;\r\n" +
+ " }\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " MyClass( @Annotation( \"annotationVal\" ) String s)\r\n" +
+ " {\r\n" +
+ " Foo.bar( ( @Annotation( \"annotationVal\" ) int a) -> { } , IllegalArgumentException.class );\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ "}";
+ formatSource(source,
+ "import java.awt.*;\r\n" +
+ "\r\n" +
+ "public class MyClass {\r\n" +
+ "\r\n" +
+ " @Annotation( Arrays.asList( \"\" ) )\r\n" +
+ " static Point p = new Point( x, y ) {\r\n" +
+ " @Override\r\n" +
+ " public int hashCode() {\r\n" +
+ " return 42;\r\n" +
+ " }\r\n" +
+ " };\r\n" +
+ "\r\n" +
+ " MyClass( @Annotation( \"annotationVal\" ) String s ) {\r\n" +
+ " Foo.bar( ( @Annotation( \"annotationVal\" ) int a ) -> {}, IllegalArgumentException.class );\r\n" +
+ " }\r\n" +
+ "\r\n" +
+ "}"
+ );
+}
+/**
+ * https://bugs.eclipse.org/477005 - [formatter] NullPointerException when first line is empty and indented
+ */
+public void testBug477005() {
+ this.formatterPrefs.indent_empty_lines = true;
+ this.formatterPrefs.blank_lines_before_package = 2;
+ String source =
+ "\r\n" +
+ "\r\n" +
+ "package test;\r\n" +
+ "\r\n" +
+ "public class MyClass {\r\n" +
+ "}";
+ formatSource(source);
+}
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsBugsTest.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsBugsTest.java
index 48dcc5a..052ab58 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsBugsTest.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsBugsTest.java
@@ -7223,4 +7223,103 @@
" // bbb\n" +
"}");
}
+/**
+ * https://bugs.eclipse.org/475294 - [formatter] "Preserve whitespace..." problems with wrapped line comments
+ */
+public void testBug475294() {
+ this.formatterPrefs.comment_preserve_white_space_between_code_and_line_comments = true;
+ String source =
+ "public class A {\n" +
+ " void a() {\n" +
+ " System.out.println();// aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " }\n" +
+ "}";
+ formatSource(source,
+ "public class A {\n" +
+ " void a() {\n" +
+ " System.out.println();// aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " }\n" +
+ "}");
+}
+/**
+ * https://bugs.eclipse.org/475294 - [formatter] "Preserve whitespace..." problems with wrapped line comments
+ */
+public void testBug475294b() {
+ this.formatterPrefs.comment_preserve_white_space_between_code_and_line_comments = true;
+ this.formatterPrefs.use_tabs_only_for_leading_indentations = true;
+ String source =
+ "public class A {\n" +
+ " void a() {\n" +
+ " System.out.println();// aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " }\n" +
+ "}";
+ formatSource(source,
+ "public class A {\n" +
+ " void a() {\n" +
+ " System.out.println();// aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " System.out.println(); // aaaaaaa bbbbbbbbbbbbbbb ccccccccccccc\n" +
+ " // ddddddddddddddd eeeeeeeeeeeeeee\n" +
+ " }\n" +
+ "}");
+}
}
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AttachSourceTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AttachSourceTests.java
index 07b52f5..20c9af0 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AttachSourceTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AttachSourceTests.java
@@ -194,6 +194,12 @@
" class Inner {\n" +
" Inner() {\n" +
" }\n" +
+ " class WW {\n" +
+ " WW() {}\n" +
+ " class WWW {\n" +
+ " WWW() {}\n" +
+ " }\n" +
+ " }\n" +
" }\n" +
"}"
};
@@ -900,6 +906,12 @@
" class Inner {\n" +
" Inner() {\n" +
" }\n" +
+ " class WW {\n" +
+ " WW() {}\n" +
+ " class WWW {\n" +
+ " WWW() {}\n" +
+ " }\n" +
+ " }\n" +
" }\n" +
"}",
type.getSource());
@@ -1046,6 +1058,32 @@
type.getSource());
attachSource(root, null, null); // detach source
}
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=476304
+public void testInnerClass10() throws JavaModelException {
+ IJavaProject project = this.getJavaProject("/AttachSourceTests");
+ IPackageFragmentRoot root = project.getPackageFragmentRoot(getFile("/AttachSourceTests/innerClasses.jar"));
+ attachSource(root, "/AttachSourceTests/innerClassessrc.zip", null);
+ IPackageFragment fragment = root.getPackageFragment("inner");
+
+ IType type = fragment.getClassFile("X$Inner$WW.class").getType();
+ assertSourceEquals(
+ "Unexpected source",
+ "class WW {\n" +
+ " WW() {}\n" +
+ " class WWW {\n" +
+ " WWW() {}\n" +
+ " }\n" +
+ " }",
+ type.getSource());
+ type = fragment.getClassFile("X$Inner$WW$WWW.class").getType();
+ assertSourceEquals(
+ "Unexpected source",
+ "class WWW {\n" +
+ " WWW() {}\n" +
+ " }",
+ type.getSource());
+ attachSource(root, null, null); // detach source
+}
/**
* Ensures that a source folder can be attached to a lib folder.
*/
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
index b90ac98..824c5d5 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
@@ -14328,5 +14328,110 @@
if (ProjectA != null) deleteProject(ProjectA);
}
}
+/** @bug 476738
+ * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=476738"
+ */
+public void testBug476738_001() throws CoreException {
+ this.workingCopies = new ICompilationUnit[1];
+ this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/X.java",
+ "interface I { \n" +
+ " public void query(Foo.InnerKey key);// Search result of method query(Foo.InnerKey) returns the method query(Bar.InnerKey) too \n" +
+ " public void query(Bar.InnerKey key);\n" +
+ "}\n" +
+ "\n" +
+ "class Foo { \n" +
+ " static class InnerKey {}\n" +
+ "}\n" +
+ "class Bar {\n" +
+ " static class InnerKey {}\n" +
+ "}\n" +
+ "\n" +
+ "class X {\n" +
+ " public static void foo(I i, Foo.InnerKey key) {\n" +
+ " i.query(key);\n" +
+ " }\n" +
+ " public static void bar(I i, Bar.InnerKey key) {\n" +
+ " i.query(key);\n" +
+ " }\n" +
+ " public static I getInstance() {\n" +
+ " return null;\n" +
+ " }\n" +
+ "}\n"
+ );
+
+ String str = this.workingCopies[0].getSource();
+ String selection = "query";
+ int start = str.indexOf(selection);
+ int length = selection.length();
+
+ IJavaElement[] elements = this.workingCopies[0].codeSelect(start, length);
+ MethodPattern leftPattern = (MethodPattern) SearchPattern.createPattern(elements[0], REFERENCES, EXACT_RULE | ERASURE_RULE);
+ MethodPattern rightPattern = (MethodPattern) SearchPattern.createPattern(elements[0], REFERENCES, EXACT_RULE | ERASURE_RULE);
+ SearchPattern pattern = SearchPattern.createOrPattern(leftPattern, rightPattern);
+ new SearchEngine(this.workingCopies).search(pattern,
+ new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
+ getJavaSearchWorkingCopiesScope(),
+ this.resultCollector,
+ null);
+ assertSearchResults(
+ "src/X.java void X.foo(I, Foo.InnerKey) [query(key)] EXACT_MATCH"
+ );
+}
+/** @bug 476738
+ * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=476738"
+ */
+public void testBug476738_002() throws CoreException {
+ this.workingCopies = new ICompilationUnit[1];
+ this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/X.java",
+ "interface I { \n" +
+ " public void query/* one */(Foo.InnerKey key);// Search result of method query(Foo.InnerKey) returns the method query(Bar.InnerKey) too \n" +
+ " public void query/* two */(Bar.InnerKey key);\n" +
+ "}\n" +
+ "\n" +
+ "class Foo { \n" +
+ " static class InnerKey {}\n" +
+ "}\n" +
+ "class Bar {\n" +
+ " static class InnerKey {}\n" +
+ "}\n" +
+ "\n" +
+ "class X {\n" +
+ " public static void foo(I i, Foo.InnerKey key) {\n" +
+ " i.query(key);\n" +
+ " }\n" +
+ " public static void bar(I i, Bar.InnerKey key) {\n" +
+ " i.query(key);\n" +
+ " }\n" +
+ " public static I getInstance() {\n" +
+ " return null;\n" +
+ " }\n" +
+ "}\n"
+ );
+
+ String str = this.workingCopies[0].getSource();
+ String selection = "query";
+ String selection1 = "query/* one */";
+ String selection2 = "query/* two */";
+ int start = str.indexOf(selection1);
+ int length = selection.length();
+ IJavaElement[] elements = this.workingCopies[0].codeSelect(start, length);
+ MethodPattern leftPattern = (MethodPattern) SearchPattern.createPattern(elements[0], REFERENCES, EXACT_RULE | ERASURE_RULE);
+
+ start = str.indexOf(selection2);
+ length = selection.length();
+ elements = this.workingCopies[0].codeSelect(start, length);
+ MethodPattern rightPattern = (MethodPattern) SearchPattern.createPattern(elements[0], REFERENCES, EXACT_RULE | ERASURE_RULE);
+
+ SearchPattern pattern = SearchPattern.createOrPattern(leftPattern, rightPattern);
+ new SearchEngine(this.workingCopies).search(pattern,
+ new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
+ getJavaSearchWorkingCopiesScope(),
+ this.resultCollector,
+ null);
+ assertSearchResults(
+ "src/X.java void X.foo(I, Foo.InnerKey) [query(key)] EXACT_MATCH\n" +
+ "src/X.java void X.bar(I, Bar.InnerKey) [query(key)] EXACT_MATCH"
+ );
+}
}
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests2.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests2.java
index 5969c4c..4c0e682 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests2.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests2.java
@@ -18,10 +18,9 @@
import java.util.ArrayList;
import java.util.List;
-import junit.framework.Test;
-
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.IAccessRule;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
@@ -34,8 +33,12 @@
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchMatch;
import org.eclipse.jdt.core.search.SearchPattern;
+import org.eclipse.jdt.core.search.TypeNameMatch;
+import org.eclipse.jdt.core.search.TypeNameMatchRequestor;
import org.eclipse.jdt.internal.core.search.matching.MethodPattern;
+import junit.framework.Test;
+
// The size of JavaSearchBugsTests.java is very big, Hence continuing here.
@SuppressWarnings({"rawtypes", "unchecked"})
public class JavaSearchBugsTests2 extends AbstractJavaSearchTests {
@@ -1907,4 +1910,55 @@
deleteProject("P");
}
}
+
+ public void testBug473921() throws Exception {
+ try {
+ IJavaProject p = this.createJavaProject(
+ "P",
+ new String[] {},
+ new String[] { "/P/lib473921.jar", "JCL17_LIB" },
+ new String[][] {{ "p/*" }, { }},
+ new String[][] {{ "**/*" }, { }},
+ null/*no project*/,
+ null/*no inclusion pattern*/,
+ null/*no exclusion pattern*/,
+ null/*no exported project*/,
+ "",
+ null/*no source outputs*/,
+ null/*no inclusion pattern*/,
+ null/*no exclusion pattern*/,
+ "1.7"
+ );
+ org.eclipse.jdt.core.tests.util.Util.createJar(
+ new String[] {
+ "p/Enclosing.java",
+ "package p;\n" +
+ "public class Enclosing { enum Nested { A, B } }\n"
+ },
+ p.getProject().getLocation().append("lib473921.jar").toOSString(),
+ "1.7");
+ refresh(p);
+
+ IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { p });
+ class Collector extends TypeNameMatchRequestor {
+ List<TypeNameMatch> matches = new ArrayList<>();
+ @Override
+ public void acceptTypeNameMatch(TypeNameMatch match) {
+ this.matches.add(match);
+ }
+ }
+ Collector collector = new Collector();
+ new SearchEngine().searchAllTypeNames(
+ null,
+ new char[][] { "Nested".toCharArray() },
+ scope,
+ collector,
+ IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
+ null);
+ assertEquals(1, collector.matches.size());
+ assertEquals(IAccessRule.K_ACCESSIBLE, collector.matches.get(0).getAccessibility());
+ } finally {
+ deleteProject("P");
+ }
+ }
}
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite18Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite18Test.java
index 055fd36..ec3300a 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite18Test.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite18Test.java
@@ -22,11 +22,14 @@
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.Annotation;
+import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.ExpressionStatement;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.MarkerAnnotation;
import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.NormalAnnotation;
import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
@@ -752,6 +755,48 @@
}
}
+ public void testBug474270_since_8() throws Exception {
+ String contents =
+ "package pack1;\n" +
+ "import java.util.Comparator;\n" +
+ "interface Comparator<T> {\n" +
+ " int compare(T o1, T o2);\n" +
+ " public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {\n" +
+ " return null;\n" +
+ " }\n" +
+ "}\n" +
+ "public class X {\n" +
+ " Comparator mComparator1 = null;\n" +
+ " Comparator mComparator2 = (pObj1, pObj2) -> mComparator1.compare(pObj1, pObj2);\n" +
+ " X() {mComparator1 = Comparator.naturalOrder();}\n" +
+ "}\n";
+ createFolder("/" + PROJECT + "/src/pack1");
+ createFile("/" + PROJECT + "/src/pack1/X.java", contents);
+
+ ICompilationUnit cu = getCompilationUnit("/" + PROJECT + "/src/pack1/X.java");
+ ASTParser parser = ASTParser.newParser(AST.JLS8);
+ parser.setSource(cu);
+ parser.setResolveBindings(true);
+ parser.setStatementsRecovery(true);
+ CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);
+ TypeDeclaration type= (TypeDeclaration) astRoot.types().get(1);
+ MethodDeclaration [] methods = type.getMethods();
+ MethodDeclaration method = methods[0];
+ ExpressionStatement stmt = (ExpressionStatement) method.getBody().statements().get(0);
+ Assignment assignment = (Assignment) stmt.getExpression();
+ MethodInvocation invocation = (MethodInvocation) assignment.getRightHandSide();
+ ITypeBinding typeBinding = invocation.resolveTypeBinding();
+ typeBinding = typeBinding.getDeclaredMethods()[0].getParameterTypes()[0];
+ contents = "package pack2;\n" +
+ "\n" +
+ "public class A{}\n";
+ createFolder("/" + PROJECT + "/src/pack2");
+ createFile("/" + PROJECT + "/src/pack2/A.java", contents);
+ cu = getCompilationUnit("/" + PROJECT + "/src/pack2/A.java");
+ ImportRewrite rewrite = newImportsRewrite(cu, new String[0], 99, 99, true);
+ rewrite.addImport(typeBinding, astRoot.getAST());
+ }
+
private void assertEqualStringIgnoreDelim(String actual, String expected) throws IOException {
StringAsserts.assertEqualStringIgnoreDelim(actual, expected);
}
diff --git a/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR308/testLambda/A_out.java b/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR308/testLambda/A_out.java
index ac92b6f..24670c6 100644
--- a/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR308/testLambda/A_out.java
+++ b/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR308/testLambda/A_out.java
@@ -44,7 +44,7 @@
}
}
- .howMany();
+ .howMany();
};
}
diff --git a/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambda/A_out.java b/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambda/A_out.java
index 11e7d9a..1638629 100644
--- a/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambda/A_out.java
+++ b/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambda/A_out.java
@@ -48,7 +48,7 @@
}
}
- .howMany();
+ .howMany();
};
}
diff --git a/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambdaOptions/A_out.java b/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambdaOptions/A_out.java
index 2c0e1f0..05a86b6 100644
--- a/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambdaOptions/A_out.java
+++ b/org.eclipse.jdt.core.tests.model/workspace/FormatterJSR335/testLambdaOptions/A_out.java
@@ -51,7 +51,7 @@
}
}
- .howMany();
+ .howMany();
};
}
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
index 391c763..6968ee2 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
@@ -683,6 +683,14 @@
}
}
+ public void logUnavaibleAPT(String className) {
+ if ((this.tagBits & Logger.XML) != 0) {
+ this.parameters.put(Logger.MESSAGE, this.main.bind("configure.unavailableAPT", className)); //$NON-NLS-1$
+ printTag(Logger.ERROR_TAG, this.parameters, true, true);
+ }
+ this.printlnErr(this.main.bind("configure.unavailableAPT", className)); //$NON-NLS-1$
+ }
+
public void logIncorrectVMVersionForAnnotationProcessing() {
if ((this.tagBits & Logger.XML) != 0) {
this.parameters.put(Logger.MESSAGE, this.main.bind("configure.incorrectVMVersionforAPT")); //$NON-NLS-1$
@@ -4030,17 +4038,16 @@
this.classNames = null;
}
protected void initializeAnnotationProcessorManager() {
+ String className = "org.eclipse.jdt.internal.compiler.apt.dispatch.BatchAnnotationProcessorManager"; //$NON-NLS-1$
try {
- Class c = Class.forName("org.eclipse.jdt.internal.compiler.apt.dispatch.BatchAnnotationProcessorManager"); //$NON-NLS-1$
+ Class c = Class.forName(className);
AbstractAnnotationProcessorManager annotationManager = (AbstractAnnotationProcessorManager) c.newInstance();
annotationManager.configure(this, this.expandedCommandLine);
annotationManager.setErr(this.err);
annotationManager.setOut(this.out);
this.batchCompiler.annotationProcessorManager = annotationManager;
- } catch (ClassNotFoundException e) {
- // ignore
- } catch (InstantiationException e) {
- // should not happen
+ } catch (ClassNotFoundException | InstantiationException e) {
+ this.logger.logUnavaibleAPT(className);
throw new org.eclipse.jdt.internal.compiler.problem.AbortCompilation();
} catch (IllegalAccessException e) {
// should not happen
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
index cceb509..25f27ab 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
@@ -104,6 +104,7 @@
configure.accessRuleAfterDestinationPath = access rules cannot follow destination path entries: {0}
configure.duplicateDestinationPathEntry = duplicate destination path entry in {0} option
configure.invalidClassName = invalid class name: {0}
+configure.unavailableAPT = Unable to load annotation processing manager {0} from classpath.
configure.incorrectVMVersionforAPT = Annotation processing got disabled, since it requires a 1.6 compliant JVM
configure.incompatibleSourceForCldcTarget=Target level ''{0}'' is incompatible with source level ''{1}''. A source level ''1.3'' or lower is required
configure.incompatibleComplianceForCldcTarget=Target level ''{0}'' is incompatible with compliance level ''{1}''. A compliance level ''1.4''or lower is required
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistParser.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistParser.java
index 555bdcf..4be2814 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistParser.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistParser.java
@@ -2022,6 +2022,7 @@
prepareForHeaders();
goForHeaders();
this.diet = true; // passed this point, will not consider method bodies
+ this.dietInt = 0;
}
return RESTART;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CategorizedProblem.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CategorizedProblem.java
index 3fe14ec..55b0453 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CategorizedProblem.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CategorizedProblem.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2008 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -149,4 +149,13 @@
public Object[] getExtraMarkerAttributeValues() {
return DefaultProblem.EMPTY_VALUES;
}
+/**
+ * {@inheritDoc}
+ * <p>Note: This implementation always returns <code>false</code>, subclasses can override.</p>
+ *
+ * @since 3.12
+ */
+public boolean isInfo() {
+ return false;
+}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java
index d30135f..e92d6bf 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java
@@ -302,6 +302,14 @@
boolean isWarning();
/**
+ * Checks the severity to see if the problem is an information.
+ *
+ * @return true if the information bit is set for the severity, false otherwise
+ * @since 3.12
+ */
+boolean isInfo();
+
+/**
* Set the end position of the problem (inclusive), or -1 if unknown.
* Used for shifting problem positions.
*
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
index 8720e8f..4b0996d 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
@@ -4004,7 +4004,8 @@
if (isConstructor) { // insert String name,int ordinal
length = writeArgumentName(ConstantPool.EnumName, ClassFileConstants.AccSynthetic, length);
length = writeArgumentName(ConstantPool.EnumOrdinal, ClassFileConstants.AccSynthetic, length);
- } else if (CharOperation.equals(ConstantPool.ValueOf, binding.selector)) { // insert String name
+ } else if (binding instanceof SyntheticMethodBinding
+ && CharOperation.equals(ConstantPool.ValueOf, binding.selector)) { // insert String name
length = writeArgumentName(ConstantPool.Name, ClassFileConstants.AccMandated, length);
targetParameters = Binding.NO_PARAMETERS; // Override "unknown" synthetics below
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
index 6eb5627..4651364 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
@@ -40,6 +40,8 @@
* bug 412153 - [1.8][compiler] Check validity of annotations which may be repeatable
* bug 412149 - [1.8][compiler] Emit repeated annotations into the designated container
* bug 419209 - [1.8] Repeating container annotations should be rejected in the presence of annotation it contains
+ * Till Brychcy - Contributions for
+ * bug 467094 - [1.8][null] TYPE_USE NullAnnotations of array contents are applied to field.
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;
@@ -988,6 +990,9 @@
local.declaration.bits |= HasTypeAnnotations;
typeRef.bits |= HasTypeAnnotations;
local.type = mergeAnnotationsIntoType(scope, se8Annotations, se8nullBits, se8NullAnnotation, typeRef, local.type);
+ if(scope.environment().usesNullTypeAnnotations()) {
+ local.tagBits &= ~(se8nullBits);
+ }
}
break;
case Binding.FIELD:
@@ -998,6 +1003,9 @@
fieldDeclaration.bits |= HasTypeAnnotations;
fieldDeclaration.type.bits |= HasTypeAnnotations;
field.type = mergeAnnotationsIntoType(scope, se8Annotations, se8nullBits, se8NullAnnotation, fieldDeclaration.type, field.type);
+ if(scope.environment().usesNullTypeAnnotations()) {
+ field.tagBits &= ~(se8nullBits);
+ }
}
break;
case Binding.METHOD:
@@ -1009,6 +1017,9 @@
methodDecl.bits |= HasTypeAnnotations;
methodDecl.returnType.bits |= HasTypeAnnotations;
method.returnType = mergeAnnotationsIntoType(scope, se8Annotations, se8nullBits, se8NullAnnotation, methodDecl.returnType, method.returnType);
+ if(scope.environment().usesNullTypeAnnotations()) {
+ method.tagBits &= ~(se8nullBits);
+ }
}
}
break;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java
index 47cfc81..3cb59b1 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java
@@ -42,6 +42,7 @@
}
targetContext.recordAbruptExit();
+ targetContext.expireNullCheckedFieldInfo();
this.initStateIndex =
currentScope.methodScope().recordInitializationStates(flowInfo);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
index c42960c..df99b84 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
@@ -447,7 +447,7 @@
if (valueRequired || needRuntimeCheckcast || annotatedCast) { // Added for: 1F1W9IG: IVJCOM:WINNT - Compiler omits casting check
codeStream.generateConstant(this.constant, this.implicitConversion);
if (needRuntimeCheckcast || annotatedCast) {
- codeStream.checkcast(this.type, this.resolvedType);
+ codeStream.checkcast(this.type, this.resolvedType, pc);
}
if (!valueRequired) {
// the resolveType cannot be double or long
@@ -459,7 +459,7 @@
}
this.expression.generateCode(currentScope, codeStream, annotatedCast || valueRequired || needRuntimeCheckcast);
if (annotatedCast || (needRuntimeCheckcast && TypeBinding.notEquals(this.expression.postConversionType(currentScope), this.resolvedType.erasure()))) { // no need to issue a checkcast if already done as genericCast
- codeStream.checkcast(this.type, this.resolvedType);
+ codeStream.checkcast(this.type, this.resolvedType, pc);
}
if (valueRequired) {
codeStream.generateImplicitConversion(this.implicitConversion);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java
index a6f946d..30b7d4c 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java
@@ -42,6 +42,7 @@
}
targetContext.recordAbruptExit();
+ targetContext.expireNullCheckedFieldInfo();
if (targetContext == FlowContext.NotContinuableContext) {
currentScope.problemReporter().invalidContinue(this);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java
index a9b9c86..bf90d3a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java
@@ -16,6 +16,8 @@
* Bug 458396 - NPE in CodeStream.invoke()
* Jesper S Moller - Contributions for
* Bug 378674 - "The method can be declared as static" is wrong
+ * Robert Roth <robert.roth.off@gmail.com> - Contributions for
+ * Bug 361039 - NPE in FieldReference.optimizedBooleanConstant
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;
@@ -552,6 +554,8 @@
}
public Constant optimizedBooleanConstant() {
+ if (this.resolvedType == null)
+ return Constant.NotAConstant;
switch (this.resolvedType.id) {
case T_boolean :
case T_JavaLangBoolean :
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java
index 936c293..f1145cd 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java
@@ -103,6 +103,8 @@
}
}
thenFlowInfo = this.thenStatement.analyseCode(currentScope, flowContext, thenFlowInfo);
+ if (!(this.thenStatement instanceof Block))
+ flowContext.expireNullCheckedFieldInfo();
}
// any null check from the condition is now expired
flowContext.expireNullCheckedFieldInfo();
@@ -131,6 +133,8 @@
}
}
elseFlowInfo = this.elseStatement.analyseCode(currentScope, flowContext, elseFlowInfo);
+ if (!(this.elseStatement instanceof Block))
+ flowContext.expireNullCheckedFieldInfo();
}
// process AutoCloseable resources closed in only one branch:
currentScope.correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
index 877114a..a615681 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
@@ -425,6 +425,8 @@
if (this.body instanceof Expression) {
Expression expression = (Expression) this.body;
new ReturnStatement(expression, expression.sourceStart, expression.sourceEnd, true).resolve(this.scope); // :-) ;-)
+ if (expression.resolvedType == TypeBinding.VOID && !expression.statementExpression())
+ this.scope.problemReporter().invalidExpressionAsStatement(expression);
} else {
this.body.resolve(this.scope);
/* At this point, shape analysis is complete for ((see returnsExpression(...))
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java
index ad77677..845d662 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java
@@ -66,6 +66,7 @@
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
+import org.eclipse.jdt.internal.compiler.lookup.ImplicitNullAnnotationVerifier;
import org.eclipse.jdt.internal.compiler.lookup.InferenceContext18;
import org.eclipse.jdt.internal.compiler.lookup.IntersectionTypeBinding18;
import org.eclipse.jdt.internal.compiler.lookup.InvocationSite;
@@ -741,8 +742,14 @@
}
protected void checkNullAnnotations(BlockScope scope) {
- if (scope.compilerOptions().isAnnotationBasedNullAnalysisEnabled) {
+ CompilerOptions compilerOptions = scope.compilerOptions();
+ if (compilerOptions.isAnnotationBasedNullAnalysisEnabled) {
if (this.expectedType == null || !NullAnnotationMatching.hasContradictions(this.expectedType)) { // otherwise assume it has been reported and we can do nothing here
+ if ((this.binding.tagBits & TagBits.IsNullnessKnown) == 0) {
+ // not interested in reporting problems against this.binding:
+ new ImplicitNullAnnotationVerifier(scope.environment(), compilerOptions.inheritNullAnnotations)
+ .checkImplicitNullAnnotations(this.binding, null/*srcMethod*/, false, scope);
+ }
// TODO: simplify by using this.freeParameters?
int len;
int expectedlen = this.binding.parameters.length;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java
index cb1f37b..25d348d 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java
@@ -171,6 +171,7 @@
currentScope.checkUnclosedCloseables(flowInfo, flowContext, this, currentScope);
// inside conditional structure respect that a finally-block may conditionally be entered directly from here
flowContext.recordAbruptExit();
+ flowContext.expireNullCheckedFieldInfo();
return FlowInfo.DEAD_END;
}
@Override
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java
index ce13931..5f6e111 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java
@@ -123,6 +123,7 @@
if (caseInits == FlowInfo.DEAD_END) {
fallThroughState = ESCAPING;
}
+ switchContext.expireNullCheckedFieldInfo();
}
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java
index aafe24b..9fa7cbf 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java
@@ -116,14 +116,14 @@
@Override
public ITypeAnnotationWalker toMethodParameter(short index) {
- // don't set nextIsDefaultLocation, because signature-level nullness is handled by ImplicitNullAnnotationVerifier
+ // don't set nextIsDefaultLocation, because signature-level nullness is handled by ImplicitNullAnnotationVerifier (triggered per invocation via MessageSend.resolveType() et al)
if (this.isEmpty) return restrict(this.matches, this.pathPtr);
return super.toMethodParameter(index);
}
@Override
public ITypeAnnotationWalker toMethodReturn() {
- // don't set nextIsDefaultLocation, because signature-level nullness is handled by ImplicitNullAnnotationVerifier
+ // don't set nextIsDefaultLocation, because signature-level nullness is handled by ImplicitNullAnnotationVerifier (triggered per invocation via MessageSend.resolveType() et al)
if (this.isEmpty) return restrict(this.matches, this.pathPtr);
return super.toMethodReturn();
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
index 85da064..045f8d4 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
@@ -656,10 +656,10 @@
}
public void checkcast(TypeBinding typeBinding) {
- this.checkcast(null, typeBinding);
+ this.checkcast(null, typeBinding, -1);
}
-public void checkcast(TypeReference typeReference, TypeBinding typeBinding) {
+public void checkcast(TypeReference typeReference, TypeBinding typeBinding, int currentPosition) {
this.countLabels = 0;
if (this.classFileOffset + 2 >= this.bCodeStream.length) {
resizeByteArray();
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/TypeAnnotationCodeStream.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/TypeAnnotationCodeStream.java
index 66cfc2d..2be341c 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/TypeAnnotationCodeStream.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/TypeAnnotationCodeStream.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2012, 2014 IBM Corporation and others.
+ * Copyright (c) 2012, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -81,7 +81,7 @@
super.newArray(typeReference, allocationExpression, arrayBinding);
}
- public void checkcast(TypeReference typeReference, TypeBinding typeBinding) {
+ public void checkcast(TypeReference typeReference, TypeBinding typeBinding, int currentPosition) {
/* We use a slightly sub-optimal generation for intersection casts by resorting to a runtime cast for every intersecting type, but in
reality this should not matter. In its intended use form such as (I & Serializable) () -> {}, no cast is emitted at all. Also note
intersection cast type references cannot nest i.e ((X & I) & J) is not valid syntax.
@@ -91,13 +91,21 @@
for (int i = typeReferences.length - 1; i >= 0; i--) { // need to emit right to left.
typeReference = typeReferences[i];
if (typeReference != null) {
- if ((typeReference.bits & ASTNode.HasTypeAnnotations) != 0)
- addAnnotationContext(typeReference, this.position, i, AnnotationTargetTypeConstants.CAST);
- super.checkcast(typeReference, typeReference.resolvedType);
+ if ((typeReference.bits & ASTNode.HasTypeAnnotations) != 0) {
+ if (!typeReference.resolvedType.isBaseType()) {
+ addAnnotationContext(typeReference, this.position, i, AnnotationTargetTypeConstants.CAST);
+ } else {
+ // for base type record it against the start position of the expression
+ addAnnotationContext(typeReference, currentPosition, i, AnnotationTargetTypeConstants.CAST);
+ }
+ }
+ if (!typeReference.resolvedType.isBaseType()) {
+ super.checkcast(typeReference, typeReference.resolvedType, currentPosition);
+ }
}
}
} else {
- super.checkcast(null, typeBinding);
+ super.checkcast(null, typeBinding, currentPosition);
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java
index 61d54b5..9e3b20f 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BoundSet.java
@@ -9,6 +9,7 @@
* Stephan Herrmann - initial API and implementation
* Lars Vogel <Lars.Vogel@vogella.com> - Contributions for
* Bug 473178
+ * IBM Corporation - Bug fixes
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;
@@ -182,7 +183,21 @@
return copy;
}
public TypeBinding findSingleWrapperType() {
- TypeBinding wrapperBound = null;
+ if (this.instantiation != null) {
+ if (this.instantiation.isProperType(true)) {
+ switch (this.instantiation.id) {
+ case TypeIds.T_JavaLangByte:
+ case TypeIds.T_JavaLangShort:
+ case TypeIds.T_JavaLangCharacter:
+ case TypeIds.T_JavaLangInteger:
+ case TypeIds.T_JavaLangLong:
+ case TypeIds.T_JavaLangFloat:
+ case TypeIds.T_JavaLangDouble:
+ case TypeIds.T_JavaLangBoolean:
+ return this.instantiation;
+ }
+ }
+ }
if (this.subBounds != null) {
Iterator<TypeBound> it = this.subBounds.iterator();
while(it.hasNext()) {
@@ -197,9 +212,7 @@
case TypeIds.T_JavaLangFloat:
case TypeIds.T_JavaLangDouble:
case TypeIds.T_JavaLangBoolean:
- if (wrapperBound != null)
- return null;
- wrapperBound = boundType;
+ return boundType;
}
}
}
@@ -218,14 +231,12 @@
case TypeIds.T_JavaLangFloat:
case TypeIds.T_JavaLangDouble:
case TypeIds.T_JavaLangBoolean:
- if (wrapperBound != null)
- return null;
- wrapperBound = boundType;
+ return boundType;
}
}
}
}
- return wrapperBound;
+ return null;
}
/**
* Not per JLS: enhance the given type bounds using the nullHints, if useful.
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java
index 9b4b32e..c51a617 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java
@@ -110,11 +110,7 @@
return ConstraintTypeFormula.create(exprType, this.right, COMPATIBLE, this.isSoft);
}
if (innerCtx.stepCompleted >= InferenceContext18.APPLICABILITY_INFERRED) {
- inferenceContext.currentBounds.addBounds(innerCtx.b2, inferenceContext.environment);
- inferenceContext.inferenceVariables = innerCtx.inferenceVariables;
- inferenceContext.inferenceKind = innerCtx.inferenceKind;
- innerCtx.outerContext = inferenceContext;
- inferenceContext.usesUncheckedConversion = innerCtx.usesUncheckedConversion;
+ inferenceContext.integrateInnerInferenceB2(innerCtx);
} else {
return FALSE; // should not reach here.
}
@@ -362,11 +358,7 @@
// spec says erasure, but we don't really have compatibility rules for erasure, use raw type instead:
TypeBinding erasure = inferenceContext.environment.convertToRawType(returnType, false);
ConstraintTypeFormula newConstraint = ConstraintTypeFormula.create(erasure, targetType, COMPATIBLE);
- if (!inferenceContext.reduceAndIncorporate(newConstraint))
- return false;
- // continuing at true is not spec'd but needed for javac-compatibility,
- // see org.eclipse.jdt.core.tests.compiler.regression.GenericsRegressionTest_1_8.testBug428198()
- // and org.eclipse.jdt.core.tests.compiler.regression.GenericsRegressionTest_1_8.testBug428264()
+ return inferenceContext.reduceAndIncorporate(newConstraint);
}
TypeBinding rTheta = inferenceContext.substitute(returnType);
ParameterizedTypeBinding parameterizedType = InferenceContext18.parameterizedWithWildcard(rTheta);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
index 1d3415d..7c6d065 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
@@ -15,6 +15,8 @@
* Bug 435805 - [1.8][compiler][null] Java 8 compiler does not recognize declaration style null annotations
* Bug 458396 - NPE in CodeStream.invoke()
* Bug 446217 - [null] @NonNullByDefault in package-info.java causes bogus "null type safety" warning
+ * Till Brychcy - Contribution for
+ * bug 467094 - [1.8][null] TYPE_USE NullAnnotations of array contents are applied to field.
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;
@@ -245,21 +247,23 @@
}
public void fillInDefaultNonNullness(FieldDeclaration sourceField, Scope scope) {
+ if (this.type == null || this.type.isBaseType())
+ return;
LookupEnvironment environment = scope.environment();
- if (this.type == null)
- return;
- if (environment.usesNullTypeAnnotations() && !this.type.acceptsNonNullDefault())
- return;
- if ( !this.type.isBaseType()
- && (this.tagBits & TagBits.AnnotationNullMASK) == 0 // declaration annotation?
- && (this.type.tagBits & TagBits.AnnotationNullMASK) == 0) // type annotation? (java.lang.@Nullable String)
- {
- if (environment.usesNullTypeAnnotations())
+ if (environment.usesNullTypeAnnotations()) {
+ if (!this.type.acceptsNonNullDefault())
+ return;
+ if ( (this.type.tagBits & TagBits.AnnotationNullMASK) == 0) {
this.type = environment.createAnnotatedType(this.type, new AnnotationBinding[]{environment.getNonNullAnnotation()});
- else
+ } else if ((this.type.tagBits & TagBits.AnnotationNonNull) != 0) {
+ scope.problemReporter().nullAnnotationIsRedundant(sourceField);
+ }
+ } else {
+ if ( (this.tagBits & TagBits.AnnotationNullMASK) == 0 ) {
this.tagBits |= TagBits.AnnotationNonNull;
- } else if ((this.tagBits & TagBits.AnnotationNonNull) != 0) {
- scope.problemReporter().nullAnnotationIsRedundant(sourceField);
+ } else if ((this.tagBits & TagBits.AnnotationNonNull) != 0) {
+ scope.problemReporter().nullAnnotationIsRedundant(sourceField);
+ }
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java
index 2da3f5c..ea1e31c 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java
@@ -128,6 +128,7 @@
/** The inference variables for which as solution is sought. */
InferenceVariable[] inferenceVariables;
+ int nextVarId;
/** Constraints that have not yet been reduced and incorporated. */
ConstraintFormula[] initialConstraints;
@@ -179,7 +180,7 @@
if (i >= len)
System.arraycopy(interned, 0, outermostContext.internedVariables = new InferenceVariable[len+10], 0, len);
}
- return outermostContext.internedVariables[i] = new InferenceVariable(typeParameter, rank, i, site, this.environment, this.object);
+ return outermostContext.internedVariables[i] = new InferenceVariable(typeParameter, rank, this.nextVarId++, site, this.environment, this.object);
}
public static final int CHECK_UNKNOWN = 0;
@@ -1399,6 +1400,16 @@
return record;
}
+ public void integrateInnerInferenceB2(InferenceContext18 innerCtx) {
+ this.currentBounds.addBounds(innerCtx.b2, this.environment);
+ this.inferenceVariables = innerCtx.inferenceVariables;
+ this.inferenceKind = innerCtx.inferenceKind;
+ innerCtx.outerContext = this;
+ this.usesUncheckedConversion = innerCtx.usesUncheckedConversion;
+ for (InferenceVariable variable : this.inferenceVariables)
+ variable.updateSourceName(this.nextVarId++);
+ }
+
public void resumeSuspendedInference(SuspendedInferenceRecord record) {
// merge inference variables:
if (this.inferenceVariables == null) { // no new ones, assume we aborted prematurely
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java
index 060e4cf..b999b85 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java
@@ -23,11 +23,13 @@
TypeBinding typeParameter;
long nullHints; // one of TagBits.{AnnotationNonNull,AnnotationNullable} may steer inference into inferring nullness as well; set both bits to request avoidance.
private InferenceVariable prototype;
+ int varId; // this is used for constructing a source name like T#0. NB: varId and sourceName are mutable, to be updated when two InferenceContext18 are integrated.
public InferenceVariable(TypeBinding typeParameter, int parameterRank, int iVarId, InvocationSite site, LookupEnvironment environment, ReferenceBinding object) {
this(typeParameter, parameterRank, site,
CharOperation.concat(typeParameter.shortReadableName(), Integer.toString(iVarId).toCharArray(), '#'),
environment, object);
+ this.varId = iVarId;
}
private InferenceVariable(TypeBinding typeParameter, int parameterRank, InvocationSite site, char[] sourceName, LookupEnvironment environment, ReferenceBinding object) {
super(sourceName, null/*declaringElement*/, parameterRank, environment);
@@ -47,12 +49,21 @@
this.superclass = object;
this.prototype = this;
}
+ void updateSourceName(int newId) {
+ int hashPos = CharOperation.indexOf('#', this.sourceName);
+ this.varId = newId;
+ this.sourceName = CharOperation.concat(
+ CharOperation.subarray(this.sourceName, 0, hashPos),
+ Integer.toString(this.varId).toCharArray(),
+ '#');
+ }
@Override
public TypeBinding clone(TypeBinding enclosingType) {
InferenceVariable clone = new InferenceVariable(this.typeParameter, this.rank, this.site, this.sourceName, this.environment, this.superclass);
clone.tagBits = this.tagBits;
clone.nullHints = this.nullHints;
+ clone.varId = this.varId;
clone.prototype = this;
return clone;
}
@@ -119,16 +130,19 @@
}
public int hashCode() {
- if (this.sourceName != null)
- return this.sourceName.hashCode();
- return super.hashCode();
+ int code = this.typeParameter.hashCode() + 17 * this.rank;
+ if (this.site != null)
+ return 31 * code + this.site.hashCode();
+ else
+ return code;
}
public boolean equals(Object obj) {
if (!(obj instanceof InferenceVariable))
return false;
- if (this.sourceName != null)
- return this.sourceName.equals(((InferenceVariable)obj).sourceName);
- return super.equals(obj);
+ InferenceVariable other = (InferenceVariable) obj;
+ return this.rank == other.rank
+ && this.site == other.site
+ && TypeBinding.equalsEquals(this.typeParameter, other.typeParameter);
}
public TypeBinding erasure() {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java
index 3b5083d..8882848 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java
@@ -810,6 +810,11 @@
}
public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, TypeBinding[] typeArguments) {
+ return createParameterizedGenericMethod(genericMethod, typeArguments, false, false);
+}
+public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, TypeBinding[] typeArguments,
+ boolean inferredWithUncheckedConversion, boolean hasReturnProblem)
+{
// cached info is array of already created parameterized types for this type
ParameterizedGenericMethodBinding[] cachedInfo = (ParameterizedGenericMethodBinding[])this.uniqueParameterizedGenericMethodBindings.get(genericMethod);
int argLength = typeArguments == null ? 0: typeArguments.length;
@@ -828,6 +833,12 @@
for (int j = 0; j < cachedArgLength; j++){
if (typeArguments[j] != cachedArguments[j]) continue nextCachedMethod; //$IDENTITY-COMPARISON$
}
+ if (inferredWithUncheckedConversion) { // JSL 18.5.2: "If unchecked conversion was necessary..."
+ // don't tolerate remaining parameterized types / type variables, should have been eliminated by erasure:
+ if (cachedMethod.returnType.isParameterizedType() || cachedMethod.returnType.isTypeVariable()) continue;
+ for (TypeBinding exc : cachedMethod.thrownExceptions)
+ if (exc.isParameterizedType() || exc.isTypeVariable()) continue nextCachedMethod;
+ }
// all arguments match, reuse current
return cachedMethod;
}
@@ -843,7 +854,8 @@
this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
}
// add new binding
- ParameterizedGenericMethodBinding parameterizedGenericMethod = new ParameterizedGenericMethodBinding(genericMethod, typeArguments, this);
+ ParameterizedGenericMethodBinding parameterizedGenericMethod =
+ new ParameterizedGenericMethodBinding(genericMethod, typeArguments, this, inferredWithUncheckedConversion, hasReturnProblem);
cachedInfo[index] = parameterizedGenericMethod;
return parameterizedGenericMethod;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java
index 1789afe..1f0446b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2013 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -188,7 +188,8 @@
}
}
}
- checkForBridgeMethod(currentMethod, inheritedMethod, allInheritedMethods);
+ if (!inheritedMethod.isStatic() && !inheritedMethod.isFinal())
+ checkForBridgeMethod(currentMethod, inheritedMethod, allInheritedMethods);
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
index 905fdf8..2fa02c9 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -338,7 +338,7 @@
} else {
if (concreteMethod != null && concreteMethod.isDefaultMethod()) {
if (this.environment.globalOptions.complianceLevel >= ClassFileConstants.JDK1_8) {
- if (!checkInheritedDefaultMethods(methods, length))
+ if (!checkInheritedDefaultMethods(methods, isOverridden, length))
return;
}
}
@@ -346,21 +346,21 @@
super.checkInheritedMethods(methods, length, isOverridden, isInherited);
}
}
-boolean checkInheritedDefaultMethods(MethodBinding[] methods, int length) {
- // JLS8 9.4.1 (interface) and 8.4.8.4 (class):
+boolean checkInheritedDefaultMethods(MethodBinding[] methods, boolean[] isOverridden, int length) {
+ // JLS8 9.4.1.3 (interface) and 8.4.8.4 (class):
// default method clashes with other inherited method which is override-equivalent
if (length < 2) return true;
boolean ok = true;
findDefaultMethod: for (int i=0; i<length; i++) {
- if (methods[i].isDefaultMethod()) {
+ if (methods[i].isDefaultMethod() && !isOverridden[i]) {
findEquivalent: for (int j=0; j<length; j++) {
- if (j == i) continue findEquivalent;
+ if (j == i || isOverridden[j]) continue findEquivalent;
if (isMethodSubsignature(methods[i], methods[j])) {
if (!doesMethodOverride(methods[i], methods[j]) && !doesMethodOverride(methods[j], methods[i])) {
problemReporter().inheritedDefaultMethodConflictsWithOtherInherited(this.type, methods[i], methods[j]);
ok = false;
+ continue findDefaultMethod;
}
- continue findDefaultMethod;
}
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
index 6c22117..f7ab036 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
@@ -263,7 +263,7 @@
// assemble the solution etc:
TypeBinding[] solutions = infCtx18.getSolutions(typeVariables, invocationSite, result);
if (solutions != null) {
- methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, solutions);
+ methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, solutions, infCtx18.usesUncheckedConversion, hasReturnProblem);
if (invocationSite instanceof Invocation)
infCtx18.forwardResults(result, (Invocation) invocationSite, methodSubstitute, expectedType);
if (hasReturnProblem) { // illegally working from the provisional result?
@@ -529,7 +529,7 @@
/**
* Create method of parameterized type, substituting original parameters with type arguments.
*/
- public ParameterizedGenericMethodBinding(MethodBinding originalMethod, TypeBinding[] typeArguments, LookupEnvironment environment) {
+ public ParameterizedGenericMethodBinding(MethodBinding originalMethod, TypeBinding[] typeArguments, LookupEnvironment environment, boolean inferredWithUncheckConversion, boolean hasReturnProblem) {
this.environment = environment;
this.modifiers = originalMethod.modifiers;
this.selector = originalMethod.selector;
@@ -541,8 +541,16 @@
this.originalMethod = originalMethod;
this.parameters = Scope.substitute(this, originalMethod.parameters);
// error case where exception type variable would have been substituted by a non-reference type (207573)
- this.returnType = Scope.substitute(this, originalMethod.returnType);
- this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions);
+ if (inferredWithUncheckConversion) { // JSL 18.5.2: "If unchecked conversion was necessary..."
+ this.returnType = getErasure18_5_2(originalMethod.returnType, environment, hasReturnProblem); // propagate simulation of Bug JDK_8026527
+ this.thrownExceptions = new ReferenceBinding[originalMethod.thrownExceptions.length];
+ for (int i = 0; i < originalMethod.thrownExceptions.length; i++) {
+ this.thrownExceptions[i] = (ReferenceBinding) getErasure18_5_2(originalMethod.thrownExceptions[i], environment, false); // no excuse for exceptions
+ }
+ } else {
+ this.returnType = Scope.substitute(this, originalMethod.returnType);
+ this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions);
+ }
if (this.thrownExceptions == null) this.thrownExceptions = Binding.NO_EXCEPTIONS;
checkMissingType: {
if ((this.tagBits & TagBits.HasMissingType) != 0)
@@ -582,6 +590,16 @@
}
}
+ TypeBinding getErasure18_5_2(TypeBinding type, LookupEnvironment env, boolean substitute) {
+ // opportunistic interpretation of (JLS 18.5.2):
+ // "If unchecked conversion was necessary ..., then ...
+ // the return type and thrown types of the invocation type of m are given by
+ // the erasure of the return type and thrown types of m's type."
+ if (substitute)
+ type = Scope.substitute(this, type);
+ return env.convertToRawType(type, true);
+ }
+
/*
* parameterizedDeclaringUniqueKey dot selector originalMethodGenericSignature percent typeArguments
* p.X<U> { <T> void bar(T t, U u) { new X<String>().bar(this, "") } } --> Lp/X<Ljava/lang/String;>;.bar<T:Ljava/lang/Object;>(TT;Ljava/lang/String;)V%<Lp/X;>
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/PolyParameterizedGenericMethodBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/PolyParameterizedGenericMethodBinding.java
index 3a5f6c4..29ed92b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/PolyParameterizedGenericMethodBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/PolyParameterizedGenericMethodBinding.java
@@ -14,7 +14,7 @@
private ParameterizedGenericMethodBinding wrappedBinding;
public PolyParameterizedGenericMethodBinding(ParameterizedGenericMethodBinding applicableMethod) {
- super(applicableMethod.originalMethod, applicableMethod.typeArguments, applicableMethod.environment);
+ super(applicableMethod.originalMethod, applicableMethod.typeArguments, applicableMethod.environment, false, false);
this.wrappedBinding = applicableMethod;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
index 582cb19..33ded17 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
@@ -757,8 +757,13 @@
} else if (!method.isOverriding() || !isOverriddenMethodGeneric(method)) {
return new ProblemMethodBinding(method, method.selector, genericTypeArguments, ProblemReasons.TypeParameterArityMismatch);
}
- } else if (typeVariables == Binding.NO_TYPE_VARIABLES && method instanceof PolyParameterizedGenericMethodBinding) {
- return method;
+ } else if (typeVariables == Binding.NO_TYPE_VARIABLES && method instanceof ParameterizedGenericMethodBinding) {
+ if (compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8 && invocationSite instanceof Invocation) {
+ Invocation invocation = (Invocation) invocationSite;
+ InferenceContext18 infCtx = invocation.getInferenceContext((ParameterizedGenericMethodBinding) method);
+ if (infCtx != null)
+ return method; // inference is responsible, no need to recheck.
+ }
}
if (tiebreakingVarargsMethods) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
index 32b1b07..55374ca 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
@@ -244,13 +244,11 @@
}
public int boundsCount() {
- if (this.firstBound == null) {
+ if (this.firstBound == null)
return 0;
- } else if (TypeBinding.equalsEquals(this.firstBound, this.superclass)) {
- return this.superInterfaces.length + 1;
- } else {
- return this.superInterfaces.length;
- }
+ if (this.firstBound.isInterface())
+ return this.superInterfaces.length; // only interface bounds
+ return this.superInterfaces.length + 1; // class or array type isn't contained in superInterfaces
}
/**
@@ -421,10 +419,11 @@
if (n == 0)
return NO_TYPE_BOUNDS;
TypeBound[] bounds = new TypeBound[n];
- bounds[0] = TypeBound.createBoundOrDependency(theta, this.firstBound, variable);
- int ifcOffset = TypeBinding.equalsEquals(this.firstBound, this.superclass) ? -1 : 0;
- for (int i = 1; i < n; i++)
- bounds[i] = TypeBound.createBoundOrDependency(theta, this.superInterfaces[i+ifcOffset], variable);
+ int idx = 0;
+ if (!this.firstBound.isInterface())
+ bounds[idx++] = TypeBound.createBoundOrDependency(theta, this.firstBound, variable);
+ for (int i = 0; i < this.superInterfaces.length; i++)
+ bounds[idx++] = TypeBound.createBoundOrDependency(theta, this.superInterfaces[i], variable);
return bounds;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
index 1893d20..f7bac96 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
@@ -9727,11 +9727,14 @@
CompilationUnitDeclaration parsedUnit;
boolean old = this.diet;
+ int oldInt = this.dietInt;
try {
+ this.dietInt = 0;
this.diet = true;
parsedUnit = parse(sourceUnit, compilationResult);
} finally {
this.diet = old;
+ this.dietInt = oldInt;
}
return parsedUnit;
}
@@ -11498,6 +11501,7 @@
}
public ASTNode[] parseClassBodyDeclarations(char[] source, int offset, int length, CompilationUnitDeclaration unit) {
boolean oldDiet = this.diet;
+ int oldInt = this.dietInt;
boolean oldTolerateDefaultClassMethods = this.tolerateDefaultClassMethods;
/* automaton initialization */
initialize();
@@ -11525,12 +11529,14 @@
/* run automaton */
try {
this.diet = true;
+ this.dietInt = 0;
this.tolerateDefaultClassMethods = this.parsingJava8Plus;
parse();
} catch (AbortCompilation ex) {
this.lastAct = ERROR_ACTION;
} finally {
this.diet = oldDiet;
+ this.dietInt = oldInt;
this.tolerateDefaultClassMethods = oldTolerateDefaultClassMethods;
}
@@ -12339,6 +12345,7 @@
if (this.referenceContext instanceof CompilationUnitDeclaration){
goForHeaders();
this.diet = true; // passed this point, will not consider method bodies
+ this.dietInt = 0;
return RESTART;
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationBinding.java
index 0e8f6db..5475581 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationBinding.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2005, 2011 BEA Systems, Inc.
+ * Copyright (c) 2005, 2015 BEA Systems, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -28,6 +28,7 @@
*/
class AnnotationBinding implements IAnnotationBinding {
static final AnnotationBinding[] NoAnnotations = new AnnotationBinding[0];
+ static final AnnotationBinding[][] NoAnnotationsOnDimensions = new AnnotationBinding[0][];
private org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding binding;
private BindingResolver bindingResolver;
private String key;
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ITypeBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ITypeBinding.java
index 4786097..c3f8699 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ITypeBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ITypeBinding.java
@@ -562,6 +562,23 @@
public IAnnotationBinding[] getTypeAnnotations();
/**
+ * Returns the type use annotations on dimensions, or the empty array if there
+ * are no annotations on dimensions.
+ *
+ * <p>
+ * Since JLS8, (Section 9.7.4) type annotations can appear at array dimensions. These annotations
+ * are returned in a 2-d array with each row containing annotations for that dimension. If only some
+ * of the dimensions have type annotations, the rows corresponding to the dimensions without
+ * annotations will have an empty single dimensional array.
+ * </p>
+ *
+ * @return type annotations specified on the dimensions of this type reference, or an empty array if
+ * either there is no dimension or no type use annotation is found on the dimensions.
+ * @since 3.12
+ */
+ public IAnnotationBinding[][] getTypeAnnotationsOnDimensions();
+
+ /**
* Returns the type arguments of this generic type instance, or the
* empty list for other type bindings.
* <p>
@@ -584,8 +601,8 @@
public ITypeBinding[] getTypeArguments();
/**
- * Returns the upper type bounds of this type variable, wildcard, or capture. If the
- * variable, wildcard, or capture had no explicit bound, then it returns an empty list.
+ * Returns the upper type bounds of this type variable, wildcard, capture, or intersectionType.
+ * If the variable, wildcard, or capture had no explicit bound, then it returns an empty list.
* <p>
* Note that per construction, it can only contain one class or array type,
* at most, and then it is located in first position.
@@ -595,11 +612,12 @@
* binding, e.g. <code>capture-of ? extends Object[]</code>
* </p>
*
- * @return the list of upper bounds for this type variable, wildcard, or capture,
+ * @return the list of upper bounds for this type variable, wildcard, capture, or intersection type
* or otherwise the empty list
* @see #isTypeVariable()
* @see #isWildcardType()
* @see #isCapture()
+ * @see #isIntersectionType()
* @since 3.1
*/
public ITypeBinding[] getTypeBounds();
@@ -819,6 +837,28 @@
public boolean isInterface();
/**
+ * Returns whether this type binding represents an intersection binding.
+ * <p>
+ * Intersection types can be derived from type parameter bounds and cast
+ * expressions; they also arise in the processes of capture conversion
+ * and least upper bound computation as specified in section 4.9 of
+ * <em>The Java Language Specification, Java SE 8 Edition</em> (JLS8).
+ * </p>
+ * <p>
+ * All the types in the intersection type can be accessed using
+ * {@link #getTypeBounds()}. Wildcard types with more than one
+ * bound will also be reported as intersection type. To check whether this
+ * is a wildcard type, use {@link #isWildcardType()}.
+ * </p>
+ * @return <code>true</code> if this type binding is an intersecting type,
+ * and <code>false</code> otherwise
+ * @see #getTypeBounds()
+ * @see ITypeBinding#isWildcardType()
+ * @since 3.12
+ */
+ public boolean isIntersectionType();
+
+ /**
* Returns whether this type binding represents a local class.
* <p>
* A local class is any nested class or enum type not declared as a member
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java
index 23cba7b..f4a55b1 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java
@@ -39,16 +39,16 @@
private static final ITypeBinding[] NO_TYPE_BINDINGS = new ITypeBinding[0];
protected org.eclipse.jdt.internal.compiler.lookup.MethodBinding binding;
protected BindingResolver resolver;
- private ITypeBinding[] parameterTypes;
- private ITypeBinding[] exceptionTypes;
- private String name;
- private ITypeBinding declaringClass;
- private ITypeBinding returnType;
- private String key;
- private ITypeBinding[] typeParameters;
- private ITypeBinding[] typeArguments;
- private IAnnotationBinding[] annotations;
- private IAnnotationBinding[][] parameterAnnotations;
+ private volatile ITypeBinding[] parameterTypes;
+ private volatile ITypeBinding[] exceptionTypes;
+ private volatile String name;
+ private volatile ITypeBinding declaringClass;
+ private volatile ITypeBinding returnType;
+ private volatile String key;
+ private volatile ITypeBinding[] typeParameters;
+ private volatile ITypeBinding[] typeArguments;
+ private volatile IAnnotationBinding[] annotations;
+ private volatile IAnnotationBinding[][] parameterAnnotations;
MethodBinding(BindingResolver resolver, org.eclipse.jdt.internal.compiler.lookup.MethodBinding binding) {
this.resolver = resolver;
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RecoveredTypeBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RecoveredTypeBinding.java
index c126584..97bc4e5 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RecoveredTypeBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RecoveredTypeBinding.java
@@ -467,6 +467,13 @@
}
/* (non-Javadoc)
+ * @see org.eclipse.jdt.core.dom.ITypeBinding#isIntersectionType18()
+ */
+ public boolean isIntersectionType() {
+ return false;
+ }
+
+ /* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ITypeBinding#isLocal()
*/
public boolean isLocal() {
@@ -728,4 +735,9 @@
public IAnnotationBinding[] getTypeAnnotations() {
return AnnotationBinding.NoAnnotations;
}
+
+ @Override
+ public IAnnotationBinding[][] getTypeAnnotationsOnDimensions() {
+ return AnnotationBinding.NoAnnotationsOnDimensions;
+ }
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java
index 1fdc509..e163e5f 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java
@@ -14,6 +14,8 @@
package org.eclipse.jdt.core.dom;
+import java.util.ArrayList;
+import java.util.List;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.compiler.CharOperation;
@@ -64,6 +66,7 @@
private IVariableBinding[] fields;
private IAnnotationBinding[] annotations;
private IAnnotationBinding[] typeAnnotations;
+ private IAnnotationBinding[][] typeAnnotationsOnDimensions;
private IMethodBinding[] methods;
private ITypeBinding[] members;
private ITypeBinding[] interfaces;
@@ -144,6 +147,34 @@
return AnnotationBinding.NoAnnotations;
}
+ private IAnnotationBinding[][] resolveAnnotationBindingsOnDimensions(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] internalAnnotations) {
+ int length = internalAnnotations == null ? 0 : internalAnnotations.length;
+ if (length != 0) {
+ IAnnotationBinding[][] dimAnnotations = new IAnnotationBinding[length][];
+ int row = 0;
+ List <IAnnotationBinding> tmpList = new ArrayList<>();
+ for (int i = 0; i < length; i++) {
+ org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding internalAnnotation = internalAnnotations[i];
+ if (internalAnnotation == null) {
+ if (tmpList.size() > 0) {
+ dimAnnotations[row] = tmpList.toArray(new AnnotationBinding[0]);
+ tmpList.clear();
+ } else {
+ dimAnnotations[row] = AnnotationBinding.NoAnnotations;
+ }
+ ++row;
+ }
+ IAnnotationBinding annotationInstance = this.resolver.getAnnotationInstance(internalAnnotation);
+ if (annotationInstance == null) {
+ continue;
+ }
+ tmpList.add(annotationInstance);
+ }
+ System.arraycopy(dimAnnotations, 0, (dimAnnotations = new IAnnotationBinding[row][]), 0, row);
+ return dimAnnotations;
+ }
+ return AnnotationBinding.NoAnnotationsOnDimensions;
+ }
/*
* @see ITypeBinding#getBinaryName()
* @since 3.0
@@ -554,6 +585,19 @@
return this.interfaces = NO_TYPE_BINDINGS;
}
+ private ITypeBinding[] getIntersectingTypes() {
+ ITypeBinding[] intersectionBindings = TypeBinding.NO_TYPE_BINDINGS;
+ if (this.binding instanceof IntersectionTypeBinding18) {
+ ReferenceBinding[] intersectingTypes = this.binding.getIntersectingTypes();
+ int l = intersectingTypes.length;
+ intersectionBindings = new ITypeBinding[l];
+ for (int i = 0; i < l; ++i) {
+ intersectionBindings[i] = this.resolver.getTypeBinding(intersectingTypes[i]);
+ }
+ }
+ return intersectionBindings;
+ }
+
public IJavaElement getJavaElement() {
JavaElement element = getUnresolvedJavaElement();
if (element != null)
@@ -926,6 +970,8 @@
} else if (this.binding instanceof WildcardBinding) {
WildcardBinding wildcardBinding = (WildcardBinding) this.binding;
typeVariableBinding = wildcardBinding.typeVariable();
+ } else if (this.binding instanceof IntersectionTypeBinding18) {
+ return this.bounds = getIntersectingTypes();
}
if (typeVariableBinding != null) {
ReferenceBinding varSuperclass = typeVariableBinding.superclass();
@@ -1214,6 +1260,14 @@
}
/*
+ * @see ITypeBinding#isIntersectionType18
+ */
+ public boolean isIntersectionType() {
+ int kind = this.binding.kind();
+ return kind == Binding.INTERSECTION_TYPE18 || kind == Binding.INTERSECTION_TYPE;
+ }
+
+ /*
* @see ITypeBinding#isLocal()
*/
public boolean isLocal() {
@@ -1363,6 +1417,17 @@
return this.typeAnnotations;
}
+ /*
+ * (non-Javadoc)
+ * @see org.eclipse.jdt.core.dom.ITypeBinding#getTypeAnnotationsOnDimensions()
+ */
+ public IAnnotationBinding[][] getTypeAnnotationsOnDimensions() {
+ if (this.typeAnnotationsOnDimensions == null) {
+ this.typeAnnotationsOnDimensions = resolveAnnotationBindingsOnDimensions(this.binding.getTypeAnnotations());
+ }
+ return this.typeAnnotationsOnDimensions;
+ }
+
static class LocalTypeBinding extends TypeBinding {
private IBinding declaringMember;
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/rewrite/ImportRewrite.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/rewrite/ImportRewrite.java
index 0541f2a..55023d2 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/rewrite/ImportRewrite.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/rewrite/ImportRewrite.java
@@ -1391,7 +1391,7 @@
} else {
normalizedBinding= normalizeTypeBinding(binding);
if (normalizedBinding == null) {
- type = ast.newSimpleType(ast.newSimpleName("invalid")); //$NON-NLS-1$
+ return ast.newSimpleType(ast.newSimpleName("invalid")); //$NON-NLS-1$
} else if (normalizedBinding.isTypeVariable()) {
// no import
type = ast.newSimpleType(ast.newSimpleName(binding.getName()));
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java
index 1e2c529..7233476 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java
@@ -57,16 +57,17 @@
private final static Pattern HTML_TAG_PATTERN;
private final static Pattern HTML_ATTRIBUTE_PATTERN;
static {
- String formatCodeTags = "(pre)?"; //$NON-NLS-1$
- String separateLineTags = "(dl|hr|nl|p|ul|ol|table|tr)?"; //$NON-NLS-1$
- String breakBeforeTags = "(dd|dt|li|td|th|h1|h2|h3|h4|h5|h6|q)?"; //$NON-NLS-1$
- String breakAfterTags = "(br)?"; //$NON-NLS-1$
- String noFormatTags = "(code|em|tt)?"; //$NON-NLS-1$
- String otherTags = "([^<>&&\\S]+)??"; //$NON-NLS-1$
- String ws = "(?:[ \\t]+|[\\r\\n]+[ \\t]*\\*?)"; // whitespace or line break with optional asterisk //$NON-NLS-1$
- String attribute = "(?:" + ws + "+[^=&&\\S]+" + ws + "*(=)" + ws + "*\"?[^\"]*\"?)"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
- HTML_TAG_PATTERN = Pattern.compile("<(/)?" //$NON-NLS-1$
- + formatCodeTags + separateLineTags + breakBeforeTags + breakAfterTags + noFormatTags + otherTags
+ String formatCodeTags = "(pre)"; //$NON-NLS-1$
+ String separateLineTags = "(dl|hr|nl|p|ul|ol|table|tr)"; //$NON-NLS-1$
+ String breakBeforeTags = "(dd|dt|li|td|th|h1|h2|h3|h4|h5|h6|q)"; //$NON-NLS-1$
+ String breakAfterTags = "(br)"; //$NON-NLS-1$
+ String noFormatTags = "(code|em|tt)"; //$NON-NLS-1$
+ String otherTags = "([^<>&&\\S]++)"; //$NON-NLS-1$
+ String ws = "(?>[ \\t]++|[\\r\\n]++[ \\t]*+\\*?)"; // whitespace or line break with optional asterisk //$NON-NLS-1$
+ String attributeValue = "(?>\"[^\"]*\")|(?>\'[^\']*\')|[^/>\"\'&&\\S]++"; //$NON-NLS-1$
+ String attribute = "(?>" + ws + "+[^=&&\\S]+" + ws + "*(=)" + ws + "*(?>" + attributeValue + "))"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+ HTML_TAG_PATTERN = Pattern.compile("<(/)?+(?:" //$NON-NLS-1$
+ + formatCodeTags + '|' + separateLineTags + '|' + breakBeforeTags + '|' + breakAfterTags + '|' + noFormatTags + '|' + otherTags + ')'
+ "(" + attribute + "*)" + ws + "*/?>", Pattern.CASE_INSENSITIVE); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
HTML_ATTRIBUTE_PATTERN = Pattern.compile(attribute);
}
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java
index ae1ef58..92b756b 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java
@@ -361,27 +361,28 @@
@Override
public boolean visit(ArrayInitializer node) {
int openBraceIndex = this.tm.firstIndexIn(node, TokenNameLBRACE);
- Token afterOpenBraceToken = this.tm.get(openBraceIndex + 1);
- boolean isEmpty = afterOpenBraceToken.tokenType == TokenNameRBRACE;
- if (isEmpty && this.options.keep_empty_array_initializer_on_one_line)
- return true;
+ boolean isEmpty = handleEmptyLinesIndentation(openBraceIndex);
- Token openBraceToken = this.tm.get(openBraceIndex);
int closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
- handleBracePosition(openBraceToken, closeBraceIndex, this.options.brace_position_for_array_initializer);
+ Token openBraceToken = this.tm.get(openBraceIndex);
+ Token closeBraceToken = this.tm.get(closeBraceIndex);
+
+ if (!(node.getParent() instanceof ArrayInitializer)) {
+ Token afterOpenBraceToken = this.tm.get(openBraceIndex + 1);
+ for (int i = 0; i < this.options.continuation_indentation_for_array_initializer; i++) {
+ afterOpenBraceToken.indent();
+ closeBraceToken.unindent();
+ }
+ }
+
+ if (!isEmpty || !this.options.keep_empty_array_initializer_on_one_line)
+ handleBracePosition(openBraceToken, closeBraceIndex, this.options.brace_position_for_array_initializer);
if (!isEmpty) {
- Token closeBraceToken = this.tm.get(closeBraceIndex);
if (this.options.insert_new_line_after_opening_brace_in_array_initializer)
openBraceToken.breakAfter();
if (this.options.insert_new_line_before_closing_brace_in_array_initializer)
closeBraceToken.breakBefore();
- if (!(node.getParent() instanceof ArrayInitializer)) {
- for (int i = 0; i < this.options.continuation_indentation_for_array_initializer; i++) {
- afterOpenBraceToken.indent();
- closeBraceToken.unindent();
- }
- }
}
return true;
}
@@ -550,6 +551,7 @@
: this.tm.firstIndexAfter(nodeBeforeOpenBrace, TokenNameLBRACE);
int closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
Token openBraceToken = this.tm.get(openBraceIndex);
+ Token closeBraceToken = this.tm.get(closeBraceIndex);
handleBracePosition(openBraceToken, closeBraceIndex, bracePosition);
boolean isEmpty = true;
@@ -559,13 +561,16 @@
break;
}
}
+
+ handleEmptyLinesIndentation(openBraceIndex);
+
if (!isEmpty || newLineInEmpty) {
openBraceToken.breakAfter();
- this.tm.get(closeBraceIndex).breakBefore();
+ closeBraceToken.breakBefore();
}
if (indentBody) {
this.tm.get(openBraceIndex + 1).indent();
- this.tm.get(closeBraceIndex).unindent();
+ closeBraceToken.unindent();
}
}
@@ -582,6 +587,31 @@
}
}
+ private boolean handleEmptyLinesIndentation(int openBraceIndex) {
+ Token open = this.tm.get(openBraceIndex);
+ Token next = this.tm.get(openBraceIndex + 1);
+ boolean isEmpty = next.tokenType == TokenNameRBRACE;
+ if (!isEmpty || this.tm.countLineBreaksBetween(open, next) < 2 || !this.options.indent_empty_lines)
+ return isEmpty;
+
+ // find a line break and make a token out of it
+ for (int i = open.originalEnd + 1; i < next.originalStart; i++) {
+ char c = this.tm.charAt(i);
+ char c2 = this.tm.charAt(i + 1);
+ int lineBreakStart = (c == '\r' || c == '\n') ? i : -1;
+ int lineBreakEnd = ((c2 == '\r' || c2 == '\n') && c2 != c) ? i + 1 : lineBreakStart;
+ if (lineBreakStart >= 0) {
+ Token emptyLineToken = new Token(lineBreakStart, lineBreakEnd, Token.TokenNameEMPTY_LINE);
+ emptyLineToken.breakBefore();
+ emptyLineToken.breakAfter();
+ emptyLineToken.setToEscape(true); // force text builder to use toString()
+ this.tm.insert(openBraceIndex + 1, emptyLineToken);
+ return true;
+ }
+ }
+ return true;
+ }
+
private void indent(ASTNode node) {
int startIndex = this.tm.firstIndexIn(node, -1);
while (startIndex > 0 && this.tm.get(startIndex - 1).isComment())
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java
index 9ecfdc8..2377567 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java
@@ -191,9 +191,10 @@
} else {
handleToken(node.getName(), TokenNameLPAREN, spaceBeforeOpenParen, spaceAfterOpenParen);
- if (node.isConstructor() ? this.options.insert_space_before_closing_paren_in_constructor_declaration
- : this.options.insert_space_before_closing_paren_in_method_declaration)
- handleToken(node.getName(), TokenNameRPAREN, true, false);
+ boolean spaceBeforeCloseParen = node.isConstructor()
+ ? this.options.insert_space_before_closing_paren_in_constructor_declaration
+ : this.options.insert_space_before_closing_paren_in_method_declaration;
+ handleTokenBefore(node.getBody(), TokenNameRPAREN, spaceBeforeCloseParen, false);
}
if ((node.isConstructor() ? this.options.insert_space_before_opening_brace_in_constructor_declaration
@@ -464,7 +465,8 @@
if (handleParenthesis) {
handleToken(node, TokenNameLPAREN, this.options.insert_space_before_opening_paren_in_annotation,
this.options.insert_space_after_opening_paren_in_annotation);
- handleToken(node, TokenNameRPAREN, this.options.insert_space_before_closing_paren_in_annotation, false);
+ if (this.options.insert_space_before_closing_paren_in_annotation)
+ this.tm.lastTokenIn(node, TokenNameRPAREN).spaceBefore();
}
ASTNode parent = node.getParent();
@@ -486,7 +488,7 @@
this.options.insert_space_before_opening_paren_in_method_declaration,
this.options.insert_space_after_opening_paren_in_method_declaration);
- handleToken(node, TokenNameRPAREN,
+ handleTokenBefore(node.getBody(), TokenNameRPAREN,
this.options.insert_space_before_closing_paren_in_method_declaration, false);
}
handleCommas(parameters, this.options.insert_space_before_comma_in_method_declaration_parameters,
@@ -497,19 +499,17 @@
@Override
public boolean visit(Block node) {
- if (node.getParent().getLength() == 0)
+ ASTNode parent = node.getParent();
+ if (parent.getLength() == 0)
return true; // this is a fake block created by parsing in statements mode
- if (node.getParent() instanceof MethodDeclaration)
+ if (parent instanceof MethodDeclaration)
return true; // spaces handled in #visit(MethodDeclaration)
handleToken(node, TokenNameLBRACE, this.options.insert_space_before_opening_brace_in_block, false);
- if (this.options.insert_space_after_closing_brace_in_block) {
+ if (this.options.insert_space_after_closing_brace_in_block
+ && (parent instanceof Statement || parent instanceof CatchClause)) {
int closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
- if (closeBraceIndex + 1 < this.tm.size()) {
- int nextToken = this.tm.get(closeBraceIndex + 1).tokenType;
- if (nextToken != TokenNameSEMICOLON && nextToken != TokenNameRPAREN)
- this.tm.get(closeBraceIndex).spaceAfter();
- }
+ this.tm.get(closeBraceIndex).spaceAfter();
}
return true;
}
@@ -601,7 +601,7 @@
public boolean visit(ClassInstanceCreation node) {
List<Type> typeArguments = node.typeArguments();
handleTypeArguments(typeArguments);
- handleInvocation(node, node.getType());
+ handleInvocation(node, node.getType(), node.getAnonymousClassDeclaration());
if (!typeArguments.isEmpty()) {
handleTokenBefore(typeArguments.get(0), TokenNamenew, false, true); // fix for: new<Integer>A<String>()
}
@@ -631,6 +631,11 @@
}
private void handleInvocation(ASTNode invocationNode, ASTNode nodeBeforeOpeningParen) {
+ handleInvocation(invocationNode, nodeBeforeOpeningParen, null);
+ }
+
+ private void handleInvocation(ASTNode invocationNode, ASTNode nodeBeforeOpeningParen,
+ ASTNode nodeAfterClosingParen) {
if (handleEmptyParens(nodeBeforeOpeningParen,
this.options.insert_space_between_empty_parens_in_method_invocation)) {
handleToken(nodeBeforeOpeningParen, TokenNameLPAREN,
@@ -640,7 +645,10 @@
this.options.insert_space_before_opening_paren_in_method_invocation,
this.options.insert_space_after_opening_paren_in_method_invocation);
if (this.options.insert_space_before_closing_paren_in_method_invocation) {
- this.tm.lastTokenIn(invocationNode, TokenNameRPAREN).spaceBefore();
+ Token closingParen = nodeAfterClosingParen == null
+ ? this.tm.lastTokenIn(invocationNode, TokenNameRPAREN)
+ : this.tm.firstTokenBefore(nodeAfterClosingParen, TokenNameRPAREN);
+ closingParen.spaceBefore();
}
}
}
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java
index f1b92e1..8e725a9 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java
@@ -153,7 +153,7 @@
if (getLineBreaksBefore() > 1) {
Token indentToken = null;
if (this.options.indent_empty_lines && token.tokenType != TokenNameNotAToken)
- indentToken = token.getIndent() > getPrevious().getIndent() ? token : getPrevious();
+ indentToken = (index == 0 || token.getIndent() > getPrevious().getIndent()) ? token : getPrevious();
for (int i = 1; i < getLineBreaksBefore(); i++) {
bufferLineSeparator(token, true);
if (indentToken != null)
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java
index 66dfafb..762edd0 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java
@@ -70,6 +70,9 @@
}
}
+ /** Special token type used to mark tokens that store empty line indentation */
+ public static final int TokenNameEMPTY_LINE = 10000;
+
/** Position in source of the first character. */
public final int originalStart;
/** Position in source of the last character (this position is included in the token). */
@@ -276,6 +279,8 @@
}
public String toString(String source) {
+ if (this.tokenType == TokenNameEMPTY_LINE)
+ return ""; //$NON-NLS-1$
return source.substring(this.originalStart, this.originalEnd + 1);
}
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java
index aff5ee5..76f74e1 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java
@@ -432,6 +432,8 @@
for (Token[] pair : this.formatOffTagPairs) {
int index1 = findIndex(pair[0].originalStart, -1, false);
int index2 = findIndex(pair[1].originalEnd, -1, false);
+ pair[0] = get(index1);
+ pair[1] = get(index2);
Token unformatted = new Token(pair[0].originalStart, pair[1].originalEnd, TokenNameWHITESPACE);
unformatted.setIndent(Math.min(pair[0].getIndent(), findSourcePositionInLine(pair[0].originalStart)));
unformatted.putLineBreaksBefore(pair[0].getLineBreaksBefore());
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java
index dd89f53..b24658a 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java
@@ -227,6 +227,7 @@
if (prefix.tokenType == TokenNameWHITESPACE) {
whitespace = new Token(prefix);
whitespace.breakBefore();
+ whitespace.setIndent(indent);
whitespace.setWrapPolicy(new WrapPolicy(0, commentIndex, false));
prefix = structure.get(1);
assert prefix.tokenType == TokenNameCOMMENT_LINE;
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java
index a548f48..9c15869 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java
@@ -23,7 +23,6 @@
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.SimpleName;
-import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.internal.formatter.Token;
import org.eclipse.jdt.internal.formatter.TokenManager;
@@ -71,21 +70,14 @@
this.tm = tokenManager;
}
- public void prepareAlign(TypeDeclaration node) {
- List<FieldDeclaration> bodyDeclarations = node.bodyDeclarations();
+ public void prepareAlign(List<FieldDeclaration> bodyDeclarations) {
ArrayList<FieldDeclaration> alignGroup = new ArrayList<>();
for (BodyDeclaration declaration : bodyDeclarations) {
- if (!alignGroup.isEmpty()) {
- if ((declaration instanceof FieldDeclaration)) {
- alignGroup.add((FieldDeclaration) declaration);
- } else {
- alignFields(alignGroup);
- alignGroup = new ArrayList<>();
- }
- }
- if (alignGroup.isEmpty()) {
- if (declaration instanceof FieldDeclaration)
- alignGroup.add((FieldDeclaration) declaration);
+ if ((declaration instanceof FieldDeclaration)) {
+ alignGroup.add((FieldDeclaration) declaration);
+ } else {
+ alignFields(alignGroup);
+ alignGroup = new ArrayList<>();
}
}
alignFields(alignGroup);
@@ -104,7 +96,7 @@
int positionInLine = this.tm.getPositionInLine(nameIndex);
maxNameAlign = Math.max(maxNameAlign, positionInLine);
}
- maxNameAlign = this.tm.toIndent(maxNameAlign, true);
+ maxNameAlign = this.tm.toIndent(maxNameAlign, false);
int maxAssignAlign = 0;
for (FieldDeclaration declaration : alignGroup) {
@@ -121,7 +113,7 @@
maxAssignAlign = Math.max(maxAssignAlign, positionInLine);
}
}
- maxAssignAlign = this.tm.toIndent(maxAssignAlign, true);
+ maxAssignAlign = this.tm.toIndent(maxAssignAlign, false);
for (FieldDeclaration declaration : alignGroup) {
List<VariableDeclarationFragment> fragments = declaration.fragments();
@@ -155,7 +147,7 @@
maxCommentAlign = Math.max(maxCommentAlign,
positionCounter.findMaxPosition(firstIndexInLine, lastIndex));
}
- maxCommentAlign = this.tm.toIndent(maxCommentAlign, true);
+ maxCommentAlign = this.tm.toIndent(maxCommentAlign, false);
for (FieldDeclaration declaration : alignGroup) {
int typeIndex = this.tm.firstIndexIn(declaration.getType(), -1);
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java
index 791c385..a25a29b 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java
@@ -320,6 +320,7 @@
findWrapsCached(index, currentIndent);
break;
}
+ currentIndent = Math.max(currentIndent, token.getAlign());
token.setIndent(currentIndent);
}
token = this.tm.get(index);
@@ -346,6 +347,7 @@
break;
if (shouldForceWrap(token, currentIndent))
currentIndent = token.getIndent();
+ currentIndent = Math.max(currentIndent, token.getAlign());
token.setIndent(currentIndent);
}
}
@@ -634,8 +636,8 @@
int getWrapIndent(Token token) {
WrapPolicy policy = token.getWrapPolicy();
- if (policy == null || (token.getLineBreaksBefore() > 1 && !policy.isForced && !policy.isTopPriority()))
- return token.getIndent(); // no additional indentation after an empty line
+ if (policy == null)
+ return token.getIndent();
if (this.options.never_indent_line_comments_on_first_column && token.tokenType == TokenNameCOMMENT_LINE
&& token.getIndent() == 0)
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java
index 39bcda7..3ac9ad2 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java
@@ -38,6 +38,7 @@
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.ArrayInitializer;
import org.eclipse.jdt.core.dom.Assignment;
@@ -106,7 +107,7 @@
final DefaultCodeFormatterOptions options;
final int kind;
- FieldAligner fieldAligner;
+ final FieldAligner fieldAligner;
int importsStart = -1, importsEnd = -1;
@@ -125,11 +126,17 @@
this.tm = tokenManager;
this.options = options;
this.kind = kind;
+
+ this.fieldAligner = new FieldAligner(this.tm);
}
@Override
public boolean preVisit2(ASTNode node) {
this.currentDepth++;
+
+ assert this.wrapIndexes.isEmpty() && this.wrapPenalties.isEmpty();
+ assert this.wrapParentIndex == -1 && this.wrapGroupEnd == -1;
+
boolean isMalformed = (node.getFlags() & ASTNode.MALFORMED) != 0;
if (isMalformed) {
this.tm.addDisableFormatTokenPair(this.tm.firstTokenIn(node, -1), this.tm.lastTokenIn(node, -1));
@@ -180,12 +187,23 @@
handleWrap(this.options.alignment_for_superinterfaces_in_type_declaration, PREFERRED);
}
- if (this.options.align_type_members_on_columns) {
- if (this.fieldAligner == null) {
- this.fieldAligner = new FieldAligner(this.tm);
- }
- this.fieldAligner.prepareAlign(node);
- }
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
+
+ return true;
+ }
+
+ @Override
+ public boolean visit(AnnotationTypeDeclaration node) {
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
+ return true;
+ }
+
+ @Override
+ public boolean visit(AnonymousClassDeclaration node) {
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
return true;
}
@@ -218,13 +236,16 @@
}
if (!node.isConstructor()) {
+ this.wrapParentIndex = this.tm.findFirstTokenInLine(this.tm.firstIndexIn(node.getName(), -1));
List<TypeParameter> typeParameters = node.typeParameters();
if (!typeParameters.isEmpty())
this.wrapIndexes.add(this.tm.firstIndexIn(typeParameters.get(0), -1));
- if (node.getReturnType2() != null && !node.modifiers().isEmpty())
- this.wrapIndexes.add(this.tm.firstIndexIn(node.getReturnType2(), -1));
+ if (node.getReturnType2() != null) {
+ int returTypeIndex = this.tm.firstIndexIn(node.getReturnType2(), -1);
+ if (returTypeIndex != this.wrapParentIndex)
+ this.wrapIndexes.add(returTypeIndex);
+ }
this.wrapIndexes.add(this.tm.firstIndexIn(node.getName(), -1));
- this.wrapParentIndex = this.tm.findFirstTokenInLine(this.tm.firstIndexIn(node.getName(), -1));
this.wrapGroupEnd = this.tm.lastIndexIn(node.getName(), -1);
handleWrap(this.options.alignment_for_method_declaration);
}
@@ -252,6 +273,10 @@
this.wrapPenalties.add(PREFERRED);
handleWrap(this.options.alignment_for_superinterfaces_in_enum_declaration, node);
}
+
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
+
return true;
}
@@ -333,7 +358,8 @@
findTokensToWrap(node, 0);
this.wrapParentIndex = this.wrapIndexes.remove(0);
this.wrapGroupEnd = this.tm.lastIndexIn(node, -1);
- if ((this.options.alignment_for_binary_expression & Alignment.M_INDENT_ON_COLUMN) != 0)
+ if ((this.options.alignment_for_binary_expression & Alignment.M_INDENT_ON_COLUMN) != 0
+ && this.wrapParentIndex > 0)
this.wrapParentIndex--;
for (int i = this.wrapParentIndex; i >= 0; i--) {
if (!this.tm.get(i).isComment()) {
@@ -562,7 +588,6 @@
this.wrapParentIndex = this.tm.findIndex(firstToken.originalStart - 1, TokenNameLPAREN, false);
if (!arguments.isEmpty() && this.wrapGroupEnd < 0)
this.wrapGroupEnd = this.tm.lastIndexIn(arguments.get(arguments.size() - 1), -1);
- assert this.wrapGroupEnd >= 0;
handleWrap(wrappingOption, 1 / PREFERRED);
}
}
@@ -577,17 +602,22 @@
}
private void handleWrap(int wrappingOption, ASTNode parentNode) {
+ doHandleWrap(wrappingOption, parentNode);
+ this.wrapIndexes.clear();
+ this.wrapPenalties.clear();
+ this.wrapParentIndex = this.wrapGroupEnd = -1;
+ }
+
+ private void doHandleWrap(int wrappingOption, ASTNode parentNode) {
if (this.wrapIndexes.isEmpty())
return;
- assert this.wrapParentIndex >= 0;
+ assert this.wrapParentIndex >= 0 && this.wrapParentIndex < this.wrapIndexes.get(0);
+ assert this.wrapGroupEnd >= this.wrapIndexes.get(this.wrapIndexes.size() - 1);
float penalty = this.wrapPenalties.isEmpty() ? 1 : this.wrapPenalties.get(0);
WrapPolicy policy = getWrapPolicy(wrappingOption, penalty, true, parentNode);
- if (policy == null) {
- this.wrapIndexes.clear();
- this.wrapPenalties.clear();
- this.wrapParentIndex = this.wrapGroupEnd = -1;
+ if (policy == null)
return;
- }
+
setTokenWrapPolicy(this.wrapIndexes.get(0), policy, true);
boolean wrapPreceedingComments = !(parentNode instanceof InfixExpression)
@@ -615,9 +645,6 @@
this.tm.get(this.wrapIndexes.get(0)).breakBefore();
}
}
- this.wrapIndexes.clear();
- this.wrapPenalties.clear();
- this.wrapParentIndex = this.wrapGroupEnd = -1;
}
private void setTokenWrapPolicy(int index, WrapPolicy policy, boolean wrapPreceedingComments) {
@@ -704,8 +731,7 @@
public void finishUp(ASTNode astRoot) {
preserveExistingLineBreaks();
new WrapExecutor(this.tm, this.options).executeWraps();
- if (this.fieldAligner != null)
- this.fieldAligner.alignComments();
+ this.fieldAligner.alignComments();
wrapComments();
fixEnumConstantIndents(astRoot);
}
@@ -722,45 +748,25 @@
@Override
protected boolean token(Token token, int index) {
- int lineBreaks = getLineBreaksBetween(getPrevious(), token);
- if (index > WrapPreparator.this.importsStart && index < WrapPreparator.this.importsEnd) {
- lineBreaks = lineBreaks > 1 ? (this.options2.blank_lines_between_import_groups + 1) : 0;
- } else {
- lineBreaks = Math.min(lineBreaks, this.options2.number_of_empty_lines_to_preserve + 1);
- }
+ boolean isBetweenImports = index > WrapPreparator.this.importsStart && index < WrapPreparator.this.importsEnd;
+ int lineBreaks = getLineBreaksToPreserve(getPrevious(), token, isBetweenImports);
if (lineBreaks <= getLineBreaksBefore())
return true;
- if (!this.options2.join_wrapped_lines && token.isWrappable() && lineBreaks == 1) {
- token.breakBefore();
+ if (lineBreaks == 1) {
+ if ((!this.options2.join_wrapped_lines && token.isWrappable()) || index == 0)
+ token.breakBefore();
} else if (lineBreaks > 1) {
- if (index == 0)
- lineBreaks--;
token.putLineBreaksBefore(lineBreaks);
}
return true;
}
- private int getLineBreaksBetween(Token token1, Token token2) {
- if (token1 != null) {
- List<Token> structure1 = token1.getInternalStructure();
- if (structure1 != null && !structure1.isEmpty())
- token1 = structure1.get(structure1.size() - 1);
- }
- List<Token> structure2 = token2.getInternalStructure();
- if (structure2 != null && !structure2.isEmpty())
- token2 = structure2.get(0);
- int lineBreaks = WrapPreparator.this.tm.countLineBreaksBetween(token1, token2);
- if (token1 == null)
- lineBreaks++;
- return lineBreaks;
- }
});
Token last = this.tm.get(this.tm.size() - 1);
last.clearLineBreaksAfter();
- int endingBreaks = this.tm.countLineBreaksBetween(last, null);
- endingBreaks = Math.min(endingBreaks, this.options.number_of_empty_lines_to_preserve);
+ int endingBreaks = getLineBreaksToPreserve(last, null, false);
if (endingBreaks > 0) {
last.putLineBreaksAfter(endingBreaks);
} else if ((this.kind & CodeFormatter.K_COMPILATION_UNIT) != 0
@@ -769,6 +775,29 @@
}
}
+ int getLineBreaksToPreserve(Token token1, Token token2, boolean isBetweenImports) {
+ if (token1 != null) {
+ List<Token> structure = token1.getInternalStructure();
+ if (structure != null && !structure.isEmpty())
+ token1 = structure.get(structure.size() - 1);
+ }
+ if (token2 != null) {
+ List<Token> structure = token2.getInternalStructure();
+ if (structure != null && !structure.isEmpty())
+ token2 = structure.get(0);
+ }
+ int lineBreaks = WrapPreparator.this.tm.countLineBreaksBetween(token1, token2);
+ if (isBetweenImports)
+ return lineBreaks > 1 ? (this.options.blank_lines_between_import_groups + 1) : 0;
+
+ int toPreserve = this.options.number_of_empty_lines_to_preserve;
+ if (token1 != null && token2 != null)
+ toPreserve++; // n empty lines = n+1 line breaks, except for file start and end
+ if (token1 != null && token1.tokenType == Token.TokenNameEMPTY_LINE)
+ toPreserve--;
+ return Math.min(lineBreaks, toPreserve);
+ }
+
private void wrapComments() {
CommentWrapExecutor commentWrapper = new CommentWrapExecutor(this.tm, this.options);
boolean isNLSTagInLine = false;
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/DocumentElementParser.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/DocumentElementParser.java
index 5f893e7..0ea74b9 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/DocumentElementParser.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/DocumentElementParser.java
@@ -1308,6 +1308,7 @@
}
protected void parse() {
this.diet = true;
+ this.dietInt = 0;
super.parse();
}
/*
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java
index faa6d04..c21ab1f 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java
@@ -946,9 +946,11 @@
IProgressMonitor pm) {
boolean old = this.diet;
+ int oldInt = this.dietInt;
CompilationUnitDeclaration parsedUnit = null;
try {
this.diet = true;
+ this.dietInt = 0;
this.reportReferenceInfo = fullParse;
CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit);
parsedUnit = parse(unit, compilationUnitResult);
@@ -976,6 +978,7 @@
// ignore this exception
} finally {
this.diet = old;
+ this.dietInt = oldInt;
reset();
}
return parsedUnit;
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SourceMapper.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SourceMapper.java
index aff2184..85e8139 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SourceMapper.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SourceMapper.java
@@ -1321,7 +1321,7 @@
} else if (this.binaryType.getElementName().equals(typeName))
return this.binaryType;
else
- return this.binaryType.getType(typeName);
+ return ((this.typeDepth <= 1) ? this.binaryType : this.types[this.typeDepth - 1]).getType(typeName);
}
/**
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java
index dc0177b..fa43a28 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2013 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -1359,7 +1359,9 @@
if (qualificationLength > 0) {
System.arraycopy(record.qualification, 0, path, pos, qualificationLength - 1);
CharOperation.replace(path, '.', '/');
- path[qualificationLength-1] = '/';
+
+ // Do not use '/'. Access rules work on package level and should not discriminate on enclosing types.
+ path[qualificationLength-1] = '$';
pos += qualificationLength;
}
if (nameLength > 0) {
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java
index fef7832..5b5634c 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java
@@ -1047,11 +1047,10 @@
* Selects the most applicable method (though similar but not to be confused with its namesake in jls)
* All this machinery for that elusive uncommon case referred in bug 431357.
*/
-private MethodBinding getMostApplicableMethod(List<MethodBinding> possibleMethods) {
+private MethodBinding getMostApplicableMethod(List<MethodBinding> possibleMethods, MethodPattern methodPattern) {
int size = possibleMethods.size();
MethodBinding result = size != 0 ? possibleMethods.get(0) : null;
if (size > 1) {
- MethodPattern methodPattern = ((MethodPattern) this.pattern);
// can cache but may not be worth since this is not a common case
Map<Integer, List<String>> methodPatternReverseNames = getSplitNames(methodPattern.parameterQualifications, methodPattern.parameterSimpleNames);
int len = possibleMethods.size();
@@ -1133,7 +1132,7 @@
possibleMethods.add(methods[i]);
}
}
- result = getMostApplicableMethod(possibleMethods);
+ result = getMostApplicableMethod(possibleMethods, methodPattern);
}
}
this.bindings.put(methodPattern, result != null ? result : new ProblemMethodBinding(methodPattern.selector, null, ProblemReasons.NotFound));
