Update jdt.core to I20150916-2000 for Neon M2
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..5aeb1d7 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,79 @@
 		"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");
+}
 }
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaExpressionsTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaExpressionsTest.java
index 0ce4208..0245d89 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaExpressionsTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/LambdaExpressionsTest.java
@@ -4994,6 +4994,9 @@
 				"import java.lang.reflect.Method;\n" +
 				"import java.util.List;\n" +
 				"import java.util.function.Function;\n" +
+				"import java.util.ArrayList;\n" +
+				"import java.util.Collections;\n" +
+				"import java.util.Comparator;\n" +
 				"public class X {\n" +
 				"	private static interface SerializableFunction<A, R> extends Function<A, R>, Serializable { }\n" +
 				"	private static List<String> noop(List<String> l) { return l; }\n" +
@@ -5004,18 +5007,24 @@
 				"		SerializedLambda l = (SerializedLambda)invokeWriteReplaceMethod.invoke(ObjectStreamClass.lookupAny(f.getClass()), f);\n" +
 				"		System.out.println(\"Lambda binds to: \" + l.getImplClass() + \".\" + l.getImplMethodName());\n" +
 				"		System.out.println(\"Methods (with generics):\");\n" +
+				"		List<String> list = new ArrayList<String>();\n" +
 				"		for(Method m : X.class.getDeclaredMethods()) {\n" +
 				"			if(m.getName().equals(\"main\")) continue;\n" +
 				"			if(m.getName().contains(\"deserializeLambda\")) continue;\n" +
-				"			System.out.println(\"- \" + m.getGenericReturnType() + \" \" + m.getName() + \"(\" + m.getGenericParameterTypes()[0] + \")\");\n" +
+				"			list.add(\"- \" + m.getGenericReturnType() + \" \" + m.getName() + \"(\" + m.getGenericParameterTypes()[0] + \")\");\n" +
 				"		}\n" +
+				"		Collections.sort(list, new Comparator<String>() {\n" +
+				"			public int compare(String s1, String s2) {\n" +
+				"				return s1.compareTo(s2);\n" +
+			    "			}\n" +
+				"		});\n" +
+				"		System.out.println(list.toString());\n" +
 				"	}\n" +
 				"}\n"
 			},
 			"Lambda binds to: X.lambda$0\n" + 
 			"Methods (with generics):\n" + 
-			"- java.util.List<java.lang.String> noop(java.util.List<java.lang.String>)\n" + 
-			"- java.util.List<java.lang.String> lambda$0(java.util.List<java.lang.String>)",
+			"[- java.util.List<java.lang.String> lambda$0(java.util.List<java.lang.String>), - java.util.List<java.lang.String> noop(java.util.List<java.lang.String>)]",
 			null,
 			true,
 			new String [] { "-Ddummy" }); // Not sure, unless we force the VM to not be reused by passing dummy vm argument, the generated program aborts midway through its execution.
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/NegativeLambdaExpressionsTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeLambdaExpressionsTest.java
index ab3313f..cf9f709 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeLambdaExpressionsTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeLambdaExpressionsTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011, 2014 IBM Corporation and others.
+ * Copyright (c) 2011, 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
@@ -9766,6 +9766,43 @@
 		"Type mismatch: cannot convert from I<X,X,? extends C> to I<? extends A,? extends B,? extends C>\n" + 
 		"----------\n");
 }
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474522, [1.8][compiler] ecj doesn't handle captured final fields correctly in lambdas
+public void test474522() {
+	this.runNegativeTest(
+		new String[] {
+			"Bug.java",
+			"import java.awt.event.ActionEvent;\n" + 
+			"import java.awt.event.ActionListener;\n" + 
+			"public class Bug {\n" + 
+			"    final String s;\n" + 
+			"    public Bug() {\n" + 
+			"        this.s = \"\";\n" + 
+			"    }\n" + 
+			"    private final ActionListener listener1 = new ActionListener() {\n" + 
+			"        @Override public void actionPerformed(ActionEvent e) {\n" + 
+			"            System.out.println(s);\n" + 
+			"        }\n" + 
+			"    };\n" + 
+			"    private final ActionListener listener2 = e -> System.out.println(s);\n" + 
+			"}\n"
+		},
+		"----------\n" + 
+		"1. WARNING in Bug.java (at line 8)\n" + 
+		"	private final ActionListener listener1 = new ActionListener() {\n" + 
+		"	                             ^^^^^^^^^\n" + 
+		"The value of the field Bug.listener1 is not used\n" + 
+		"----------\n" + 
+		"2. WARNING in Bug.java (at line 13)\n" + 
+		"	private final ActionListener listener2 = e -> System.out.println(s);\n" + 
+		"	                             ^^^^^^^^^\n" + 
+		"The value of the field Bug.listener2 is not used\n" + 
+		"----------\n" + 
+		"3. ERROR in Bug.java (at line 13)\n" + 
+		"	private final ActionListener listener2 = e -> System.out.println(s);\n" + 
+		"	                                                                 ^\n" + 
+		"The blank final field s may not have been initialized\n" + 
+		"----------\n");
+}
 public static Class testClass() {
 	return NegativeLambdaExpressionsTest.class;
 }
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 7d9b60b..8f2d34f 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
@@ -8281,4 +8281,118 @@
 		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(),
+			"");
+	}
 }
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java
index 80c6d93..df3c168 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java
@@ -11591,4 +11591,158 @@
 		EnumConstantDeclaration ec = (EnumConstantDeclaration) eDecl.enumConstants().get(1);
 		checkSourceRange(ec, "FOURTH_ENUM(\"b\", new X[] { }", str); //recovery parser propagated
 	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474922
+	public void testBug474922_001() throws JavaModelException {
+		String str =
+				"package xy;\n"+
+				"public class X {\n"+
+				"	static <T> void comparableValueFrom(T t) {\n"+
+				"		if (t == null || t instanceof Comparable<?>)\n"+
+				"			return;\n"+
+				"	}\n"+
+				"}\n";
+		this.workingCopy = getWorkingCopy("/Converter15/src/xy/X.java", false/*resolve*/);
+		ASTNode node = buildAST(str,this.workingCopy, false);
+
+		assertNotNull("No node", node);
+		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+		CompilationUnit compilationUnit = (CompilationUnit) node;
+		TypeDeclaration type = (TypeDeclaration) compilationUnit.types().get(0);
+		MethodDeclaration method = type.getMethods()[0];
+		IfStatement ifStatement = (IfStatement) method.getBody().statements().get(0);
+		InfixExpression infixExpression = (InfixExpression) ifStatement.getExpression();
+		checkSourceRange(infixExpression, "t == null || t instanceof Comparable<?>", str); //recovery parser propagated
+	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474922
+	public void testBug474922_002() throws JavaModelException {
+		String str =
+				"package xy;\n"+
+				"public class X {\n"+
+				"	static <T> void comparableValueFrom(T t) {\n"+
+				"		if (t == null && t instanceof Comparable<?>)\n"+
+				"			return;\n"+
+				"	}\n"+
+				"}\n";
+		this.workingCopy = getWorkingCopy("/Converter15/src/xy/X.java", false/*resolve*/);
+		ASTNode node = buildAST(str,this.workingCopy, false);
+
+		assertNotNull("No node", node);
+		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+		CompilationUnit compilationUnit = (CompilationUnit) node;
+		TypeDeclaration type = (TypeDeclaration) compilationUnit.types().get(0);
+		MethodDeclaration method = type.getMethods()[0];
+		IfStatement ifStatement = (IfStatement) method.getBody().statements().get(0);
+		InfixExpression infixExpression = (InfixExpression) ifStatement.getExpression();
+		checkSourceRange(infixExpression, "t == null && t instanceof Comparable<?>", str); //recovery parser propagated
+	}
+
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474922
+	public void testBug474922_003() throws JavaModelException {
+		String str =
+				"package xy;\n"+
+				"public class X {\n"+
+				"	static <T> void comparableValueFrom(T t) {\n"+
+				"		if (t == null ? true : t instanceof Comparable<?>)\n"+
+				"			return;\n"+
+				"	}\n"+
+				"}\n";
+		this.workingCopy = getWorkingCopy("/Converter15/src/xy/X.java", false/*resolve*/);
+		ASTNode node = buildAST(str,this.workingCopy, false);
+
+		assertNotNull("No node", node);
+		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+		CompilationUnit compilationUnit = (CompilationUnit) node;
+		TypeDeclaration type = (TypeDeclaration) compilationUnit.types().get(0);
+		MethodDeclaration method = type.getMethods()[0];
+		IfStatement ifStatement = (IfStatement) method.getBody().statements().get(0);
+		checkSourceRange(ifStatement.getExpression(), "t == null ? true : t instanceof Comparable<?>", str); //recovery parser propagated
+	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474922
+	public void testBug474922_004() throws JavaModelException {
+		String str =
+				"package xy;\n"+
+				"public class X {\n"+
+				"	static <T> void comparableValueFrom(T t, int i) {\n"+
+				"		if (t == null || t instanceof Comparable<?> || i != 0)\n"+
+				"			return;\n"+
+				"	}\n"+
+				"}\n";
+		this.workingCopy = getWorkingCopy("/Converter15/src/xy/X.java", false/*resolve*/);
+		ASTNode node = buildAST(str,this.workingCopy, false);
+
+		assertNotNull("No node", node);
+		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+		CompilationUnit compilationUnit = (CompilationUnit) node;
+		TypeDeclaration type = (TypeDeclaration) compilationUnit.types().get(0);
+		MethodDeclaration method = type.getMethods()[0];
+		IfStatement ifStatement = (IfStatement) method.getBody().statements().get(0);
+		InfixExpression infixExpression = (InfixExpression) ifStatement.getExpression();
+		checkSourceRange(infixExpression, "t == null || t instanceof Comparable<?> || i != 0", str); //recovery parser propagated
+	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474922
+	public void testBug474922_005() throws JavaModelException {
+		String str =
+				"package xy;\n"+
+				"public class X {\n"+
+				"	static <T> void comparableValueFrom(T t, int i) {\n"+
+				"		if (i != 0 || t == null || t instanceof Comparable<?>)\n"+
+				"			return;\n"+
+				"	}\n"+
+				"}\n";
+		this.workingCopy = getWorkingCopy("/Converter15/src/xy/X.java", false/*resolve*/);
+		ASTNode node = buildAST(str,this.workingCopy, false);
+
+		assertNotNull("No node", node);
+		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+		CompilationUnit compilationUnit = (CompilationUnit) node;
+		TypeDeclaration type = (TypeDeclaration) compilationUnit.types().get(0);
+		MethodDeclaration method = type.getMethods()[0];
+		IfStatement ifStatement = (IfStatement) method.getBody().statements().get(0);
+		InfixExpression infixExpression = (InfixExpression) ifStatement.getExpression();
+		checkSourceRange(infixExpression, "i != 0 || t == null || t instanceof Comparable<?>", str); //recovery parser propagated
+	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474922
+	public void testBug474922_006() throws JavaModelException {
+		String str =
+				"package xy;\n"+
+				"public class X {\n"+
+				"	static <T> void comparableValueFrom(T t) {\n"+
+				"		if (true == t instanceof Comparable<?>)\n"+
+				"			return;\n"+
+				"	}\n"+
+				"}\n";
+		this.workingCopy = getWorkingCopy("/Converter15/src/xy/X.java", false/*resolve*/);
+		ASTNode node = buildAST(str,this.workingCopy, false);
+
+		assertNotNull("No node", node);
+		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+		CompilationUnit compilationUnit = (CompilationUnit) node;
+		TypeDeclaration type = (TypeDeclaration) compilationUnit.types().get(0);
+		MethodDeclaration method = type.getMethods()[0];
+		IfStatement ifStatement = (IfStatement) method.getBody().statements().get(0);
+		InfixExpression infixExpression = (InfixExpression) ifStatement.getExpression();
+		checkSourceRange(infixExpression, "true == t instanceof Comparable<?>", str); //recovery parser propagated
+	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474922
+	public void testBug474922_007() throws JavaModelException {
+		String str =
+				"package xy;\n"+
+				"public class X {\n"+
+				"	static <T> void comparableValueFrom(T t) {\n"+
+				"		if (t == null & t instanceof Comparable<?>)\n"+
+				"			return;\n"+
+				"	}\n"+
+				"}\n";
+		this.workingCopy = getWorkingCopy("/Converter15/src/xy/X.java", false/*resolve*/);
+		ASTNode node = buildAST(str,this.workingCopy, false);
+
+		assertNotNull("No node", node);
+		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
+		CompilationUnit compilationUnit = (CompilationUnit) node;
+		TypeDeclaration type = (TypeDeclaration) compilationUnit.types().get(0);
+		MethodDeclaration method = type.getMethods()[0];
+		IfStatement ifStatement = (IfStatement) method.getBody().statements().get(0);
+		InfixExpression infixExpression = (InfixExpression) ifStatement.getExpression();
+		checkSourceRange(infixExpression, "t == null & t instanceof Comparable<?>", str); //recovery parser propagated
+	}
 }
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 07e1a7a..dfe84a3 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 1cf7c4a..23193c3 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
@@ -11103,4 +11103,364 @@
 		"}";
 	formatSource(source);
 }
+/**
+ * @bug 470506: formatter option "align field in columns" changed in Mars
+ * @test test that fields separated by extra blank lines are not considered separate groups when aligning
+ * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=470506"
+ */
+public void testBug470506() {
+	this.formatterPrefs.align_type_members_on_columns = true;
+	String source = 
+		"class C {\r\n" + 
+		"	private int						iii;\r\n" + 
+		"	String							sss;\r\n" + 
+		"\r\n" + 
+		"	protected ArrayList<Integer>	aaa;\r\n" + 
+		"\r\n" + 
+		"}";
+	formatSource(source);
+}
+
+/**
+ * @bug 472205: Class extends generic type and implements another type, missing space after ">"
+ */
+public void testBug472205() {
+	String source = 
+		"public class Test<E> extends ArrayList<String> implements Callable<String> {\n" +
+		"}\n" +
+		"\n" +
+		"class A extends B<ClientListener> implements C {\n" +
+		"}\n" +
+		"\n" +
+		"class D extends E<ClientListener> {\n" +
+		"}\n" +
+		"\n" +
+		"class F implements G<ClientListener> {\n" +
+		"}\n" +
+		"\n" +
+		"interface H extends I<ClientListener> {\n" +
+		"}\n";
+	formatSource(source);
+}
+/**
+ * @bug 471780 - [formatter] Regression in enum value Javadoc formatting
+ */
+public void testBug471780() {
+	String source = 
+		"public enum MyEnum {\r\n" + 
+		"	/** A. */\r\n" + 
+		"	A,\r\n" + 
+		"	/** B. */\r\n" + 
+		"	B\r\n" + 
+		"}";
+	formatSource(source);
+}
+/**
+ * https://bugs.eclipse.org/472009 - Formatter does not respect "keep else if on one line"
+ */
+public void testBug472009() {
+	this.formatterPrefs.alignment_for_compact_if |= Alignment.M_FORCE;
+	String source = 
+		"public class A {\r\n" + 
+		"	void a() {\r\n" + 
+		"		if (a == b) {\r\n" + 
+		"\r\n" + 
+		"		} else if (c == d) {\r\n" + 
+		"\r\n" + 
+		"		} else if (e == f) {\r\n" + 
+		"\r\n" + 
+		"		}\r\n" + 
+		"	}\r\n" + 
+		"}";
+	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);
+}
 }
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 3d30c26..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
@@ -7196,4 +7196,130 @@
 		"}";
 	formatSource(source);
 }
