From dc5c191afcc40e1e20534394a127c9088f7c32cb Mon Sep 17 00:00:00 2001 From: anna Date: Fri, 6 Apr 2012 11:53:22 +0200 Subject: [PATCH] ambiguous method calls: conflict resolver, tests (IDEA-67919; IDEA-67863; IDEA-67920; IDEA-67831; IDEA-67833; IDEA-67674; IDEA-67587; IDEA-57646; IDEA-57407; IDEA-57279; IDEA-57296; IDEA-57297; IDEA-57316; IDEA-57331) --- .../JavaMethodsConflictResolver.java | 58 +++++++++++++-- .../ambiguous/pck/AmbiguousMethodCall.java | 21 ++++++ .../pck/AmbiguousMethodCall.java | 21 ++++++ .../pck/AmbiguousMethodCall.java | 16 +++++ .../pck/AmbiguousMethodCall.java | 31 ++++++++ .../pck/AmbiguousMethodCall.java | 28 ++++++++ .../pck/AmbiguousMethodCall.java | 43 +++++++++++ .../pck/AmbiguousMethodCall.java | 15 ++++ .../pck/AmbiguousMethodCall.java | 15 ++++ .../pck/AmbiguousMethodCall.java | 11 +++ .../pck/AmbiguousMethodCall.java | 21 ++++++ .../pck/AmbiguousMethodCall.java | 16 +++++ .../pck/AmbiguousMethodCall.java | 17 +++++ .../pck/AmbiguousMethodCall.java | 24 +++++++ .../pck/AmbiguousMethodCall.java | 9 +++ .../daemon/AdvHighlightingJdk7Test.java | 72 +++++++++++++++++++ 16 files changed, 414 insertions(+), 4 deletions(-) create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguous/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousArrayInSubst/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance1/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultiIntInheritance/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends1/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends2/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends3/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamExtends/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb1/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs/pck/AmbiguousMethodCall.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs1/pck/AmbiguousMethodCall.java diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java index 848700fea850..037c6f1b8a60 100644 --- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java +++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java @@ -16,6 +16,8 @@ package com.intellij.psi.scope.conflictResolvers; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.projectRoots.JavaSdkVersion; +import com.intellij.openapi.projectRoots.JavaVersionService; import com.intellij.openapi.util.Comparing; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.*; @@ -27,6 +29,7 @@ import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.*; import gnu.trove.THashSet; import gnu.trove.TIntArrayList; +import org.jetbrains.annotations.Nullable; import java.util.HashMap; import java.util.Iterator; @@ -412,8 +415,14 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{ PsiType type1 = classSubstitutor1.substitute(methodSubstitutor1.substitute(types1[i])); PsiType type2 = classSubstitutor2.substitute(methodSubstitutor2.substitute(types2[i])); - final Specifics specifics = type1 == null || type2 == null ? null : checkSubtyping(type1, type2, method1, method2); - if (specifics == null) continue; + Specifics specifics = type1 == null || type2 == null ? null : checkSubtyping(type1, type2, method1, method2); + if (specifics == null) { + if (Comparing.equal(type1, type2)) { + specifics = checkSubstitutorSpecific(method1, method2, classSubstitutor1, classSubstitutor2, types1[i], types2[i]); + } + if (specifics == null) continue; + } + switch (specifics) { case FIRST: if (isMoreSpecific == Specifics.SECOND) return Specifics.NEITHER; @@ -447,14 +456,55 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{ } } if (isMoreSpecific == null) { - if (typeParameters1.length < typeParameters2.length) return Specifics.FIRST; - if (typeParameters1.length > typeParameters2.length) return Specifics.SECOND; + if (!JavaVersionService.getInstance().isAtLeast(myArgumentsList, JavaSdkVersion.JDK_1_7) || + !MethodSignatureUtil.areParametersErasureEqual(method1, method2)) { + if (typeParameters1.length < typeParameters2.length) return Specifics.FIRST; + if (typeParameters1.length > typeParameters2.length) return Specifics.SECOND; + } return Specifics.NEITHER; } return isMoreSpecific; } + @Nullable + private static Specifics checkSubstitutorSpecific(PsiMethod method1, + PsiMethod method2, + PsiSubstitutor classSubstitutor1, + PsiSubstitutor classSubstitutor2, + PsiType type1, + PsiType type2) { + final Map map1 = classSubstitutor1.getSubstitutionMap(); + final Map map2 = classSubstitutor2.getSubstitutionMap(); + + if (map1.size() == 1 && map2.size() == 1) { + final PsiType t1 = map1.values().iterator().next(); + final PsiType t2 = map2.values().iterator().next(); + int d1 = t1 != null ? t1.getArrayDimensions() : 0; + int d2 = t2 != null ? t2.getArrayDimensions() : 0; + if (d1 > d2) { + return Specifics.SECOND; + } + else if (d2 > d1) { + return Specifics.FIRST; + } + else { + final PsiTypeParameter p1 = map1.keySet().iterator().next(); + final PsiTypeParameter p2 = map2.keySet().iterator().next(); + Specifics specifics = checkSubtyping(TypeConversionUtil.erasure(PsiSubstitutor.EMPTY.substitute(p1)), + TypeConversionUtil.erasure(PsiSubstitutor.EMPTY.substitute(p2)), method1, method2); + if (specifics != null) { + return specifics; + } else { + final PsiType ctype1 = classSubstitutor1.substitute(type1); + final PsiType ctype2 = classSubstitutor2.substitute(type2); + return checkSubtyping(ctype1, ctype2, method1, method2); + } + } + } + return null; + } + private PsiSubstitutor calculateMethodSubstitutor(final PsiTypeParameter[] typeParameters, final PsiType[] types1, final PsiType[] types2, diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguous/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguous/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..2adaecd3b4af --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguous/pck/AmbiguousMethodCall.java @@ -0,0 +1,21 @@ +package pck; + +import java.util.List; + +import static pck.C.foo; +import static pck.D.foo; + +class C { + static void foo(List> x) { } +} + +class D { + static String foo(List> x) { return null; } +} + +public class Main { + public static void main(String[] args){ + List> x = null; + foo(x).toLowerCase(); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousArrayInSubst/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousArrayInSubst/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..da83342fde99 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousArrayInSubst/pck/AmbiguousMethodCall.java @@ -0,0 +1,21 @@ +package pck; + +import java.util.List; + +import static pck.C.foo; +import static pck.D.foo; + +class C { + static void foo(List x) { } +} + +class D { + static String foo(List x) { return null; } +} + +public class Main { + public static void main(String[] args){ + List x = null; + foo(x).toLowerCase(); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..580a30a72403 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance/pck/AmbiguousMethodCall.java @@ -0,0 +1,16 @@ +package pck; + +interface A +{ + T foo(); +} + +interface B extends A { } + +class C & B> +{ + void foo(T x) + { + Object[] foo = x.foo(); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance1/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance1/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..66d939feb5e2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousInheritance1/pck/AmbiguousMethodCall.java @@ -0,0 +1,31 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package pck; + +interface A +{ + T foo(); +} + +interface B extends A { } + +class C & B> +{ + void bar(T x) + { + x.foo(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultiIntInheritance/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultiIntInheritance/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..9f4ff3a8f1ea --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultiIntInheritance/pck/AmbiguousMethodCall.java @@ -0,0 +1,28 @@ +package pck; + +interface IA { + T a(); +} + +interface IB { + String a(); +} + +abstract class C implements IA, IB { + + { + a(); + } +} + + +interface IAO { + Object a(); +} + +abstract class CO implements IAO, IB { + + { + a(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..b23579e04efe --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends/pck/AmbiguousMethodCall.java @@ -0,0 +1,43 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package pck; + +interface IA { + T a(); +} + +interface IB { + String a(); +} + +abstract class C implements IA, IB { + + { + a(); + } +} + + +interface IAO { + Object a(); +} + +abstract class CO implements IAO, IB { + + { + a(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends1/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends1/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..92c2135a7247 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends1/pck/AmbiguousMethodCall.java @@ -0,0 +1,15 @@ +package pck; + +class A {} + +interface IA{ + void foo(A x); +} +interface IB{ + void foo(A x); +} +class C { + void bar(T x, A y){ + x.foo(y); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends2/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends2/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..ed65deaea70d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends2/pck/AmbiguousMethodCall.java @@ -0,0 +1,15 @@ +package pck; + +class A {} + +interface IA{ + void foo(A> x); +} +interface IB{ + void foo(A> x); +} +class C { + void bar(T x, A> y){ + x.foo(y); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends3/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends3/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..d9b729b13874 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMultipleTypeParamExtends3/pck/AmbiguousMethodCall.java @@ -0,0 +1,11 @@ +package pck; + +class B {} +class A extends B { + void foo(A> b){ + bar(b); + } + + void bar(B> a){} + void bar(A> a){} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamExtends/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamExtends/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..86896939138e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamExtends/pck/AmbiguousMethodCall.java @@ -0,0 +1,21 @@ +package pck; + +import java.util.List; + +import static pck.C.foo; +import static pck.D.foo; + +class C { + static void foo(List x) { } +} + +class D { + static > String foo(List x) { return null; } +} + +public class Main { + public static void main(String[] args){ + List> x = null; + foo(x).toCharArray(); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..db291ad03994 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb/pck/AmbiguousMethodCall.java @@ -0,0 +1,16 @@ +package pck; +import static pck.C.foo; +import static pck.D.foo; + +public class C { + public static void foo(){} +} +class D { + public static void foo(){} +} + +class B { + { + foo(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb1/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb1/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..d030dd376ccb --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousTypeParamNmb1/pck/AmbiguousMethodCall.java @@ -0,0 +1,17 @@ +package pck; +import static pck.D.foo; +import static pck.C.foo; + +public class C { + public static void foo(Comparable x){} +} + +class D { + public static void foo(Comparable x){} +} + +class B{ + public static void bar(Comparable x){ + foo(x); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..3ced31214dcf --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs/pck/AmbiguousMethodCall.java @@ -0,0 +1,24 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package pck; +abstract class A { + abstract void foo(Object... x); + abstract void foo(int... x); + + { + foo(1); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs1/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs1/pck/AmbiguousMethodCall.java new file mode 100644 index 000000000000..b12298e4e403 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousVarargs1/pck/AmbiguousMethodCall.java @@ -0,0 +1,9 @@ +package pck; + +abstract class A { + abstract void foo(T... y); + abstract void foo(T[]... y); + void bar(){ + foo(); + } +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java index 4bd5bfaf58d8..ae55eef24b47 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java @@ -17,6 +17,9 @@ package com.intellij.codeInsight.daemon; import com.intellij.codeInspection.LocalInspectionTool; import com.intellij.codeInspection.defUse.DefUseInspection; +import com.intellij.openapi.projectRoots.JavaSdkVersion; +import com.intellij.openapi.projectRoots.JavaVersionService; +import com.intellij.openapi.projectRoots.JavaVersionServiceImpl; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.impl.JavaSdkImpl; import com.intellij.openapi.roots.LanguageLevelProjectExtension; @@ -60,4 +63,73 @@ public class AdvHighlightingJdk7Test extends DaemonAnalyzerTestCase { public void testStaticAndSingleImportConflict() throws Exception { doTest(BASE_PATH + "staticImportConflict/UsageMixed.java", BASE_PATH + "/staticImportConflict", false, false); } + + //ambiguous method calls + private void doTestAmbiguous() throws Exception { + final String name = getTestName(true); + final JavaVersionServiceImpl versionService = (JavaVersionServiceImpl)JavaVersionService.getInstance(); + try { + versionService.setTestVersion(JavaSdkVersion.JDK_1_7); + doTest(BASE_PATH + name + "/pck/AmbiguousMethodCall.java", BASE_PATH + "/" + name, false, false); + } + finally { + versionService.setTestVersion(null); + } + } + + public void testAmbiguous() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousArrayInSubst() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousTypeParamExtends() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousTypeParamNmb() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousTypeParamNmb1() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousInheritance() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousInheritance1() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousVarargs() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousVarargs1() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousMultiIntInheritance() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousMultipleTypeParamExtends() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousMultipleTypeParamExtends1() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousMultipleTypeParamExtends2() throws Exception { + doTestAmbiguous(); + } + + public void testAmbiguousMultipleTypeParamExtends3() throws Exception { + doTestAmbiguous(); + } }