diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
index 971b03e..6dc6c34 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
@@ -81,7 +81,7 @@
 			"}\n";
 
 	static {
-//		TESTS_NAMES = new String[] { "test315_warn_options_a" };
+//		TESTS_NAMES = new String[] { "test330_warn_options" };
 //		TESTS_NUMBERS = new int[] { 306 };
 //		TESTS_RANGE = new int[] { 298, -1 };
 	}
@@ -1740,9 +1740,9 @@
         "      nls                  string literal lacking non-nls tag //$NON-NLS-<n>$\n" + 
         "      noEffectAssign     + assignment without effect\n" + 
         "      null                 potential missing or redundant null check\n" + 
-        "      nullAnnot(<annot. names separated by |>) + annotation based null analysis,\n" +
-        "                           nullable|nonnull|nonnullbydefault annotation types\n" +
-        "                           optionally specified using fully qualified names\n" +
+        "      nullAnnot(<annot. names separated by |>) + annotation based null analysis,\n" + 
+        "                           nullable|nonnull|nonnullbydefault annotation types\n" + 
+        "                           optionally specified using fully qualified names\n" + 
         "      nullDereference    + missing null check\n" + 
         "      over-ann             missing @Override annotation (superclass)\n" + 
         "      paramAssign          assignment to a parameter\n" + 
@@ -1758,12 +1758,14 @@
         "      super                overriding a method without making a super invocation\n" + 
         "      suppress           + enable @SuppressWarnings\n" + 
         "                           When used with -err:, it can also silent optional\n" + 
-        "                           errors and warnings\n" +
+        "                           errors and warnings\n" + 
         "      switchDefault      + switch statement lacking a default case\n" + 
         "      syncOverride         missing synchronized in synchr. method override\n" + 
         "      syntheticAccess      synthetic access for innerclass\n" + 
         "      tasks(<tags separated by |>) tasks identified by tags inside comments\n" + 
         "      typeHiding         + type parameter hiding another type\n" + 
+        "      tolerateVarargsCode + tolerate varargs code that was accepted by \n" + 
+        "							 earlier compiler versions in compliance<1.7\n" + 
         "      unavoidableGenericProblems + ignore unavoidable type safety problems\n" + 
         "                                   due to raw APIs\n" + 
         "      unchecked          + unchecked type operation\n" + 
@@ -1782,7 +1784,7 @@
         "      unusedTypeArgs     + unused type arguments for method and constructor\n" + 
         "      uselessTypeCheck     unnecessary cast/instanceof operation\n" + 
         "      varargsCast        + varargs argument need explicit cast\n" + 
-        "      warningToken       + unsupported or unnecessary @SuppressWarnings\n" +
+        "      warningToken       + unsupported or unnecessary @SuppressWarnings\n" + 
         "\n";
 	String expandedExpectedOutput =
 		MessageFormat.format(expectedOutput, new String[] {
@@ -1888,9 +1890,9 @@
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility\" value=\"public\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.localVariableHiding\" value=\"ignore\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName\" value=\"warning\"/>\n" + 
-			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDefaultCase\" value=\"ignore\"/>\n" +
-			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation\" value=\"ignore\"/>\n" +
-			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault\" value=\"disabled\"/>\n" +
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDefaultCase\" value=\"ignore\"/>\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation\" value=\"ignore\"/>\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault\" value=\"disabled\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod\" value=\"ignore\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocComments\" value=\"ignore\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding\" value=\"disabled\"/>\n" + 
@@ -1930,6 +1932,7 @@
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.suppressWarnings\" value=\"enabled\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation\" value=\"ignore\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.tasks\" value=\"warning\"/>\n" + 
+			"		<option key=\"org.eclipse.jdt.core.compiler.problem.tolerateEarlierCompiledVarargsCode\" value=\"disabled\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems\" value=\"enabled\"/>\n" + 
 			"		<option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\n" + 
@@ -13178,4 +13181,59 @@
 			"1 problem (1 warning)",
 			true);
 }