+/**
+ * https://bugs.eclipse.org/474011 - [formatter] non-nls strings are duplicated by formatter
+ */
+public void testBug474011() {
+	String source = 
+		"class A {\n" + 
+		"	String aaaaaaaaaaaaaaaa = \"11111111111111111111111111111111111111\"; //$NON-NLS-1$ aaa bbb ccc\n" + 
+		"	String bbbbbbbbbbbbbbbb = \"22222222222222222222222222222222222222\"; //$NON-NLS-1$ //$NON-NLS-1$\n" + 
+		"	String cccccccccccccccc = \"33333333333333333333333333333333333333\"; //$NON-NLS-1$ //$NON-NLS-2$\n" + 
+		"	String dddddddddddddddd = \"44444444444444444444444444444444444444\"; //$NON-NLS-1$ // $NON-NLS-2$\n" + 
+		"	String eeeeeeeeeeeeeeee = \"55555555555555555555555555555555555555\"; //$NON-NLS-1$ // aaa // bbb\n" + 
+		"}";
+	formatSource(source,
+		"class A {\n" + 
+		"	String aaaaaaaaaaaaaaaa = \"11111111111111111111111111111111111111\"; //$NON-NLS-1$ aaa\n" + 
+		"																		// bbb\n" + 
+		"																		// ccc\n" + 
+		"	String bbbbbbbbbbbbbbbb = \"22222222222222222222222222222222222222\"; //$NON-NLS-1$\n" + 
+		"	String cccccccccccccccc = \"33333333333333333333333333333333333333\"; //$NON-NLS-1$ //$NON-NLS-2$\n" + 
+		"	String dddddddddddddddd = \"44444444444444444444444444444444444444\"; //$NON-NLS-1$ //\n" + 
+		"																		// $NON-NLS-2$\n" + 
+		"	String eeeeeeeeeeeeeeee = \"55555555555555555555555555555555555555\"; //$NON-NLS-1$ //\n" + 
+		"																		// aaa\n" + 
+		"																		// //\n" + 
+		"																		// 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 537e9c9..28ec046 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
@@ -14336,5 +14336,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/model/SignatureTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/SignatureTests.java
index ac3fec1..bc98f73 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/SignatureTests.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/SignatureTests.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2012 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
@@ -444,6 +444,17 @@
 }
 /**
  * @see Signature
+ * (regression test for Bug 466512: Unexpected runtime error while computing a text hover)
+ */
+public void testGetTypeParameters7() {
+	String sig = "<S:!-TT;>(Ljava.lang.Class<!-TT;>;)Lxy.HoverTest$TestClass<!-TT;>;";
+	assertStringsEqual(
+			"Unexpected type parameters",
+			"S:!-TT;\n",
+			Signature.getTypeParameters(sig));
+}
+/**
+ * @see Signature
  */
 public void testGetQualifier1() {
 	assertEquals(
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/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
index afecd5c..3b35f21 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
@@ -4121,7 +4121,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/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/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/IfStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java
index 677623b..ad4c07d 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();
@@ -134,6 +136,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/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 89e198f..250a0ef 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
@@ -185,6 +185,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/impl/CompilerOptions.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
index 8245d60..ee26e1d 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.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
@@ -291,6 +291,7 @@
 	public static final String VERSION_1_9 = "1.9"; //$NON-NLS-1$
 	public static final String ERROR = "error"; //$NON-NLS-1$
 	public static final String WARNING = "warning"; //$NON-NLS-1$
+	public static final String INFO = "info"; //$NON-NLS-1$
 	public static final String IGNORE = "ignore"; //$NON-NLS-1$
 	public static final String ENABLED = "enabled"; //$NON-NLS-1$
 	public static final String DISABLED = "disabled"; //$NON-NLS-1$
@@ -426,6 +427,11 @@
 	 * @see #resetDefaults()
 	 */
 	protected IrritantSet warningThreshold;
+	/** 
+	 * Defaults defined at {@link IrritantSet#COMPILER_DEFAULT_INFOS}
+	 * @see #resetDefaults()
+	 */
+	protected IrritantSet infoThreshold;
 	
 	/**
 	 * Default settings are to be defined in {@lnk CompilerOptions#resetDefaults()}
@@ -1551,6 +1557,9 @@
 		if (this.warningThreshold.isSet(irritant)) {
 			return ProblemSeverities.Warning | ProblemSeverities.Optional;
 		}
+		if (this.infoThreshold.isSet(irritant)) {
+			return ProblemSeverities.Info | ProblemSeverities.Optional;
+		}
 		return ProblemSeverities.Ignore;
 	}
 
@@ -1559,6 +1568,9 @@
 			return ERROR;
 		if(this.warningThreshold.isSet(irritant))
 			return WARNING;
+		if (this.infoThreshold.isSet(irritant)) {
+			return INFO;
+		}
 		return IGNORE;
 	}
 	public String getVisibilityString(int level) {
@@ -1575,13 +1587,15 @@
 	}
 
 	public boolean isAnyEnabled(IrritantSet irritants) {
-		return this.warningThreshold.isAnySet(irritants) || this.errorThreshold.isAnySet(irritants);
+		return this.warningThreshold.isAnySet(irritants) || this.errorThreshold.isAnySet(irritants)
+					|| this.infoThreshold.isAnySet(irritants);
 	}
 
 	protected void resetDefaults() {
 		// problem default severities defined on IrritantSet
 		this.errorThreshold = new IrritantSet(IrritantSet.COMPILER_DEFAULT_ERRORS);
 		this.warningThreshold = new IrritantSet(IrritantSet.COMPILER_DEFAULT_WARNINGS);
+		this.infoThreshold = new IrritantSet(IrritantSet.COMPILER_DEFAULT_INFOS);
 		
 		// by default only lines and source attributes are generated.
 		this.produceDebugAttributes = ClassFileConstants.ATTR_SOURCE | ClassFileConstants.ATTR_LINES;
@@ -2404,12 +2418,19 @@
 		if (ERROR.equals(severityString)) {
 			this.errorThreshold.set(irritant);
 			this.warningThreshold.clear(irritant);
+			this.infoThreshold.clear(irritant);
 		} else if (WARNING.equals(severityString)) {
 			this.errorThreshold.clear(irritant);
 			this.warningThreshold.set(irritant);
+			this.infoThreshold.clear(irritant);
+		} else if (INFO.equals(severityString)) {
+			this.errorThreshold.clear(irritant);
+			this.warningThreshold.clear(irritant);
+			this.infoThreshold.set(irritant);
 		} else if (IGNORE.equals(severityString)) {
 			this.errorThreshold.clear(irritant);
 			this.warningThreshold.clear(irritant);
+			this.infoThreshold.clear(irritant);
 		}
 	}
 
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java
index 9832309..547352e 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.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
@@ -82,6 +82,7 @@
 	public static final IrritantSet JAVADOC = new IrritantSet(CompilerOptions.InvalidJavadoc);
 	public static final IrritantSet COMPILER_DEFAULT_ERRORS = new IrritantSet(0); // no optional error by default	
 	public static final IrritantSet COMPILER_DEFAULT_WARNINGS = new IrritantSet(0); // see static initializer below
+	public static final IrritantSet COMPILER_DEFAULT_INFOS = new IrritantSet(0); // As of now, no default values
 //{ObjectTeams: new irritants:
 	public static final IrritantSet NOT_EXACTLY_ONE_BASECALL = new IrritantSet(
             CompilerOptions.NotExactlyOneBasecall);
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/problem/DefaultProblem.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/DefaultProblem.java
index 8a214e0..4c9f016 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/DefaultProblem.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/DefaultProblem.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 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
@@ -253,7 +253,11 @@
  * @return boolean
  */
 public boolean isWarning() {
-	return (this.severity & ProblemSeverities.Error) == 0;
+	return (this.severity & ProblemSeverities.Error) == 0
+			&& (this.severity & ProblemSeverities.Info) == 0;
+}
+public boolean isInfo() {
+	return (this.severity & ProblemSeverities.Info) != 0;
 }
 
 public void setOriginatingFileName(char[] fileName) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemSeverities.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemSeverities.java
index 3c921cf..c6e2e21 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemSeverities.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemSeverities.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
@@ -26,8 +26,9 @@
 	final int Fatal = 128; // when bit is set: problem was either a mandatory error, or an optional+treatOptionalErrorAsFatal
 	final int Ignore = 256; // during handling only
 	final int InternalError = 512;  // always exposed, even when silent error handling policy is in effect.
+	final int Info = 1024; // When bit is set, the unit or project is not flagged.
 
 //{ObjectTeams: signal problem that should be ignored, but yet recorded to match potential @SuppressWarnings
-	final int IgnoredGenerated = 1024;
+	final int IgnoredGenerated = 2048;
 // SH}
 }
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
index 0eef1bd..2f11352 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
@@ -954,8 +954,7 @@
 				 			temp = (InfixExpression) temp.getLeftOperand();
 				 		}
 				 	}
-					int startPosition = infixExpression.getLeftOperand().getStartPosition();
-					infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+				 	setInfixSourcePositions(infixExpression, expression.sourceStart);
 					if (this.resolveBindings) {
 						this.recordNodes(infixExpression, expression);
 					}
@@ -967,16 +966,14 @@
 			Expression leftExpression = convert(leftOperand);
 			infixExpression.setLeftOperand(leftExpression);
 			infixExpression.setRightOperand((Expression)infixExpression.extendedOperands().remove(0));
-			int startPosition = leftExpression.getStartPosition();
-			infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+		 	setInfixSourcePositions(infixExpression, expression.sourceStart);
 			return infixExpression;
 		}
 		Expression leftExpression = convert(expression.left);
 		infixExpression.setLeftOperand(leftExpression);
 		infixExpression.setRightOperand(convert(expression.right));
 		infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_AND);
-		int startPosition = leftExpression.getStartPosition();
-		infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+	 	setInfixSourcePositions(infixExpression, expression.sourceStart);
 		return infixExpression;
 	}
 