+
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=374605
+// -warn option :tolerateVarargsCode
+public void test330_warn_options() {
+	this.runConformTest(
+		new String[] {
+				"p/X.java",
+				"package p;\n" +
+				"import java.util.Arrays;\n" +
+				"public class X {\n" +
+				"    public static void test(int... a) {\n" +
+				" 		System.out.println(Arrays.toString(a));}\n" +
+				"    public static <T> void test(Object... a) {\n" +
+				"		 System.out.println(Arrays.toString(a));}\n" +
+				"    public static void main(String[] args) {\n" +
+				"            test(1);\n" +
+				"     }\n" +
+				"}\n"
+		},
+		"\"" + OUTPUT_DIR +  File.separator + "p" + File.separator + "X.java\""
+		+ " -sourcepath \"" + OUTPUT_DIR + "\""
+		+ " -1.5"
+		+ " -warn:+tolerateVarargsCode -proc:none -d \"" + OUTPUT_DIR + "\"",
+		"",
+		"",
+		true);
+	this.runNegativeTest(
+			new String[] {
+					"p/X.java",
+					"package p;\n" +
+					"import java.util.Arrays;\n" +
+					"public class X {\n" +
+					"    public static void test(int... a) {\n" +
+					" 		System.out.println(Arrays.toString(a));}\n" +
+					"    public static <T> void test(Object... a) {\n" +
+					"		 System.out.println(Arrays.toString(a));}\n" +
+					"    public static void main(String[] args) {\n" +
+					"            test(1);\n" +
+					"     }\n" +
+					"}\n"
+			},
+			"\"" + OUTPUT_DIR +  File.separator + "p" + File.separator + "X.java\""
+			+ " -sourcepath \"" + OUTPUT_DIR + "\""
+			+ " -1.7"
+			+ " -warn:+tolerateVarargsCode -proc:none -d \"" + OUTPUT_DIR + "\"",
+			"",
+			"----------\n" + 
+			"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/p/X.java (at line 9)\n" + 
+			"	test(1);\n" + 
+			"	^^^^\n" + 
+			"The method test(int[]) is ambiguous for the type X\n" + 
+			"----------\n" + 
+			"1 problem (1 error)",
+			true);
+}
 }
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/VarargsTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/VarargsTest.java
index 536723b..e4e27c0 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/VarargsTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/VarargsTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2005, 2011 IBM Corporation and others.
+ * Copyright (c) 2005, 2012 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
@@ -798,6 +798,51 @@
 			"----------\n"
 		);
 	}
+	
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=383780
+	public void test015_tolerate() throws Exception {
+		if (this.complianceLevel < ClassFileConstants.JDK1_5) return;
+		Map options = getCompilerOptions();
+		options.put(CompilerOptions.OPTION_TolerateVarargsCodeThatCompiled, CompilerOptions.ENABLED);
+		if (this.complianceLevel >= ClassFileConstants.JDK1_7) {
+		this.runNegativeTest(
+				new String[] {
+						"X.java",
+						"public class X {\n" +
+						"	public static void main(String[] s) {\n" +
+						"		Y.count(new int[0]);\n" + // for some reason this is not ambiguous
+						"	}\n" +
+						"}\n" +
+						"class Y {\n" +
+						"	public static void count(int[] array, int ... values) { System.out.print(1); }\n" +
+						"	public static void count(int[] array, int[] ... values) { System.out.print(2); }\n" +
+						"}\n",
+			},
+			"----------\n" + 
+			"1. ERROR in X.java (at line 3)\n" + 
+			"	Y.count(new int[0]);\n" + 
+			"	  ^^^^^\n" + 
+			"The method count(int[], int[]) is ambiguous for the type Y\n" + 
+			"----------\n",
+			null, true, options);
+		} else {
+			this.runConformTest(
+				new String[] {
+						"X.java",
+						"public class X {\n" +
+						"	public static void main(String[] s) {\n" +
+						"		Y.count(new int[0]);\n" + // for some reason this is not ambiguous
+						"	}\n" +
+						"}\n" +
+						"class Y {\n" +
+						"	public static void count(int[] array, int ... values) { System.out.print(1); }\n" +
+						"	public static void count(int[] array, int[] ... values) { System.out.print(2); }\n" +
+						"}\n",
+			},
+			"1", 
+			null, true, null, options, null);
+		}
+	}
 
 	public void test016() { // check behaviour of Scope.mostSpecificMethodBinding()
 		this.runNegativeTest( // but this call is ambiguous
@@ -1235,7 +1280,7 @@
 			},
 			"1");
 	}