@@ -1395,8 +1392,7 @@
 				 			temp = (InfixExpression) temp.getLeftOperand();
 				 		}
 				 	}
-					int startPosition = infixExpression.getLeftOperand().getStartPosition();
-					infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+					setInfixSourcePositions(infixExpression, infixExpression.getLeftOperand().getStartPosition());
 					if (this.resolveBindings) {
 						this.recordNodes(infixExpression, expression);
 					}
@@ -1409,7 +1405,7 @@
 			infixExpression.setLeftOperand(leftExpression);
 			infixExpression.setRightOperand((Expression)infixExpression.extendedOperands().remove(0));
 			int startPosition = leftExpression.getStartPosition();
-			infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+			setInfixSourcePositions(infixExpression, startPosition);
 			return infixExpression;
 		} else if (expression.left instanceof StringLiteralConcatenation
 				&& ((expression.left.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)
@@ -1423,14 +1419,14 @@
 			}
 			infixExpression.extendedOperands().add(convert(expression.right));
 			int startPosition = literal.sourceStart;
-			infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+			setInfixSourcePositions(infixExpression, startPosition);
 			return infixExpression;
 		}
 		Expression leftExpression = convert(expression.left);
 		infixExpression.setLeftOperand(leftExpression);
 		infixExpression.setRightOperand(convert(expression.right));
 		int startPosition = leftExpression.getStartPosition();
-		infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+		setInfixSourcePositions(infixExpression, startPosition);
 		return infixExpression;
 	}
 
@@ -1687,10 +1683,11 @@
 		if (this.resolveBindings) {
 			recordNodes(conditionalExpression, expression);
 		}
-		conditionalExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
 		conditionalExpression.setExpression(convert(expression.condition));
 		conditionalExpression.setThenExpression(convert(expression.valueIfTrue));
-		conditionalExpression.setElseExpression(convert(expression.valueIfFalse));
+		Expression elseExpression = convert(expression.valueIfFalse);
+		conditionalExpression.setElseExpression(elseExpression);
+		conditionalExpression.setSourceRange(expression.sourceStart, elseExpression.getStartPosition() + elseExpression.getLength() - expression.sourceStart);
 		return conditionalExpression;
 	}
 
@@ -1794,7 +1791,7 @@
 		infixExpression.setLeftOperand(leftExpression);
 		infixExpression.setRightOperand(convert(expression.right));
 		int startPosition = leftExpression.getStartPosition();
-		infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+		setInfixSourcePositions(infixExpression, startPosition);
 		switch ((expression.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) {
 			case org.eclipse.jdt.internal.compiler.ast.OperatorIds.EQUAL_EQUAL :
 				infixExpression.setOperator(InfixExpression.Operator.EQUALS);
@@ -2692,8 +2689,7 @@
 				 			temp = (InfixExpression) temp.getLeftOperand();
 				 		}
 				 	}
-					int startPosition = infixExpression.getLeftOperand().getStartPosition();
-					infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+				 	setInfixSourcePositions(infixExpression, expression.sourceStart);
 					if (this.resolveBindings) {
 						this.recordNodes(infixExpression, expression);
 					}
@@ -2705,19 +2701,26 @@
 			Expression leftExpression = convert(leftOperand);
 			infixExpression.setLeftOperand(leftExpression);
 			infixExpression.setRightOperand((Expression)infixExpression.extendedOperands().remove(0));
-			int startPosition = leftExpression.getStartPosition();
-			infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+		 	setInfixSourcePositions(infixExpression, expression.sourceStart);
 			return infixExpression;
 		}
 		Expression leftExpression = convert(expression.left);
 		infixExpression.setLeftOperand(leftExpression);
 		infixExpression.setRightOperand(convert(expression.right));
 		infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_OR);
-		int startPosition = leftExpression.getStartPosition();
-		infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
+	 	setInfixSourcePositions(infixExpression, expression.sourceStart);
 		return infixExpression;
 	}
 