-	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=102631
+ 	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=102631
 	public void test033() {
 		this.runNegativeTest(
 			new String[] {
@@ -1301,6 +1346,57 @@
 			"The method c(boolean, boolean, Object[]) is ambiguous for the type X\n" +
 			"----------\n"
 		);
+	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=383780
+	public void test033_tolerate() {
+		if (this.complianceLevel < ClassFileConstants.JDK1_5) return;
+		Map options = getCompilerOptions();
+		options.put(CompilerOptions.OPTION_TolerateVarargsCodeThatCompiled, CompilerOptions.ENABLED);
+		if (this.complianceLevel >= ClassFileConstants.JDK1_7) {
+		this.runNegativeTest(
+			new String[] {
+				"X.java",
+				"public class X {\n" +
+				"	void a(boolean b, Object... o) {System.out.print(1);}\n" +
+				"	void a(Object... o) {System.out.print(2);}\n" +
+				"	public static void main(String[] args) {\n" +
+				"		X x = new X();\n" +
+				"		x.a(true);\n" +
+				"		x.a(true, \"foobar\");\n" +
+				"		x.a(\"foo\", \"bar\");\n" +
+				"	}\n" +
+				"}\n",
+			},
+			"----------\n" + 
+			"1. ERROR in X.java (at line 6)\n" + 
+			"	x.a(true);\n" + 
+			"	  ^\n" + 
+			"The method a(boolean, Object[]) is ambiguous for the type X\n" + 
+			"----------\n" + 
+			"2. ERROR in X.java (at line 7)\n" + 
+			"	x.a(true, \"foobar\");\n" + 
+			"	  ^\n" + 
+			"The method a(boolean, Object[]) is ambiguous for the type X\n" + 
+			"----------\n",
+			null, true, options);
+		} else {
+			this.runConformTest(
+					new String[] {
+						"X.java",
+						"public class X {\n" +
+						"	void a(boolean b, Object... o) {System.out.print(1);}\n" +
+						"	void a(Object... o) {System.out.print(2);}\n" +
+						"	public static void main(String[] args) {\n" +
+						"		X x = new X();\n" +
+						"		x.a(true);\n" +
+						"		x.a(true, \"foobar\");\n" +
+						"		x.a(\"foo\", \"bar\");\n" +
+						"	}\n" +
+						"}\n",
+					},
+					"112",
+					null, true, null, options, null);
+		}
 	}
 	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=106106
 	public void test034() {
@@ -2818,6 +2914,98 @@
 			},
 			"Done");
 	}