+	private void setInfixSourcePositions(InfixExpression infixExpression, int sourceStart) {
+		int n = infixExpression.extendedOperands().size();
+		Expression rightMostExp = n <= 0 ? infixExpression.getRightOperand() : (Expression) infixExpression.extendedOperands().get(n - 1);
+		int rightSourceEnd = rightMostExp.getStartPosition() + rightMostExp.getLength() - 1;
+		int infixSourceEnd = infixExpression.getStartPosition() + infixExpression.getLength() - 1;
+		infixSourceEnd = rightSourceEnd > infixSourceEnd ? rightSourceEnd : infixSourceEnd;
+		infixExpression.setSourceRange(sourceStart, infixSourceEnd - sourceStart + 1);
+	}
+
 	public PostfixExpression convert(org.eclipse.jdt.internal.compiler.ast.PostfixExpression expression) {
 		final PostfixExpression postfixExpression = new PostfixExpression(this.ast);
 		if (this.resolveBindings) {
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 0d17f9e..f1caf75 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
@@ -572,6 +572,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>
@@ -594,8 +611,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.
@@ -605,11 +622,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();
@@ -828,6 +846,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();
+
 //{ObjectTeams: added isTeam(), isRole(), getBaseClass(), isClassPartOf(), getOptimalName()
 	/**
 	 * Returns whether this type binding represents a team type.
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 90eab94..9515c1c 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
@@ -45,16 +45,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 98ed738..ec5abf0 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
@@ -478,6 +478,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() {
@@ -777,6 +784,11 @@
 	public IAnnotationBinding[] getTypeAnnotations() {
 		return AnnotationBinding.NoAnnotations;
 	}
+
+	@Override
+	public IAnnotationBinding[][] getTypeAnnotationsOnDimensions() {
+		return AnnotationBinding.NoAnnotationsOnDimensions;
+	}
 //{ObjectTeams: new lookup-functions
 	public org.eclipse.jdt.internal.compiler.lookup.TypeBinding getResolvedBinding() {
 		return this.binding;
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 eeb5f7f..7a26dbd 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
@@ -83,6 +83,7 @@
 	private IVariableBinding[] fields;
 	private IAnnotationBinding[] annotations;
 	private IAnnotationBinding[] typeAnnotations;
+	private IAnnotationBinding[][] typeAnnotationsOnDimensions;
 	private IMethodBinding[] methods;
 	private ITypeBinding[] members;
 	private ITypeBinding[] interfaces;
@@ -175,6 +176,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
@@ -667,6 +696,19 @@
 // SH}	
 	}
 
+	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)
@@ -1084,6 +1126,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();
@@ -1471,6 +1515,14 @@
 //	ira+SH}
 
 	/*
+	 * @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() {
@@ -1661,6 +1713,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 e78162b..5922e45 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
@@ -1496,7 +1496,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 16f575f..6fca372 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
@@ -18,6 +18,7 @@
 import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameLBRACE;
 import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameRBRACE;
 import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameSEMICOLON;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_JAVADOC;
 import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamebase;
 import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameelse;
 import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamefinally;
@@ -201,9 +202,11 @@
 		handleBodyDeclarations(node.bodyDeclarations());
 
 		List<EnumConstantDeclaration> enumConstants = node.enumConstants();
-		for (int i = 0; i < enumConstants.size() - 1; i++) {
+		for (int i = 0; i < enumConstants.size(); i++) {
 			EnumConstantDeclaration declaration = enumConstants.get(i);
-			if (declaration.getAnonymousClassDeclaration() != null)
+			if (declaration.getJavadoc() != null)
+				this.tm.firstTokenIn(declaration, TokenNameCOMMENT_JAVADOC).breakBefore();
+			if (declaration.getAnonymousClassDeclaration() != null && i < enumConstants.size() - 1)
 				this.tm.firstTokenAfter(declaration, TokenNameCOMMA).breakAfter();
 		}
 
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 2e4940c..db9623a 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
@@ -993,7 +993,8 @@
 
 	private void handleToken(ASTNode node, int tokenType, boolean spaceBefore, boolean spaceAfter) {
 		if (spaceBefore || spaceAfter) {
-			Token token = this.tm.firstTokenIn(node, tokenType);
+			Token token = this.tm.get(this.tm.findIndex(node.getStartPosition(), tokenType, true));
+			// ^not the same as "firstTokenIn(node, tokenType)" - do not assert the token is inside the node
 			handleToken(token, spaceBefore, spaceAfter);
 		}
 	}
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 e5b8ba8..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,12 +227,14 @@
 		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;
 		}
 		int prefixEnd = commentToken.originalStart + 1;
-		if (prefix.tokenType == TokenNameCOMMENT_LINE)
-			prefixEnd = Math.max(prefixEnd, prefix.originalEnd);
+		if (!prefix.hasNLSTag())
+			prefixEnd = Math.max(prefixEnd, prefix.originalEnd); // comments can start with more than 2 slashes
 		prefix = new Token(commentToken.originalStart, prefixEnd, TokenNameCOMMENT_LINE);
 		if (whitespace == null) {
 			prefix.breakBefore();
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 121e36f..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,9 +23,7 @@
 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.DefaultCodeFormatterOptions;
 import org.eclipse.jdt.internal.formatter.Token;
 import org.eclipse.jdt.internal.formatter.TokenManager;
 import org.eclipse.jdt.internal.formatter.TokenTraverser;
@@ -68,52 +66,23 @@
 
 	final TokenManager tm;
 
-	private final DefaultCodeFormatterOptions options;
-
-	public FieldAligner(TokenManager tokenManager, DefaultCodeFormatterOptions options) {
+	public FieldAligner(TokenManager tokenManager) {
 		this.tm = tokenManager;
-		this.options = options;
 	}
 
-	public void prepareAlign(TypeDeclaration node) {
-		List<FieldDeclaration> bodyDeclarations = node.bodyDeclarations();
+	public void prepareAlign(List<FieldDeclaration> bodyDeclarations) {
 		ArrayList<FieldDeclaration> alignGroup = new ArrayList<>();
-		BodyDeclaration previous = null;
 		for (BodyDeclaration declaration : bodyDeclarations) {
-			if (!alignGroup.isEmpty()) {
-				if ((declaration instanceof FieldDeclaration) && !areSeparated(previous, declaration)) {
-					alignGroup.add((FieldDeclaration) declaration);
-				} else {
-					alignFields(alignGroup);
-					alignGroup = new ArrayList<>();
-				}
+			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);
-			}
-			previous = declaration;
 		}
 		alignFields(alignGroup);
 	}
 
-	private boolean areSeparated(BodyDeclaration declaration1, BodyDeclaration declaration2) {
-		// check if there are more empty lines between fields than normal
-		if (this.options.number_of_empty_lines_to_preserve <= this.options.blank_lines_before_field)
-			return false;
-		int maxLineBreaks = 0;
-		int from = this.tm.lastIndexIn(declaration1, -1);
-		int to = this.tm.firstIndexIn(declaration2, -1);
-
-		Token previous = this.tm.get(from);
-		for (int i = from + 1; i <= to; i++) {
-			Token token = this.tm.get(i);
-			maxLineBreaks = Math.max(maxLineBreaks, this.tm.countLineBreaksBetween(previous, token));
-			previous = token;
-		}
-		return maxLineBreaks - 1 > this.options.blank_lines_before_field;
-	}
-
 	private void alignFields(ArrayList<FieldDeclaration> alignGroup) {
 		if (alignGroup.size() < 2)
 			return;
@@ -127,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) {
@@ -144,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();
@@ -178,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 0c7e84e..cbb012d 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
@@ -39,6 +39,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;
@@ -110,7 +111,7 @@
 	final DefaultCodeFormatterOptions options;
 	final int kind;
 	
-	FieldAligner fieldAligner;
+	final FieldAligner fieldAligner;
 
 	int importsStart = -1, importsEnd = -1;
 
@@ -129,6 +130,8 @@
 		this.tm = tokenManager;
 		this.options = options;
 		this.kind = kind;
+
+		this.fieldAligner = new FieldAligner(this.tm);
 	}
 
 	@Override
@@ -184,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.options);
-			}
-			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;
 	}
 
@@ -256,6 +270,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;
 	}
 
@@ -337,7 +355,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()) {
@@ -461,7 +480,7 @@
 				this.wrapIndexes.add(thenIndex);
 		}
 		Statement elseStatement = node.getElseStatement();
-		if (elseStatement != null && !(elseStatement instanceof Block)) {
+		if (elseStatement != null && !(elseStatement instanceof Block) && !(elseStatement instanceof IfStatement)) {
 			int elseIndex = this.tm.firstIndexIn(elseStatement, -1);
 			if (this.tm.get(elseIndex).getLineBreaksBefore() == 0)
 				this.wrapIndexes.add(elseIndex);
@@ -740,8 +759,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);
 	}
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
index 7f9ba85..d5c7e64 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
@@ -367,7 +367,7 @@
 	 *    error or a warning.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -380,7 +380,7 @@
 	 *    scenario either as an error or a warning.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -392,7 +392,7 @@
 	 *    error or a warning.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -436,7 +436,7 @@
 	 *    catch blocks corresponding to checked exceptions.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -448,7 +448,7 @@
 	 *    variables (that is, variables never read from).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLocal"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -460,7 +460,7 @@
 	 *    parameters (that is, parameters never read from).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameter"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -472,7 +472,7 @@
 	 *    parameters (that is, the thrown exception is never read from).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -527,7 +527,7 @@
 	 *    reference.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedImport"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 2.0
@@ -541,7 +541,7 @@
 	 *    in an error. From Java7 on, unused type arguments are being tolerated, and optionally warned against.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.4
@@ -555,7 +555,7 @@
 	 *    performance implications.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @category CompilerOptionID
@@ -568,7 +568,7 @@
 	 * unused type parameter. </p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedTypeParameter"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.9
@@ -582,7 +582,7 @@
 	 *    String literal (that is, not tagged with <code>//$NON-NLS-&lt;n&gt;$</code>).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 2.0
@@ -595,7 +595,7 @@
 	 *    used as an identifier (reserved keyword in 1.4).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.assertIdentifier"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 2.0
@@ -608,7 +608,7 @@
 	 *    used as an identifier (reserved keyword in 1.5).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.enumIdentifier"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -622,7 +622,7 @@
 	 *    be qualified with a type name.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 2.1
@@ -636,7 +636,7 @@
 	 *    preferably be qualified with its declaring type name.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -649,7 +649,7 @@
 	 *    has no effect (e.g <code>'x = x'</code>).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noEffectAssignment"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 2.1
@@ -668,7 +668,7 @@
 	 *    </pre>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 2.1
@@ -681,7 +681,7 @@
 	 *    method or field is declared but never used within the same unit.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 2.1
@@ -694,7 +694,7 @@
 	 *    declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.localVariableHiding"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -721,7 +721,7 @@
 	 *    declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fieldHiding"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -735,7 +735,7 @@
 	 *    a nested type is hiding another nested type defined in same unit.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.typeParameterHiding"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -748,7 +748,7 @@
 	 *    of a control statement  (where it probably was meant to be a boolean comparison).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -761,7 +761,7 @@
 	 *    entered by falling through previous case. Empty cases are allowed.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fallthroughCase"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.2
@@ -774,7 +774,7 @@
 	 *    unnecessary semicolon is encountered.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.emptyStatement"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -785,7 +785,7 @@
 	 * Compiler option ID.
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.booleanMethodThrowingException"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -799,7 +799,7 @@
 	 *    is unnecessary.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -812,7 +812,7 @@
 	 *    nested within an <code>else</code> clause (in situation where then clause is not completing normally).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryElse"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -825,7 +825,7 @@
 	 *    documented with any comment.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -837,7 +837,7 @@
 	 * <p>When enabled, the compiler will issue an error or a warning when a finally block does not complete normally.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -856,7 +856,7 @@
 	 *    and {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -934,7 +934,7 @@
 	 *    In order to improve code readability, it should be qualified, e.g. <code>'x'</code> should rather be written <code>'this.x'</code>.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -953,7 +953,7 @@
 	 *    invalidates type safety since involving raw types (e.g. invoking <code>#foo(X&lt;String&gt;)</code> with arguments <code>(X)</code>).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -967,7 +967,7 @@
 	 *    reject raw references to generic types.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.rawTypeReference"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.2
@@ -997,7 +997,7 @@
 	 *    bound corresponding to a final type; since final types cannot be further extended, the parameter is pretty useless.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finalParameterBound"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1010,7 +1010,7 @@
 	 *    of a <code>serialVersionUID</code> field. This field must be declared as static final and be of type <code>long</code>.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingSerialVersion"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1024,7 +1024,7 @@
 	 *    invoked with arguments <code>("foo", null)</code>).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1037,7 +1037,7 @@
 	 *    conversion is performed.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.autoboxing"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1050,7 +1050,7 @@
 	 *    as a super-interface. Though legal, this is discouraged.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1063,7 +1063,7 @@
 	 *    declaration which overrides a superclass method but has no <code>@Override</code> annotation.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1091,7 +1091,7 @@
 	 *    carrying a <code>@deprecated</code> doc tag but having no corresponding <code>@Deprecated</code> annotation.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1104,7 +1104,7 @@
 	 * overrides Object.equals(Object) but does not override hashCode().</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.5
@@ -1118,7 +1118,7 @@
 	 * going to be signaled as being dead code.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deadCode"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.5
@@ -1145,7 +1145,7 @@
 	 * 		Reporting is further controlled by the option {@link #COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT}.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1176,7 +1176,7 @@
 	 * 		against each switch statement that lacks a default case.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingDefaultCase"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1197,7 +1197,7 @@
 	 *    <code>LABEL: { break; }</code>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLabel"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.2
@@ -1210,7 +1210,7 @@
 	 *    When enabled, the compiler will issue an error or a warning for a problem in Javadoc.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadoc"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -1297,7 +1297,7 @@
 	 *    also see the setting {@link #COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY}.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTags"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -1351,7 +1351,7 @@
 	 *    also see the setting {@link #COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY}.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocComments"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.0
@@ -1398,7 +1398,7 @@
 	 *    is used in String concatenations (for example, <code>"hello" + new char[]{'w','o','r','l','d'}</code>).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 2.1
@@ -1439,7 +1439,7 @@
 	 *    assigned to.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.parameterAssignment"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.2
@@ -1452,7 +1452,7 @@
 	 *    not been declared as <code>static</code>, even though it qualifies as one.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.7
@@ -1466,7 +1466,7 @@
 	 *    when another method doesn't override it.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.7
@@ -1481,7 +1481,7 @@
 	 *    flow analysis shows that the method <code>close()</code> is not invoked locally on that value.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportUnclosedCloseable"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1497,7 +1497,7 @@
 	 *    not invoked locally on that value for all execution paths.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1512,7 +1512,7 @@
 	 *    not managed by a try-with-resources block.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1623,7 +1623,7 @@
 	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code>.</dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code>.</dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1690,7 +1690,7 @@
 	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"error"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1722,7 +1722,7 @@
 	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1740,7 +1740,7 @@
 	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.8
@@ -1799,7 +1799,7 @@
 	 *    in order to make this (legal) change of contract explicit.</p>   
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.9
@@ -1907,7 +1907,7 @@
 	 *    to the access rule specifications.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.forbiddenReference"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"error"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1920,7 +1920,7 @@
 	 *    to the access rule specifications.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.discouragedReference"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1976,7 +1976,7 @@
 	 *    it cannot handle inside a <code>@SuppressWarnings</code> annotation.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.1
@@ -1991,7 +1991,7 @@
 	 *    silencing the warning for unnecessary <code>@SuppressWarnings</code>, as it is the master switch to silence ALL warnings.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedWarningToken"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.4
@@ -2007,7 +2007,7 @@
 	 *    is enabled.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullReference"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.2
@@ -2024,7 +2024,7 @@
 	 *    is enabled.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.potentialNullReference"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.3
@@ -2040,7 +2040,7 @@
 	 *    is enabled.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullCheck"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.3
@@ -2053,7 +2053,7 @@
 	 *    the super invocation.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.3
@@ -2067,7 +2067,7 @@
 	 *    of its supertypes.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.4
@@ -2080,7 +2080,7 @@
 	 * is involving identical operands (e.g <code>'x == x'</code>).</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.comparingIdentical"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
 	 * </dl>
 	 * @since 3.5
@@ -2093,7 +2093,7 @@
 	 * overrides a synchronized method without having a synchronized modifier.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.5
@@ -2106,7 +2106,7 @@
 	 * neither by holding a reference nor by invoking one of the object's methods.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.6
@@ -2120,7 +2120,7 @@
 	 * <p>This option only has an effect if the compiler compliance is 1.7 or greater.</p>
 	 * <dl>
 	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments"</code></dd>
-	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
+	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
 	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
 	 * </dl>
 	 * @since 3.7.1
@@ -2752,6 +2752,12 @@
 	/**
 	 * Configurable option value: {@value}.
 	 * @category OptionValue
+	 * @since 3.12
+	 */
+	public static final String INFO = "info"; //$NON-NLS-1$
+	/**
+	 * Configurable option value: {@value}.
+	 * @category OptionValue
 	 */
 	public static final String COMPUTE = "compute"; //$NON-NLS-1$
 	/**
@@ -3926,7 +3932,7 @@
 	 * <code>null</code> otherwise. Non-null return values are taken from the
 	 * constants defined by this class whose names start with
 	 * <code>COMPILER_PB</code> and for which the possible values of the
-	 * option are defined by <code>{ "error", "warning", "ignore" }</code>. A
+	 * option are defined by <code>{ "error", "warning", "info", "ignore" }</code>. A
 	 * null return value means that the provided problem ID is unknown or that
 	 * it matches a problem whose severity cannot be configured.
 	 * @param problemID one of the problem IDs defined by {@link IProblem}
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java
index 0640b73..a9bc0a8 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java
@@ -2453,6 +2453,14 @@
 							// not a type variable signature -> it is a new type parameter
 						}
 						break;
+					case C_CAPTURE:
+						try {
+							i = Util.scanCaptureTypeSignature(methodOrTypeSignature, i);
+							i++; // position at start of next param if any
+						} catch (IllegalArgumentException e) {
+							// not a capture variable signature -> it is a new type parameter
+						}
+						break;
 					// default: another type parameter is starting
 				}
 			}
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 080d1a1..6632c46 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
@@ -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
@@ -1249,7 +1249,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/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java
index 4d38ecc..c56a4b1 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.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
@@ -85,6 +85,7 @@
 };
 public final static Integer S_ERROR = new Integer(IMarker.SEVERITY_ERROR);
 public final static Integer S_WARNING = new Integer(IMarker.SEVERITY_WARNING);
+public final static Integer S_INFO = new Integer(IMarker.SEVERITY_INFO);
 public final static Integer P_HIGH = new Integer(IMarker.PRIORITY_HIGH);
 public final static Integer P_NORMAL = new Integer(IMarker.PRIORITY_NORMAL);
 public final static Integer P_LOW = new Integer(IMarker.PRIORITY_LOW);
@@ -801,7 +802,7 @@
 			// standard attributes
 			int index = 0;
 			allValues[index++] = problem.getMessage(); // message
-			allValues[index++] = problem.isError() ? S_ERROR : S_WARNING; // severity
+			allValues[index++] = problem.isError() ? S_ERROR : problem.isWarning() ? S_WARNING : S_INFO; // severity
 			allValues[index++] = new Integer(id); // ID
 			allValues[index++] = new Integer(problem.getSourceStart()); // start
 			allValues[index++] = new Integer(problem.getSourceEnd() + 1); // end
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/eval/RequestorWrapper.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/eval/RequestorWrapper.java
index 9eda025..c189f44 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/eval/RequestorWrapper.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/eval/RequestorWrapper.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2009 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
@@ -59,7 +59,7 @@
 		marker.setAttribute(IMarker.LINE_NUMBER, problem.getSourceLineNumber());
 		//marker.setAttribute(IMarker.LOCATION, "#" + problem.getSourceLineNumber());
 		marker.setAttribute(IMarker.MESSAGE, problem.getMessage());
-		marker.setAttribute(IMarker.SEVERITY, (problem.isWarning() ? IMarker.SEVERITY_WARNING : IMarker.SEVERITY_ERROR));
+		marker.setAttribute(IMarker.SEVERITY, (problem.isError() ? IMarker.SEVERITY_ERROR : problem.isWarning() ? IMarker.SEVERITY_WARNING : IMarker.SEVERITY_INFO));
 		marker.setAttribute(IMarker.SOURCE_ID, JavaBuilder.SOURCE_ID);
 		this.requestor.acceptProblem(marker, new String(fragmentSource), fragmentKind);
 	} catch (CoreException e) {
diff --git a/org.eclipse.jdt.core/pom.xml b/org.eclipse.jdt.core/pom.xml
index e4d96ca..35f3b5a 100644
--- a/org.eclipse.jdt.core/pom.xml
+++ b/org.eclipse.jdt.core/pom.xml
@@ -50,7 +50,6 @@
 	  </plugin>
       <plugin>
         <artifactId>maven-resources-plugin</artifactId>
-        <version>2.6</version>
         <executions>
           <execution>
             <id>copy-batch-compiler-source</id>
diff --git a/org.eclipse.jdt.core/scripts/ecj.1 b/org.eclipse.jdt.core/scripts/ecj.1
index 87ad248..1461b12 100644
--- a/org.eclipse.jdt.core/scripts/ecj.1
+++ b/org.eclipse.jdt.core/scripts/ecj.1
@@ -1,479 +1,853 @@
-.TH ecj 1 "18 March 2014"

-.LP

-.SH NAME

-ecj \- the eclipse JDT Batch Compiler

-.SH SYNOPSIS

-.B ecj <options> infile

-.B ...

-.SH DESCRIPTION

-.B ecj is the batch compiler from Eclipse and is available as ecj.jar.

-Since 3.3, this jar also contains the support for jsr199 (Compiler API) 

-and the support for jsr269 (Annotation processing). In order to use the 

-annotations processing support, a 1.6 VM is required.

-

-.SH OPTIONS

-Option Summary

-.sp

-Here is a summary of all the options, grouped by type.  Explanations are in the following sections.

-.sp

-.ul 1

-ClassPath Options

-.sp

-\fB\-bootclasspath \-cp|\-classpath \-extdirs \-endorseddirs \-sourcepath \-d \-encoding\fR

-.sp

-.ul 1

-Compliance Options

-.sp

-.B \-target \-1.3 \-1.4 \-1.5 \-1.6 \-1.7 \-1.8 \-source 

-.sp

-.ul 1

-Warning Options

-.sp

-.B \-?:warn \-help:warn \-warn:... \-nowarn \-err:... \-deprecation \-properties 

-.sp

-.ul 

-Debug Options

-.sp

-\fB\-g \-preserveAllLocals \-Akey[=\fIvalue\fB] \-proc:[only|none] \-processor \-processorpath \-s \-XprintProcessorInfo \-XprintRounds \-classNames\fR

-.sp

-.ul 

-Ignored Options (for compatibility with javac options)

-.sp

-\-J \-X \-O

-.sp

-.ul 

-Advanced Options

-.sp

-\fB@<file> \-maxProblems \-log \-Xemacs \-proceedOnError \-verbose \-referenceInfo \-progress \-time \-noExit \-repeat \-inlineJSR \-enableJavaDoc \-missingNullDefault 

-.sp

-.ul 

-Helping Options

-.sp

-\-? \-help \-v \-version \-showversion

-.B

-.IP \-bootclasspath <dir 1>;<dir 2>;...;<dir P>

-This is a list of directories or jar files used to bootstrap the class files used by the compiler. By default the libraries of the running VM are used. Entries are separated by the platform path separator.

-Each directory or file can specify access rules for types between '[' and ']'. 

-If no bootclasspath is specified, the compiler will infer it using the following system properties sun.boot.class.path, vm.boot.class.path or org.apache.harmony.boot.class.path in this order respectively

-

-.IP "\-cp|\-classpath <dir 1>;dir2;...<dir P>"

-This is a list of directories or jar files used to compile the source files. The default value is the value of the property "java.class.path". Entries are separated by the platform path separator.

-Each directory or file can specify access rules for types between '[' and ']' (e.g. [\-X] to forbid access to type X, [~X] to discourage access to type X, [+p/X:\-p/*] to forbid access to all types in package p but allow access to p/X).

-The compiler follows the Class-Path clauses of jar files' manifests recursively and appends each referenced jar file to the end of the classpath, provided it is not on the classpath yet.

-

-.IP "\-extdirs <dir 1>;<dir 2>;...;<dir P>"

-This is a list of directories used to specify the location of extension zip/jar files. Entries are separated by the platform path separator.

-

-.IP "\-endorseddirs <dir 1>;<dir 2>;...;<dir P>"

-This is a list of directories used to specify the location of endorsed zip/jar files. Entries are separated by the platform path separator.

-

-.IP "\-sourcepath <dir 1>;<dir 2>;...;<dir P>"

-This is a list of directories used to specify the source files. Entries are separated by the platform path separator.  Each directory can specify access rules for types between '[' and ']'.

-

-.IP "\-d <dir 1>|none"

-This is used to specify in which directory the generated .class files should be dumped. If it is omitted, no package directory structure is created.

-If you want to generate no .class file at all, use \-d none.

-

-.IP "\-encoding <encoding name>"

-Specify default encoding for all source files. Custom encoding can also be specified on a per file basis by suffixing each input source file/folder name with [<encoding name>]. For example X.java[utf8] would specify the UTF-8 encoding for the compilation unit X.java located in the current user directory. 

-If multiple default source file encodings are specified, the last one will be used.

-

-For example:

-

-�... \-encoding UTF-8 X.java[Cp1252] Y.java[UTF-16] Z.java ....

-All source files will be read using UTF-8 encoding (this includes Z.java). X.java will be read using Cp1252 encoding and Y.java will be read using UTF-16 encoding.

-�... \-encoding UTF-8 -encoding UTF-16 ....

-All source files will be read using UTF-16 encoding. The \-encoding option for UTF-8 is ignored.

-�... \-encoding Cp1252 /foo/bar/X.java[UTF-16] /foo/bar[UTF-8] ....

-All source files will be read using Cp1252 encoding. X.java is the only file inside the /foo/bar directory to be read using the encoding UTF-16. All other files in that directory will use UTF-8 encoding.

-

-.IP "\-target 1.1 to 1.8 or (5, 5.0, etc)"

-This specifies the .class file target setting. The possible value are: 

-�1.1 (major version: 45 minor: 3)

-�1.2 (major version: 46 minor: 0)

-�1.3 (major version: 47 minor: 0)

-�1.4 (major version: 48 minor: 0)

-�1.5, 5 or 5.0 (major version: 49 minor: 0)

-�1.6, 6 or 6.0 (major version: 50 minor: 0)

-�1.7, 7 or 7.0 (major version: 51 minor: 0)

-�1.8, 8 or 8.0 (major version: 132 minor: 0)

-Defaults are: 

-�1.1 in \-1.3 mode

-�1.2 in \-1.4 mode

-�1.5 in \-1.5 mode

-�1.6 in \-1.6 mode

-�1.7 in \-1.7 mode

-�1.8 in \-1.8 mode

-clcd1.1 can be used to generate the StackMap attribute.

-

-.IP \-1.3

-Set compliance level to 1.3. Implicit \-source 1.3 \-target 1.1.

-

-.IP \-1.4

-Set compliance level to 1.4 (default). Implicit \-source 1.3 \-target 1.2.

-

-.IP \-1.5

-Set compliance level to 1.5. Implicit \-source 1.5 \-target 1.5.

-

-.IP \-1.6

-Set compliance level to 1.6. Implicit \-source 1.6 \-target 1.6.

-

-.IP \-1.7

-Set compliance level to 1.7. Implicit \-source 1.7 \-target 1.7.

-

-.IP \-1.8

-Set compliance level to 1.8. Implicit \-source 1.8 \-target 1.8.

-

-.IP "\-source 1.1 to 1.8 or (5, 5.0, etc)"

-This is used to specify the source level expected by the compiler.

-The possible value are: 

-�1.3

-�1.4

-�1.5, 5 or 5.0

-�1.6, 6 or 6.0

-�1.7, 7 or 7.0

-�1.8, 8 or 8.0

-

-Defaults are: 

-�1.3 in \-1.3 mode

-�1.3 in \-1.4 mode

-�1.5 in \-1.5 mode

-�1.6 in \-1.6 mode

-�1.7 in \-1.7 mode

-�1.8 in \-1.8 mode

-In 1.4, assert is treated as a keyword. In 1.5 and 1.6, enum and assert are treated as a keywords.

-

-

-.IP "\-?:warn \-help:warn"

-Display advanced warning options

-

-.IP "\-warn:..."

-Specify the set of enabled warnings.

-\-warn:none disable all warnings 

-\-warn:<warning tokens separated by ,> enable exactly the listed warnings 

-\-warn:+<warning tokens separated by ,> enable additional warnings 

-\-warn:\-<warning tokens separated by ,> disable specific warnings 

-

-Examples:

-

-�\-warn:unusedLocal,deprecation enables only the given two warning options and disables all the other options

-�\-warn:\-unusedLocal,deprecation,+fallthrough disables unusedLocal and deprecation, enables fallthrough, and leaves the other warning options untouched

-In the column Default below, a mark "+/-" indicates that an option covers several fine grained warning variants, some of which are enabled by default, others disabled. This means that specifying the given option with "+" will enable more warnings than the default, and specifying "-" disables some that are enabled by default. 

-.sp

-.IP 

-.in +.5i

-+/-  allDeadCode dead code including trivial if (DEBUG) check

-.sp

-+/- allDeprecation deprecation even inside deprecated code 

-.sp 

-- allJavadoc invalid or missing Javadoc 

-.sp 

-- allOver\-ann all missing @Override annotations (superclass and superinterfaces) 

-.sp 

-- all-static-method all method can be declared as static warnings 

-.sp 

-+ assertIdentifier occurrence of assert used as identifier 

-.sp 

-- boxing autoboxing conversion 

-.sp 

-+ charConcat when a char array is used in a string concatenation without being converted explicitly to a string 

-.sp 

-+ compareIdentical comparing identical expressions 

-.sp 

-- conditionAssign possible accidental boolean assignment 

-.sp 

-+ constructorName method with constructor name 

-.sp 

-+ deadCode dead code excluding trivial if (DEBUG) check 

-.sp 

-- dep\-ann missing @Deprecated annotation 

-.sp 

-+/- deprecation usage of deprecated type or member outside deprecated code 

-.sp 

-+ discouraged use of types matching a discouraged access rule 

-.sp 

-- emptyBlock undocumented empty block 

-.sp 

-+ enumIdentifier occurrence of enum used as identifier 

-.sp 

-+ enumSwitch incomplete enum switch 

-.sp 

-- enumSwitchPedantic report missing enum switch cases even in the presence of a default case 

-.sp 

-- fallthrough possible fall-through case 

-.sp 

-- fieldHiding field hiding another variable 

-.sp 

-+ finalBound type parameter with final bound 

-.sp 

-+ finally finally block not completing normally 

-.sp 

-+ forbidden use of types matching a forbidden access rule 

-.sp 

-- hashCode missing hashCode() method when overriding equals() 

-.sp 

-+/- hiding macro for fieldHiding, localHiding, maskedCatchBlock, and typeHiding 

-.sp 

-- includeAssertNull raise null warnings for variables that got tainted in an assert expression 

-.sp 

-- indirectStatic indirect reference to static member 

-.sp 

-- inheritNullAnnot consider null annotations as being inherited from an overridden method to any overriding methods 

-.sp 

-+ intfAnnotation annotation type used as super interface 

-.sp 

-+ intfNonInherited interface non-inherited method compatibility 

-.sp 

-- intfRedundant find redundant superinterfaces 

-.sp 

-- invalidJavadoc macro to toggle the 'malformed Javadoc comments' option and all its sub-options listed below 

-.sp 

-- invalidJavadocTag report invalid Javadoc tags in Javadoc comments. 

-.sp 

-- invalidJavadocTagDep report invalid deprecated references in Javadoc tag arguments 

-.sp 

-- invalidJavadocTagNotVisible report invalid non-visible references in Javadoc tag arguments 

-.sp 

-- invalidJavadocVisibility(<visibility>) specify visibility modifier ("public", "protected" or "private") for malformed Javadoc tag warnings. Usage example: invalidJavadocVisibility(public) 

-.sp 

-- javadoc invalid Javadoc 

-.sp 

-- localHiding local variable hiding another variable 

-.sp 

-+ maskedCatchBlock hidden catch block 

-.sp 

-- missingJavadocTags macro to toggle the 'missing Javadoc tags' option and all its sub-options listed below 

-.sp 

-- missingJavadocTagsMethod report missing Javadoc tags for a method's type parameters 

-.sp 

-- missingJavadocTagsOverriding report missing Javadoc tags in overriding methods 

-.sp 

-- missingJavadocTagsVisibility(<visibility>) specify visibility modifier ("public", "protected" or "private") for missing Javadoc tags warnings. Usage example: missingJavadocTagsVisibility(public) 

-.sp 

-- missingJavadocComments macro to toggle the 'missing Javadoc comments' option and all its sub-options listed below 

-.sp 

-- missingJavadocCommentsOverriding report missing Javadoc comments in overriding methods 

-.sp 

-- missingJavadocCommentsVisibility(<visibility>) specify visibility modifier ("public", "protected" or "private") for missing Javadoc comments warnings. Usage example: missingJavadocCommentsVisibility(public) 

-.sp 

-- nls non-nls string literals (lacking of tags //$NON-NLS-<n>) 

-.sp 

-+ noEffectAssign assignment with no effect 

-.sp 

-+ nonnullNotRepeated nonnull parameter annotation from overridden method is not repeated in an overriding method. Is effective only with the nullAnnot option enabled. 

-.sp 

-+/- null potential missing or redundant null check 

-.sp 

-- nullAnnot enable annotation based null analysis.

-If desired, the annotation types to be interpreted by the compiler can be specified by appending (nullable|nonnull|nonnullbydefault), where each annotation type is specified using its fully qualified name.

-Usage example: nullAnnot(p.Nullable|p.NonNull|p.NonNullByDefault)

-.sp 

-Enabling this option enables all null-annotation related sub-options. These can be individually controlled using options listed below 

-.sp 

-- nullAnnotConflict report conflicts between null annotation specified and nullness inferred. Is effective only with the nullAnnot option enabled. 

-.sp 

-- nullAnnotRedundant report redundant specification of null annotation. Is effective only with the nullAnnot option enabled. 

-.sp 

-- nullDereference missing null check 

-.sp 

-- nullUncheckedConversion report unchecked conversion from unannotated type to @NonNull type. Is effective only with the nullAnnot option enabled. 

-.sp 

-- over-ann missing @Override annotation (superclass only) 

-.sp 

-- paramAssign assignment to a parameter 

-.sp 

-+ pkgDefaultMethod attempt to override package-default method 

-.sp 

-+ raw usage a of raw type (instead of a parameterized type) 

-.sp 

-+/- resource (potentially) unsafe usage of resource of type Closeable 

-.sp 

-- semicolon unnecessary semicolon or empty statement 

-.sp 

-+ serial missing serialVersionUID 

-.sp 

-- specialParamHiding constructor or setter parameter hiding another field 

-.sp 

-+/- static-access macro for indirectStatic and staticReceiver 

-.sp 

-- static-method an instance method that could be as a static method 

-.sp 

-+ staticReceiver if a non static receiver is used to get a static field or call a static method 

-.sp 

-- super overriding a method without making a super invocation 

-.sp 

-+ suppress enable @SuppressWarnings 

-.sp 

-- switchDefault switch statement lacking a default case 

-.sp 

-- syncOverride missing synchronized in synchronized method override 

-.sp 

-- syntheticAccess when performing synthetic access for innerclass 

-.sp 

-- tasks enable support for tasks tags in source code 

-.sp 

-+ typeHiding type parameter hiding another type 

-.sp 

-+ unavoidableGenericProblems report even unavoidable type safety problems due to raw APIs 

-.sp 

-+ unchecked unchecked type operation 

-.sp 

-- unnecessaryElse unnecessary else clause 

-.sp 

-- unqualifiedField unqualified reference to field 

-.sp 

-+/- unused macro for unusedImport, unusedLabel, unusedLocal, unusedPrivate, unusedThrown, unusedTypeArgs, and unusedTypeParameter 

-.sp 

-- unusedAllocation allocating an object that is not used 

-.sp 

-- unusedArgument unused method parameter (deprecated option; use unusedParam instead) 

-.sp 

-+ unusedImport unused import reference 

-.sp 

-+ unusedLabel unused label 

-.sp 

-+ unusedLocal unused local variable 

-.sp 

-+ unusedParam unused method parameter 

-.sp 

-+ unusedParamImplementing unused parameter for implementing method 

-.sp 

-+ unusedParamIncludeDoc unused parameter documented in a Javadoc comment tag 

-.sp 

-+ unusedParamOverriding unused parameter for overriding method 

-.sp 

-+ unusedPrivate unused private member declaration 

-.sp 

-- unusedThrown unused declared thrown exception 

-.sp 

-- unusedThrownIncludeDocComment unused declared thrown exception documented in a Javadoc comment tag 

-.sp 

-- unusedThrownExemptExceptionThrowable report unused declared thrown exception but exempt Exception and Throwable 

-.sp 

-- unusedThrownWhenOverriding unused declared thrown exception in overriding method 

-.sp 

-+ unusedTypeArgs unused type arguments for method and constructor 

-.sp 

-+ unusedTypeParameter unused type parameter 

-.sp 

-- uselessTypeCheck unnecessary cast/instanceof operation 

-.sp 

-+ varargsCast varargs argument need explicit cast 

-.sp 

-+/- warningToken unhandled or unused warning token in @SuppressWarnings 

-.in

-

-.IP \-nowarn 

-No warning (equivalent to \-warn:none) 

-.IP "\-err:..."

-Specify the set of enabled warnings that are converted to errors.

-e.g. \-err:unusedLocal,deprecation

-unusedLocal and deprecation warnings will be converted to errors. All other warnings are still reported as warnings. \-err:<warning tokens separated by ,> convert exactly the listed warnings to errors 

-.IP "\-err:+<warning tokens separated by ,>"

-convert additional warnings to errors 

-.IP "\-err:\-<warning tokens separated by ,>"

-remove specific warnings from being converted to errors 

-.IP \-deprecation 

-Equivalent to \-warn:+deprecation. 

-.IP "\-properties <file>"

-Set warnings/errors option based on the properties file contents. This option can be used with \-nowarn, \-err:.. or \-warn:.. options, but the last one on the command line sets the options to be used.

-

-The properties file contents can be generated by setting project specific settings on an existing java project and using the file in .settings/org.eclipse.jdt.core.prefs file as a properties file, or a simple text file that is defined entry/value pairs using the constants defined in the org.eclipse.jdt.core.JavaCore class. Of those constants declared in this class, all options starting with "org.eclipse.jdt.core.compiler." are interpreted by the batch compiler.

-

-...

-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning

-org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning

-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore

-...

-To ensure that a property file has the same effect when used in the IDE and for the batch compiler, use of the \-properties option will change the defaults for a few options:

-

-\-g default changed to all enabled 

-\-preserveAllLocals default changed to enabled 

-\-enableJavadoc default changed to enabled 

-error/warning forbidden default changed to error 

- 

-.IP "\-g[:none|:lines,vars,source]" 

-Set the debug attributes level

-\-g 

-All debug info (equivalent to \-g:lines,vars,source) 

- \-g:none 

-No debug info 

-\-g:[lines,vars,source] 

-Selective debug info 

-Not specifying this option is equivalent to setting \-g:lines,source.  

-.IP "\-preserveAllLocals" 

-Explicitly request the compiler to preserve all local variables (for debug purpose). If omitted, the compiler will remove unused locals. 

-.IP "\-parameters" 

-Explicitly request the compiler to preserve information about the formal parameters of a method (such as their names) to be accessed from reflection libraries, annotation processing, code weaving, and in the debugger. This option is supported from target level 1.8 and later.

-Annotation processing options (require a 1.6 VM or above and are used only if the compliance is 1.6) 

-.IP "\-Akey[=value]" 

-Annotation processors options that are passed to annotation processors. key is made of identifiers separated by dots 

-

-.IP "\-proc:[only|none] "

-If \-proc:only is specified, the annotation processors will run but no compilation will be performed. If \-proc:none is specified, annotation processors will not be discovered or run; compilation will proceed as if no annotation processors were found. By default the compiler must search the classpath for annotation processors, so specifying \-proc:none may speed compilation if annotation processing is not required. 

-.IP "\-processor <class1[,class2,...]> "

-Qualified class names of annotation processors to run. If specified, the normal processor discovery process will be skipped. 

-.IP "\-processorpath <dir 1>;<dir 2>;...;<dir P> "

-A list of directories or jar files which will be searched for annotation processors. Entries are separated by the platform path separator. If not specified, the classpath will be searched instead. 

-.IP "\-s <dir> "

-The directory where generated source files will be created. 

-.IP "\-XprintProcessorInfo "

-Print information about which annotations and which elements a processor is asked to process 

-.IP "\-XprintRounds "

-Print information about annotation processing rounds 

-.IP "\-classNames <class1[,class2,...]> "

-Qualified names of binary types that need to be processed 

-

-.IP "\-J<option>"

-Pass option to the virtual machine 

-.IP "\-X<option>"

-Specify non-standard option. \-Xemacs is not ignored. 

-.IP "\-X"

-Print non-standard options and exit 

-.IP "\-O"

-Optimize for execution time 

-

-.IP "@<file>"

-Read command-line arguments from file 

-.IP "\-maxProblems <n>"

-Max number of problems per compilation unit (100 by default) 

-.IP "\-log <filename>"

-Specify a log file in which all output from the compiler will be dumped. This is really useful if you want to debug the batch compiler or get a file which contains all errors and warnings from a batch build. If the extension is .xml, the generated log will be an xml file. 

-.IP "\-Xemacs"

-Use emacs style to present errors and warnings locations into the console and regular text logs. XML logs are unaffected by this option. With this option active, the message:

-2. WARNING in /workspace/X.java

-(at line 8)...

-is presented as:

-/workspace/X.java:8: warning: The method... 

-.IP "\-proceedOnError[:Fatal]"

-Keep compiling in spite of errors, dumping class files with problem methods or problem types. This is recommended only if you want to be able to run your application even if you have remaining errors.

-With ":Fatal", all optional errors are treated as fatal and this leads to code that will abort if an error is reached at runtime. Without ":Fatal", optional errors don't prevent the proper code generation and the produced .class files can be run without a problem. 

-.IP "\-verbose"

-Print accessed/processed compilation units in the console or the log file if specified. 

-.IP "\-referenceInfo"

-Compute reference info. This is useful only if connected to the builder. The reference infos are useless otherwise. 

-.IP "\-progress"

-Show progress (only in \-log mode). 

-.IP "\-time" 

-Display speed information. 

-.IP "\-noExit" 

-Do not call System.exit(n) at end of compilation (n=0 if no error). 

-.IP "\-repeat <n>"

-Repeat compilation process <n> times (perf analysis). 

-.IP "\-inlineJSR"

-Inline JSR bytecode (implicit if target >= 1.5). 

-.IP "\-enableJavadoc"

-Consider references inside Javadoc. The Javadoc options are effective only when this option is enabled. 

-.IP "\-missingNullDefault"

-When annotation based null analysis is enabled (using "nullAnnot", above), this option will raise a warning whenever there is no default annotation on a package or a type. 

-.IP "\-? \-help" 

-Display the help message. 

-.IP "\-v \-version" 

-Display the build number of the compiler. This is very useful to report a bug. 

-.IP "\-showversion" 

-Display the build number of the compiler and continue. This is very useful to report a bug. 

-

-.SH BUGS

-To report bugs see https://bugs.eclipse.org/bugs

-.SH AUTHOR

-For details on eclipse committers See http://www.eclipse.org/committers/

+.TH ecj 1 "10 August 2015"
+.LP
+.SH NAME
+ecj \- the eclipse JDT Batch Compiler
+.SH SYNOPSIS
+.B ecj [OPTION]... [SOURCEFILE]...
+.B ...
+.SH DESCRIPTION
+.B ecj is the batch compiler from Eclipse and is available as ecj.jar.
+Since 3.3, this jar also contains the support for jsr199 (Compiler API) 
+and the support for jsr269 (Annotation processing). In order to use the 
+annotations processing support, a 1.6 VM is required.
+
+.SH OPTIONS SUMMARY
+.sp
+Here is a summary of all the options, grouped by type.  Explanations are in the \fBOPTIONS\fR section.
+.sp
+.ul
+ClassPath Options
+.sp
+.B \-bootclasspath \-cp|\-classpath \-extdirs \-endorseddirs \-sourcepath \-d \-encoding
+.sp
+.ul
+Compliance Options
+.sp
+.B \-target \-1.3 \-1.4 \-1.5 \-1.6 \-1.7 \-1.8 \-source 
+.sp
+.ul
+Warning Options
+.sp
+.B \-?:warn \-help:warn \-warn:... \-nowarn \-err:... \-deprecation \-properties 
+.sp
+.ul 
+Debug Options
+.sp
+\fB\-g \-preserveAllLocals \-parameters
+.sp
+.ul 
+Annotation Processing Options
+.sp
+\-Akey[=\fIvalue\fB] \-proc:[only|none] \-processor \-processorpath \-s \-XprintProcessorInfo \-XprintRounds \-classNames\fR
+.sp
+.ul 
+Ignored Options (for compatibility with javac options)
+.sp
+.B \-J \-X \-O
+.sp
+.ul 
+Advanced Options
+.sp
+\fB@<file> \-maxProblems \-log \-Xemacs \-proceedOnError \-verbose \-referenceInfo \-progress \-time \-noExit \-repeat \-inlineJSR \-enableJavaDoc \-missingNullDefault 
+.sp
+.ul 
+Helping Options
+.sp
+\-? \-help \-v \-version \-showversion
+
+.SH OPTIONS
+.sp
+.ul
+ClassPath Options
+
+.B
+.IP "\-bootclasspath <dir 1>;<dir 2>;...;<dir P>"
+This is a list of directories or jar files used to bootstrap the class files used by the compiler. By default the libraries of the running VM are used. Entries are separated by the platform path separator.
+Each directory or file can specify access rules for types between '[' and ']'. 
+If no bootclasspath is specified, the compiler will infer it using the following system properties sun.boot.class.path, vm.boot.class.path or org.apache.harmony.boot.class.path in this order respectively
+
+.B
+.IP "\-cp|\-classpath <dir 1>;dir2;...<dir P>"
+This is a list of directories or jar files used to compile the source files. The default value is the value of the property "java.class.path". Entries are separated by the platform path separator.
+Each directory or file can specify access rules for types between '[' and ']' (e.g. [\-X] to forbid access to type X, [~X] to discourage access to type X, [+p/X:\-p/*] to forbid access to all types in package p but allow access to p/X).
+The compiler follows the Class-Path clauses of jar files' manifests recursively and appends each referenced jar file to the end of the classpath, provided it is not on the classpath yet.
+
+.B
+.IP "\-extdirs <dir 1>;<dir 2>;...;<dir P>"
+This is a list of directories used to specify the location of extension zip/jar files. Entries are separated by the platform path separator.
+
+.B
+.IP "\-endorseddirs <dir 1>;<dir 2>;...;<dir P>"
+This is a list of directories used to specify the location of endorsed zip/jar files. Entries are separated by the platform path separator.
+
+.B
+.IP "\-sourcepath <dir 1>;<dir 2>;...;<dir P>"
+This is a list of directories used to specify the source files. Entries are separated by the platform path separator.  Each directory can specify access rules for types between '[' and ']'.
+
+.B
+.IP "\-d <dir 1>|none"
+This is used to specify in which directory the generated .class files should be dumped. If it is omitted, no package directory structure is created.
+If you want to generate no .class file at all, use \-d none.
+
+.B
+.IP "\-encoding <encoding name>"
+Specify default encoding for all source files. Custom encoding can also be specified on a per file basis by suffixing each input source file/folder name with [<encoding name>]. For example X.java[UTF-8] would specify the UTF-8 encoding for the compilation unit X.java located in the current user directory. 
+If multiple default source file encodings are specified, the last one will be used.
+
+For example:
+.B ... \-encoding UTF-8 X.java[Cp1252] Y.java[UTF-16] Z.java ....
+.br
+All source files will be read using UTF-8 encoding (this includes Z.java). X.java will be read using Cp1252 encoding and Y.java will be read using UTF-16 encoding.
+.sp
+.B ... \-encoding UTF-8 -encoding UTF-16 ....
+.br
+All source files will be read using UTF-16 encoding. The \-encoding option for UTF-8 is ignored.
+.sp
+.B ... \-encoding Cp1252 /foo/bar/X.java[UTF-16] /foo/bar[UTF-8] ....
+.br
+All source files will be read using Cp1252 encoding. X.java is the only file inside the /foo/bar directory to be read using the encoding UTF-16. All other files in that directory will use UTF-8 encoding.
+
+.P
+.ul
+Compliance Options
+
+.B
+.IP "\-target 1.1 to 1.8 (or 8, 8.0, etc.)"
+This specifies the .class file target setting. The possible value are: 
+.br
+.B 1.1
+(major version: 45 minor: 3)
+.br
+.B 1.2
+(major version: 46 minor: 0)
+.br
+.B 1.3
+(major version: 47 minor: 0)
+.br
+.B 1.4
+(major version: 48 minor: 0)
+.br
+.B 1.5, 5 or 5.0
+(major version: 49 minor: 0)
+.br
+.B 1.6, 6 or 6.0
+(major version: 50 minor: 0)
+.br
+.B 1.7, 7 or 7.0
+(major version: 51 minor: 0)
+.br
+.B 1.8, 8 or 8.0
+(major version: 52 minor: 0)
+
+Defaults are: 
+.br
+1.1 in \-1.3 mode
+.br
+1.2 in \-1.4 mode
+.br
+1.5 in \-1.5 mode
+.br
+1.6 in \-1.6 mode
+.br
+1.7 in \-1.7 mode
+.br
+1.8 in \-1.8 mode
+clcd1.1 can be used to generate the StackMap attribute.
+
+.B
+.IP \-1.3
+Set compliance level to 1.3. Implicit \-source 1.3 \-target 1.1.
+
+.B
+.IP \-1.4
+Set compliance level to 1.4 (default). Implicit \-source 1.3 \-target 1.2.
+
+.B
+.IP \-1.5
+Set compliance level to 1.5. Implicit \-source 1.5 \-target 1.5.
+
+.B
+.IP \-1.6
+Set compliance level to 1.6. Implicit \-source 1.6 \-target 1.6.
+
+.B
+.IP \-1.7
+Set compliance level to 1.7. Implicit \-source 1.7 \-target 1.7.
+
+.B
+.IP \-1.8
+Set compliance level to 1.8. Implicit \-source 1.8 \-target 1.8.
+
+.B
+.IP "\-source 1.1 to 1.8 (or 8, 8.0, etc.)"
+This is used to specify the source level expected by the compiler.
+The possible value are: 
+.br
+.B 1.3
+.br
+.B 1.4
+.br
+.B 1.5, 5 or 5.0
+.br
+.B 1.6, 6 or 6.0
+.br
+.B 1.7, 7 or 7.0
+.br
+.B 1.8, 8 or 8.0
+
+Defaults are: 
+.br
+1.3 in \-1.3 mode
+.br
+1.3 in \-1.4 mode
+.br
+1.5 in \-1.5 mode
+.br
+1.6 in \-1.6 mode
+.br
+1.7 in \-1.7 mode
+.br
+1.8 in \-1.8 mode
+.br
+In 1.4, assert is treated as a keyword. In 1.5 and 1.6, enum and assert are treated as keywords.
+
+.P
+.ul
+Warning Options
+
+.B
+.IP "\-?:warn \-help:warn"
+Display advanced warning options
+
+.B
+.IP "\-warn:..."
+Specify the set of enabled warnings.
+.br
+.B \-warn:none\fR \t\t\t\t\t\tdisable all warnings
+.br
+.B \-warn:\fI<warning tokens separated by ,>\fR \tenable exactly the listed warnings
+.br
+.B \-warn:+\fI<warning tokens separated by ,>\fR \tenable additional warnings
+.br
+.B \-warn:\-\fI<warning tokens separated by ,>\fR \tdisable specific warnings
+
+Examples:
+
+.B\-warn:unusedLocal,deprecation
+.br
+enables only the given two warning options and disables all the other options
+.sp
+.B\-warn:\-unusedLocal,deprecation,+fallthrough
+.br
+disables unusedLocal and deprecation, enables fallthrough, and leaves the other warning options untouched
+.sp
+The first column below shows the default state for an option. A mark "+/-" indicates that an option covers several fine grained warning variants, some of which are enabled by default, others disabled. This means that specifying the given option with "+" will enable more warnings than the default, and specifying "-" disables some that are enabled by default. 
+.sp
+
++/-
+.B allDeadCode
+dead code including trivial if (DEBUG) check
+.sp
++/-
+.B allDeprecation
+deprecation even inside deprecated code
+.sp
+\ -\ 
+.B allJavadoc
+invalid or missing Javadoc
+.sp 
+\ -\ 
+.B allOver-ann
+all missing @Override annotations (superclass and superinterfaces)
+.sp 
+\ -\ 
+.B all-static-method
+all method can be declared as static warnings
+.sp 
+\ +\ 
+.B assertIdentifier
+occurrence of assert used as identifier
+.sp 
+\ -\ 
+.B boxing
+autoboxing conversion
+.sp 
+\ +\ 
+.B charConcat
+when a char array is used in a string concatenation without being converted explicitly to a string
+.sp 
+\ +\ 
+.B compareIdentical
+comparing identical expressions
+.sp 
+\ -\ 
+.B conditionAssign
+possible accidental boolean assignment
+.sp 
+\ +\ 
+.B constructorName
+method with constructor name
+.sp 
+\ +\ 
+.B deadCode
+dead code excluding trivial if (DEBUG) check
+.sp 
+\ -\ 
+.B dep\-ann
+missing @Deprecated annotation
+.sp 
++/-
+.B deprecation
+usage of deprecated type or member outside deprecated code
+.sp 
+\ +\ 
+.B discouraged
+use of types matching a discouraged access rule
+.sp 
+\ -\ 
+.B emptyBlock
+undocumented empty block
+.sp 
+\ +\ 
+.B enumIdentifier
+occurrence of enum used as identifier
+.sp 
+\ +\ 
+.B enumSwitch
+incomplete enum switch
+.sp 
+\ -\ 
+.B enumSwitchPedantic
+report missing enum switch cases even in the presence of a default case
+.sp 
+\ -\ 
+.B fallthrough
+possible fall-through case
+.sp 
+\ -\ 
+.B fieldHiding
+field hiding another variable
+.sp 
+\ +\ 
+.B finalBound
+type parameter with final bound
+.sp 
+\ +\ 
+.B finally
+finally block not completing normally
+.sp 
+\ +\ 
+.B forbidden
+use of types matching a forbidden access rule
+.sp 
+\ -\ 
+.B hashCode
+missing hashCode() method when overriding equals()
+.sp 
++/-
+.B hiding
+macro for fieldHiding, localHiding, maskedCatchBlock, and typeHiding
+.sp 
+\ -\ 
+.B includeAssertNull
+raise null warnings for variables that got tainted in an assert expression
+.sp 
+\ -\ 
+.B indirectStatic
+indirect reference to static member
+.sp 
+\ -\ 
+.B inheritNullAnnot
+consider null annotations as being inherited from an overridden method to any overriding methods
+.sp 
+\ +\ 
+.B intfAnnotation
+annotation type used as super interface
+.sp 
+\ +\ 
+.B intfNonInherited
+interface non-inherited method compatibility
+.sp 
+\ -\ 
+.B intfRedundant
+find redundant superinterfaces
+.sp 
+\ -\ 
+.B invalidJavadoc
+macro to toggle the 'malformed Javadoc comments' option and all its sub-options listed below
+.sp 
+\ -\ 
+.B invalidJavadocTag
+report invalid Javadoc tags in Javadoc comments.
+.sp 
+\ -\ 
+.B invalidJavadocTagDep
+report invalid deprecated references in Javadoc tag arguments
+.sp 
+\ -\ 
+.B invalidJavadocTagNotVisible
+report invalid non-visible references in Javadoc tag arguments
+.sp 
+\ -\ 
+.B invalidJavadocVisibility(\fI<visibility>\fB)
+specify visibility modifier ("public", "protected" or "private") for malformed Javadoc tag warnings. Usage example: invalidJavadocVisibility(public)
+.sp 
+\ -\ 
+.B javadoc
+invalid Javadoc
+.sp 
+\ -\ 
+.B localHiding
+local variable hiding another variable
+.sp 
+\ +\ 
+.B maskedCatchBlock
+hidden catch block
+.sp 
+\ -\ 
+.B missingJavadocTags
+macro to toggle the 'missing Javadoc tags' option and all its sub-options listed below
+.sp 
+\ -\ 
+.B missingJavadocTagsMethod
+report missing Javadoc tags for a method's type parameters
+.sp 
+\ -\ 
+.B missingJavadocTagsOverriding
+report missing Javadoc tags in overriding methods
+.sp 
+\ -\ 
+.B missingJavadocTagsVisibility(\fI<visibility>\fB)
+specify visibility modifier ("public", "protected" or "private") for missing Javadoc tags warnings. Usage example: missingJavadocTagsVisibility(public)
+.sp 
+\ -\ 
+.B missingJavadocComments
+macro to toggle the 'missing Javadoc comments' option and all its sub-options listed below
+.sp 
+\ -\ 
+.B missingJavadocCommentsOverriding
+report missing Javadoc comments in overriding methods
+.sp 
+\ -\ 
+.B missingJavadocCommentsVisibility(\fI<visibility>\fB)
+specify visibility modifier ("public", "protected" or "private") for missing Javadoc comments warnings. Usage example: missingJavadocCommentsVisibility(public)
+.sp 
+\ -\ 
+.B nls
+non-nls string literals (lacking of tags //$NON-NLS-<n>)
+.sp 
+\ +\ 
+.B noEffectAssign
+assignment with no effect
+.sp 
+\ +\ 
+.B nonnullNotRepeated
+nonnull parameter annotation from overridden method is not repeated in an overriding method. Is effective only with the nullAnnot option enabled.
+.sp 
++/-
+.B null
+potential missing or redundant null check
+.sp 
+\ -\ 
+.B nullAnnot
+enable annotation based null analysis.
+If desired, the annotation types to be interpreted by the compiler can be specified by appending (nullable|nonnull|nonnullbydefault), where each annotation type is specified using its fully qualified name.
+Usage example: nullAnnot(p.Nullable|p.NonNull|p.NonNullByDefault)
+.sp 
+Enabling this option enables all null-annotation related sub-options. These can be individually controlled using options listed below 
+.sp 
+\ -\ 
+.B nullAnnotConflict
+report conflicts between null annotation specified and nullness inferred. Is effective only with the nullAnnot option enabled.
+.sp 
+\ -\ 
+.B nullAnnotRedundant
+report redundant specification of null annotation. Is effective only with the nullAnnot option enabled.
+.sp 
+\ -\ 
+.B nullDereference
+missing null check
+.sp 
+\ -\ 
+.B nullUncheckedConversion
+report unchecked conversion from unannotated type to @NonNull type. Is effective only with the nullAnnot option enabled.
+.sp 
+\ -\ 
+.B over-ann
+missing @Override annotation (superclass only)
+.sp 
+\ -\ 
+.B paramAssign
+assignment to a parameter
+.sp 
+\ +\ 
+.B pkgDefaultMethod
+attempt to override package-default method
+.sp 
+\ +\ 
+.B raw
+usage a of raw type (instead of a parameterized type)
+.sp 
++/-
+.B resource
+(potentially) unsafe usage of resource of type Closeable
+.sp 
+\ -\ 
+.B semicolon
+unnecessary semicolon or empty statement
+.sp 
+\ +\ 
+.B serial
+missing serialVersionUID
+.sp 
+\ -\ 
+.B specialParamHiding
+constructor or setter parameter hiding another field
+.sp 
++/-
+.B static-access
+macro for indirectStatic and staticReceiver
+.sp 
+\ -\ 
+.B static-method
+an instance method that could be as a static method
+.sp 
+\ +\ 
+.B staticReceiver
+if a non static receiver is used to get a static field or call a static method
+.sp 
+\ -\ 
+.B super
+overriding a method without making a super invocation
+.sp 
+\ +\ 
+.B suppress
+enable @SuppressWarnings
+.sp 
+\ -\ 
+.B switchDefault
+switch statement lacking a default case
+.sp 
+\ -\ 
+.B syncOverride
+missing synchronized in synchronized method override
+.sp 
+\ -\ 
+.B syntacticAnalysis
+perform syntax-based null analysis for fields
+.sp 
+\ -\ 
+.B syntheticAccess
+when performing synthetic access for innerclass
+.sp 
+\ -\ 
+.B tasks
+enable support for tasks tags in source code
+.sp 
+\ +\ 
+.B typeHiding
+type parameter hiding another type
+.sp 
+\ +\ 
+.B unavoidableGenericProblems
+report even unavoidable type safety problems due to raw APIs
+.sp 
+\ +\ 
+.B unchecked
+unchecked type operation
+.sp 
+\ -\ 
+.B unnecessaryElse
+unnecessary else clause
+.sp 
+\ -\ 
+.B unqualifiedField
+unqualified reference to field
+.sp 
++/-
+.B unused
+macro for unusedImport, unusedLabel, unusedLocal, unusedPrivate, unusedThrown, unusedTypeArgs, and unusedTypeParameter
+.sp 
+\ -\ 
+.B unusedAllocation
+allocating an object that is not used
+.sp 
+\ -\ 
+.B unusedArgument
+unused method parameter (deprecated option; use unusedParam instead)
+.sp 
+\ +\ 
+.B unusedImport
+unused import reference
+.sp 
+\ +\ 
+.B unusedLabel
+unused label
+.sp 
+\ +\ 
+.B unusedLocal
+unused local variable
+.sp 
+\ +\ 
+.B unusedParam
+unused method parameter
+.sp 
+\ +\ 
+.B unusedParamImplementing
+unused parameter for implementing method
+.sp 
+\ +\ 
+.B unusedParamIncludeDoc
+unused parameter documented in a Javadoc comment tag
+.sp 
+\ +\ 
+.B unusedParamOverriding
+unused parameter for overriding method
+.sp 
+\ +\ 
+.B unusedPrivate
+unused private member declaration
+.sp 
+\ -\ 
+.B unusedThrown
+unused declared thrown exception
+.sp 
+\ -\ 
+.B unusedThrownIncludeDocComment
+unused declared thrown exception documented in a Javadoc comment tag
+.sp 
+\ -\ 
+.B unusedThrownExemptExceptionThrowable
+report unused declared thrown exception but exempt Exception and Throwable
+.sp 
+\ -\ 
+.B unusedThrownWhenOverriding
+unused declared thrown exception in overriding method
+.sp 
+\ +\ 
+.B unusedTypeArgs
+unused type arguments for method and constructor
+.sp 
+\ +\ 
+.B unusedTypeParameter
+unused type parameter
+.sp 
+\ -\ 
+.B uselessTypeCheck
+unnecessary cast/instanceof operation
+.sp 
+\ +\ 
+.B varargsCast
+varargs argument need explicit cast
+.sp 
++/-
+.B warningToken
+unhandled or unused warning token in @SuppressWarnings
+.in
+
+.B
+.IP "\-nowarn"
+No warning (equivalent to \-warn:none) 
+.B
+.IP "\-err:..."
+Specify the set of enabled warnings that are converted to errors.
+.br
+E.g.
+.br
+.B \-err:unusedLocal,deprecation
+.br
+unusedLocal and deprecation warnings will be converted to errors. All other warnings are still reported as warnings.
+
+.B \-err:\fI<warning tokens separated by ,>\fR \tconvert exactly the listed warnings to errors
+.br
+.B \-err:+\fI<warning tokens separated by ,>\fR \tconvert additional warnings to errors
+.br
+.B \-err:\-\fI<warning tokens separated by ,>\fR \tremove specific warnings from being converted to errors
+
+.B
+.IP \-deprecation 
+Equivalent to \-warn:+deprecation. 
+.B
+.IP "\-properties <file>"
+Set warnings/errors option based on the properties file contents. This option can be used with \-nowarn, \-err:.. or \-warn:.. options, but the last one on the command line sets the options to be used.
+
+The properties file contents can be generated by setting project specific settings on an existing java project and using the file in .settings/org.eclipse.jdt.core.prefs file as a properties file, or a simple text file that is defined entry/value pairs using the constants defined in the org.eclipse.jdt.core.JavaCore class. Of those constants declared in this class, all options starting with "org.eclipse.jdt.core.compiler." are interpreted by the batch compiler.
+
+ ...
+.br
+org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
+.br
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning
+.br
+org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
+.br
+ ...
+.sp
+To ensure that a property file has the same effect when used in the IDE and for the batch compiler, use of the \-properties option will change the defaults for a few options:
+
+.br
+.B \-g\fR \t\t\t\t\tdefault changed to all enabled
+.br
+.B \-preserveAllLocals\fR \t\tdefault changed to enabled
+.br
+.B \-enableJavadoc\fR \t\tdefault changed to enabled
+.br
+error/warning \fBforbidden\fR \tdefault changed to error
+
+.P
+.ul
+Debug Options
+
+.B
+.IP "\-g[:none|:lines,vars,source]"
+Set the debug attributes level
+.br
+.B \-g\fR \t\t\t\t\tAll debug info (equivalent to \-g:lines,vars,source) 
+.br
+.B \-g:none\fR \t\t\t\tNo debug info 
+.br
+.B \-g:[lines,vars,source]\fR \tSelective debug info 
+.br
+Not specifying this option is equivalent to setting \-g:lines,source.
+
+.B
+.IP "\-preserveAllLocals"
+Explicitly request the compiler to preserve all local variables (for debug purpose). If omitted, the compiler will remove unused locals. 
+.B
+.IP "\-parameters"
+Explicitly request the compiler to preserve information about the formal parameters of a method (such as their names) to be accessed from reflection libraries, annotation processing, code weaving, and in the debugger. This option is supported from target level 1.8 and later.
+Annotation processing options (require a 1.6 VM or above and are used only if the compliance is 1.6) 
+
+.P
+.ul
+Annotation Processing Options
+
+.B
+.IP "\-Akey[=value]"
+Annotation processors options that are passed to annotation processors. key is made of identifiers separated by dots 
+
+.B
+.IP "\-proc:[only|none]"
+If \-proc:only is specified, the annotation processors will run but no compilation will be performed. If \-proc:none is specified, annotation processors will not be discovered or run; compilation will proceed as if no annotation processors were found. By default the compiler must search the classpath for annotation processors, so specifying \-proc:none may speed compilation if annotation processing is not required. 
+.B
+.IP "\-processor <class1[,class2,...]>"
+Qualified class names of annotation processors to run. If specified, the normal processor discovery process will be skipped. 
+.B
+.IP "\-processorpath <dir 1>;<dir 2>;...;<dir P>"
+A list of directories or jar files which will be searched for annotation processors. Entries are separated by the platform path separator. If not specified, the classpath will be searched instead. 
+.B
+.IP "\-s <dir>"
+The directory where generated source files will be created. 
+.B
+.IP "\-XprintProcessorInfo"
+Print information about which annotations and which elements a processor is asked to process 
+.B
+.IP "\-XprintRounds"
+Print information about annotation processing rounds 
+.B
+.IP "\-classNames <class1[,class2,...]>"
+Qualified names of binary types that need to be processed 
+
+.P
+.ul
+Ignored Options (for compatibility with javac options)
+
+.B
+.IP "\-J<option>"
+Pass option to the virtual machine 
+.B
+.IP "\-X<option>"
+Specify non-standard option. \-Xemacs is not ignored. 
+.B
+.IP "\-X"
+Print non-standard options and exit 
+.B
+.IP "\-O"
+Optimize for execution time 
+
+.P
+.ul
+Advanced Options
+
+.B
+.IP "@<file>"
+Read command-line arguments from file 
+.B
+.IP "\-maxProblems <n>"
+Max number of problems per compilation unit (100 by default) 
+.B
+.IP "\-log <filename>"
+Specify a log file in which all output from the compiler will be dumped. This is really useful if you want to debug the batch compiler or get a file which contains all errors and warnings from a batch build. If the extension is .xml, the generated log will be an xml file. 
+.B
+.IP "\-genericsignature"
+Explicitly request the compiler to preserve information about generic signature of lambda expressions. 
+.B
+.IP "\-Xemacs"
+Use emacs style to present errors and warnings locations into the console and regular text logs. XML logs are unaffected by this option. With this option active, the message:
+.br
+\ \ \ \ 2. WARNING in /workspace/X.java
+.br
+\ \ \ \ (at line 8)...
+.br
+is presented as:
+.br
+\ \ \ \ /workspace/X.java:8: warning: The method... 
+.br
+
+.B
+.IP "\-proceedOnError[:Fatal]"
+Keep compiling in spite of errors, dumping class files with problem methods or problem types. This is recommended only if you want to be able to run your application even if you have remaining errors.
+With ":Fatal", all optional errors are treated as fatal and this leads to code that will abort if an error is reached at runtime. Without ":Fatal", optional errors don't prevent the proper code generation and the produced .class files can be run without a problem. 
+.B
+.IP "\-verbose"
+Print accessed/processed compilation units in the console or the log file if specified. 
+.B
+.IP "\-referenceInfo"
+Compute reference info. This is useful only if connected to the builder. The reference infos are useless otherwise. 
+.B
+.IP "\-progress"
+Show progress (only in \-log mode). 
+.B
+.IP "\-time"
+Display speed information. 
+.B
+.IP "\-noExit"
+Do not call System.exit(n) at end of compilation (n=0 if no error). 
+.B
+.IP "\-repeat <n>"
+Repeat compilation process <n> times (perf analysis). 
+.B
+.IP "\-inlineJSR"
+Inline JSR bytecode (implicit if target >= 1.5). 
+.B
+.IP "\-enableJavadoc"
+Consider references inside Javadoc. The Javadoc options are effective only when this option is enabled. 
+.B
+.IP "\-missingNullDefault"
+When annotation based null analysis is enabled (using "nullAnnot", above), this option will raise a warning whenever there is no default annotation on a package or a type. 
+.B
+.IP "\-annotationpath"
+When annotation based null analysis is enabled (using "nullAnnot", above), this option defines locations where to find external annotations to support annotation-based null analysis.
+The value of this options is a list of directories or zip files. Entries are separated by the platform path separator.
+The special name CLASSPATH will cause lookup of external annotations from the classpath and sourcepath. 
+
+.P
+.ul
+Helping Options
+
+.B
+.IP "\-? \-help"
+Display the help message. 
+.B
+.IP "\-v \-version"
+Display the build number of the compiler. This is very useful to report a bug. 
+.B
+.IP "\-showversion"
+Display the build number of the compiler and continue. This is very useful to report a bug. 
+
+.SH SEE ALSO
+<\fBhttp://help.eclipse.org/topic/org.eclipse.jdt.doc.user/tasks/task-using_batch_compiler.htm\fR>
+.SH BUGS
+To report bugs, use <\fBhttps://bugs.eclipse.org/bugs/enter_bug.cgi?product=JDT&component=Core\fR>
+.SH AUTHOR
+For details on Eclipse committers, see <\fBhttp://www.eclipse.org/committers/\fR>
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 d261661..d453768 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
@@ -1365,7 +1365,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 a6e0f1a..ca54ba7 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
@@ -1130,11 +1130,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();
@@ -1216,7 +1215,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));