+	
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=383780
+	public void test070_tolerate() throws Exception {
+		if (this.complianceLevel < ClassFileConstants.JDK1_5) return;
+		Map options = getCompilerOptions();
+		options.put(CompilerOptions.OPTION_TolerateVarargsCodeThatCompiled, CompilerOptions.ENABLED);
+		if (this.complianceLevel < ClassFileConstants.JDK1_7) {
+		this.runNegativeTest(
+			new String[] {
+				"X.java",
+				"public class X {\n" +
+				"        public static void foo(int ...i) {}\n" +
+				"        public static void foo(double...d) {}\n" +
+				"        public static void main(String[] args) {\n" +
+				"            foo(1, 2, 3);\n" +
+				"            System.out.println (\"Done\");\n" +
+				"        }\n" +
+				"}\n"
+			},
+			"----------\n" + 
+			"1. ERROR in X.java (at line 5)\n" + 
+			"	foo(1, 2, 3);\n" + 
+			"	^^^\n" + 
+			"The method foo(int[]) is ambiguous for the type X\n" + 
+			"----------\n", 
+			null, true, options);
+		} else {
+			this.runConformTest(
+					new String[] {
+						"X.java",
+						"public class X {\n" +
+						"        public static void foo(int ...i) {}\n" +
+						"        public static void foo(double...d) {}\n" +
+						"        public static void main(String[] args) {\n" +
+						"            foo(1, 2, 3);\n" +
+						"            System.out.println (\"Done\");\n" +
+						"        }\n" +
+						"}\n"
+					},
+					"Done", 
+					null, true, null, options, null);
+		}
+		
+	}
+	
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=383780
+	public void test070_tolerate2() throws Exception {
+		if (this.complianceLevel < ClassFileConstants.JDK1_5) return;
+		Map options = getCompilerOptions();
+		options.put(CompilerOptions.OPTION_TolerateVarargsCodeThatCompiled, CompilerOptions.ENABLED);
+		if (this.complianceLevel >= ClassFileConstants.JDK1_7) {
+		this.runNegativeTest(
+			new String[] {
+				"X.java",
+				"import java.util.Arrays;\n" +
+				"public class X {\n" +
+				"        public static void test(int... a) {\n" +
+				"			System.out.println(Arrays.toString(a));\n}\n" +
+				"        public static <T> void test(Object... a) {\n" +
+				"			System.out.println(Arrays.toString(a));\n}\n" +
+				"        public static void main(String[] args) {\n" +
+				"            test(1);\n" +
+				"        }\n" +
+				"}\n"
+			},
+			"----------\n" + 
+			"1. ERROR in X.java (at line 10)\n" + 
+			"	test(1);\n" + 
+			"	^^^^\n" + 
+			"The method test(int[]) is ambiguous for the type X\n" + 
+			"----------\n", 
+			null, true, options);
+		} else {
+			this.runConformTest(
+					new String[] {
+							"X.java",
+							"import java.util.Arrays;\n" +
+							"public class X {\n" +
+							"        public static void test(int... a) {\n" +
+							"			System.out.println(Arrays.toString(a));\n}\n" +
+							"        public static <T> void test(Object... a) {\n" +
+							"			System.out.println(Arrays.toString(a));\n}\n" +
+							"        public static void main(String[] args) {\n" +
+							"            test(1);\n" +
+							"        }\n" +
+							"}\n"
+					},
+					"[1]", 
+					null, true, null, options, null);
+		}
+		
+	}
 	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=346038
 	public void test070a() throws Exception {
 		if (this.complianceLevel < ClassFileConstants.JDK1_5) return;
@@ -2835,6 +3023,49 @@
 			},
 			"Done");
 	}
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=383780
+	public void test070a_tolerate() throws Exception {
+		if (this.complianceLevel < ClassFileConstants.JDK1_5) return;
+		Map options = getCompilerOptions();
+		options.put(CompilerOptions.OPTION_TolerateVarargsCodeThatCompiled, CompilerOptions.ENABLED);
+		if (this.complianceLevel < ClassFileConstants.JDK1_7) {
+		this.runNegativeTest(
+			new String[] {
+				"X.java",
+				"public class X {\n" +
+				"        public static <T> void foo(int ...i) {}\n" +
+				"        public static <T> void foo(double...d) {}\n" +
+				"        public static void main(String[] args) {\n" +
+				"            foo(1, 2, 3);\n" +
+				"            System.out.println (\"Done\");\n" +
+				"        }\n" +
+				"}\n"
+			},
+			"----------\n" + 
+			"1. ERROR in X.java (at line 5)\n" + 
+			"	foo(1, 2, 3);\n" + 
+			"	^^^\n" + 
+			"The method foo(int[]) is ambiguous for the type X\n" + 
+			"----------\n", 
+			null, true, options);
+		} else {
+			this.runConformTest(
+					new String[] {
+						"X.java",
+						"public class X {\n" +
+						"        public static <T> void foo(int ...i) {}\n" +
+						"        public static <T> void foo(double...d) {}\n" +
+						"        public static void main(String[] args) {\n" +
+						"            foo(1, 2, 3);\n" +
+						"            System.out.println (\"Done\");\n" +
+						"        }\n" +
+						"}\n"
+					},
+					"Done", 
+					null, true, null, options, null);
+		}
+		
+	}
 	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=346038
 	public void test070b() throws Exception {
 		if (this.complianceLevel < ClassFileConstants.JDK1_5) return;
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
index 8fb5ce1..764d624 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
@@ -3633,6 +3633,11 @@
 			} else if (token.equals("typeHiding")) { //$NON-NLS-1$
 				setSeverity(CompilerOptions.OPTION_ReportTypeParameterHiding, severity, isEnabling);
 				return;
+			} else if (token.equals("tolerateVarargsCode")) { //$NON-NLS-1$
+				this.options.put(
+						CompilerOptions.OPTION_TolerateVarargsCodeThatCompiled,
+						isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);
+				return;
 			}
 			break;
 		case 'u' :
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
index 07e7c55..0c576c1 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
@@ -346,6 +346,8 @@
 \      syntheticAccess      synthetic access for innerclass\n\
 \      tasks(<tags separated by |>) tasks identified by tags inside comments\n\
 \      typeHiding         + type parameter hiding another type\n\
+\      tolerateVarargsCode + tolerate varargs code that was accepted by \n\
+\							 earlier compiler versions in compliance<1.7\n\
 \      unavoidableGenericProblems + ignore unavoidable type safety problems\n\
 \                                   due to raw APIs\n\
 \      unchecked          + unchecked type operation\n\
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 1a2b75f..6d6d781 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
@@ -161,6 +161,8 @@
 	static final char[][] DEFAULT_NONNULL_ANNOTATION_NAME = CharOperation.splitOn('.', "org.eclipse.jdt.annotation.NonNull".toCharArray()); //$NON-NLS-1$
 	static final char[][] DEFAULT_NONNULLBYDEFAULT_ANNOTATION_NAME = CharOperation.splitOn('.', "org.eclipse.jdt.annotation.NonNullByDefault".toCharArray()); //$NON-NLS-1$
 	public static final String OPTION_ReportMissingNonNullByDefaultAnnotation = "org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation";  //$NON-NLS-1$
+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=383780
+	public static final String OPTION_TolerateVarargsCodeThatCompiled = "org.eclipse.jdt.core.compiler.problem.tolerateEarlierCompiledVarargsCode"; //$NON-NLS-1$
 	/**
 	 * Possible values for configurable options
 	 */
@@ -414,6 +416,8 @@
 	public boolean analyseResourceLeaks;
 	/** Should missing enum cases be reported even if a default case exists in the same switch? */
 	public boolean reportMissingEnumCaseDespiteDefault;
+	/** Should the varargs code that compiled with earlier compiler versions be tolerated by this compiler? */
+	public boolean tolerateVarargsCodeThatCompiledEarlier;
 
 	// keep in sync with warningTokenToIrritant and warningTokenFromIrritant
 	public final static String[] warningTokens = {
@@ -1096,6 +1100,7 @@
 		optionsMap.put(OPTION_NonNullAnnotationName, String.valueOf(CharOperation.concatWith(this.nonNullAnnotationName, '.')));
 		optionsMap.put(OPTION_NonNullByDefaultAnnotationName, String.valueOf(CharOperation.concatWith(this.nonNullByDefaultAnnotationName, '.')));
 		optionsMap.put(OPTION_ReportMissingNonNullByDefaultAnnotation, getSeverityString(MissingNonNullByDefaultAnnotation));
+		optionsMap.put(OPTION_TolerateVarargsCodeThatCompiled, this.tolerateVarargsCodeThatCompiledEarlier ? ENABLED : DISABLED);
 		return optionsMap;
 	}
 
@@ -1258,6 +1263,8 @@
 		this.analyseResourceLeaks = true;
 
 		this.reportMissingEnumCaseDespiteDefault = false;
+		
+		this.tolerateVarargsCodeThatCompiledEarlier = false;
 	}
 
 	public void set(Map optionsMap) {
@@ -1696,6 +1703,13 @@
 				this.storeAnnotations = false;
 			}
 		}
+		if ((optionValue = optionsMap.get(OPTION_TolerateVarargsCodeThatCompiled)) != null) {
+			if (ENABLED.equals(optionValue)) {
+				this.tolerateVarargsCodeThatCompiledEarlier = true;
+			} else if (DISABLED.equals(optionValue)) {
+				this.tolerateVarargsCodeThatCompiledEarlier = false;
+			}
+		}
 	}
 	public String toString() {
 		StringBuffer buf = new StringBuffer("CompilerOptions:"); //$NON-NLS-1$
@@ -1802,6 +1816,7 @@
 		buf.append("\n\t- resource is not closed: ").append(getSeverityString(UnclosedCloseable)); //$NON-NLS-1$
 		buf.append("\n\t- resource may not be closed: ").append(getSeverityString(PotentiallyUnclosedCloseable)); //$NON-NLS-1$
 		buf.append("\n\t- resource should be handled by try-with-resources: ").append(getSeverityString(ExplicitlyClosedAutoCloseable)); //$NON-NLS-1$
+		buf.append("\n\t- code that compiled with earlier compiler versions should be tolerated in this version too : ").append(this.tolerateVarargsCodeThatCompiledEarlier ? ENABLED : DISABLED); //$NON-NLS-1$
 		return buf.toString();
 	}
 	
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
index 25fee09..08b4662 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * Copyright (c) 2000, 2012 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
@@ -582,6 +582,9 @@
 		}
 
 		int compatibilityLevel;
+		CompilerOptions options = this.compilerOptions();
+		if (options.complianceLevel < ClassFileConstants.JDK1_7 && options.tolerateVarargsCodeThatCompiledEarlier)
+			tiebreakingVarargsMethods = false;
 		if ((compatibilityLevel = parameterCompatibilityLevel(method, arguments, tiebreakingVarargsMethods)) > NOT_COMPATIBLE) {
 			if (compatibilityLevel == VARARGS_COMPATIBLE) {
 				TypeBinding varargsElementType = method.parameters[method.parameters.length - 1].leafComponentType();
@@ -3029,8 +3032,14 @@
 					if (i == oneParamsLength - 1 && one.isVarargs() && two.isVarargs()) {
 						TypeBinding oType = ((ArrayBinding) oneParam).elementsType();
 						TypeBinding eType = ((ArrayBinding) twoParam).elementsType();
-						if (oType == eType || oType.isCompatibleWith(eType))
-							return true; // special case to choose between 2 varargs methods when the last arg is Object[]
+						CompilerOptions options = this.compilerOptions();
+						if (options.complianceLevel < ClassFileConstants.JDK1_7 && options.tolerateVarargsCodeThatCompiledEarlier) {
+							if (oneParam == eType || oneParam.isCompatibleWith(eType))
+								return true; // special case to choose between 2 varargs methods when the last arg is Object[]
+						} else {
+							if (oType == eType || oType.isCompatibleWith(eType))
+								return true; // special case to choose between 2 varargs methods when the last arg is Object[]
+						}
 					}
 					return false;
 				}
@@ -4092,7 +4101,8 @@
 		// only called if env.options.sourceLevel >= ClassFileConstants.JDK1_5
 		if (arg.isCompatibleWith(param))
 			return COMPATIBLE;
-		if (tieBreakingVarargsMethods) {
+		CompilerOptions options = this.compilerOptions();
+		if (tieBreakingVarargsMethods && (options.complianceLevel >= ClassFileConstants.JDK1_7 || !options.tolerateVarargsCodeThatCompiledEarlier)) {
 			/* 15.12.2.5 Choosing the Most Specific Method, ... One variable arity member method named m is more specific than
 			   another variable arity member method of the same name if either ... Only subtypes relationship should be used.
 			   Actually this is true even for fixed arity methods, but in practice is not an issue since we run the algorithm