Short-term hack to work around issue with duplicated interfaces.

See dartbug.com/31656

Change-Id: I017085953c5ac41d2cfd7368752918c6fcb51144
Reviewed-on: https://dart-review.googlesource.com/33884
Reviewed-by: Jens Johansen <[email protected]>
Commit-Queue: Peter von der Ahé <[email protected]>

Author: peter-ahe-google

pkg/analyzer/test/generated/compile_time_error_code_kernel_test.dart

@@ -3087,6 +3087,18 @@ class CompileTimeErrorCodeTest_Kernel extends CompileTimeErrorCodeTest_Driver {
     // Test passes, even though if fails in the superclass
     await super.test_yieldInNonGenerator_async();
   }
+
+  @override
+  @failingTest
+  test_implementsDisallowedClass_class_String_num() async {
+    await super.test_implementsDisallowedClass_class_String_num();
+  }
+
+  @override
+  @failingTest
+  test_implementsDisallowedClass_classTypeAlias_String_num() async {
+    await super.test_implementsDisallowedClass_classTypeAlias_String_num();
+  }
 }
 
 /// Tests marked with this annotation fail because of a Fasta problem.

pkg/front_end/lib/src/fasta/fasta_codes_generated.dart

@@ -95,6 +95,38 @@ Message _withArgumentsAccessError(String name) {
       message: """Access error: '$name'.""", arguments: {'name': name});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<Message Function(String name, DartType _type, DartType _type2)>
+    templateAmbiguousSupertypes = const Template<
+            Message Function(String name, DartType _type, DartType _type2)>(
+        messageTemplate:
+            r"""'#name' can't implement both '#type' and '#type2'""",
+        withArguments: _withArgumentsAmbiguousSupertypes);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name, DartType _type, DartType _type2)>
+    codeAmbiguousSupertypes =
+    const Code<Message Function(String name, DartType _type, DartType _type2)>(
+        "AmbiguousSupertypes", templateAmbiguousSupertypes,
+        severity: Severity.error);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsAmbiguousSupertypes(
+    String name, DartType _type, DartType _type2) {
+  NameSystem nameSystem = new NameSystem();
+  StringBuffer buffer = new StringBuffer();
+  new Printer(buffer, syntheticNames: nameSystem).writeNode(_type);
+  String type = '$buffer';
+
+  buffer = new StringBuffer();
+  new Printer(buffer, syntheticNames: nameSystem).writeNode(_type2);
+  String type2 = '$buffer';
+
+  return new Message(codeAmbiguousSupertypes,
+      message: """'$name' can't implement both '$type' and '$type2'""",
+      arguments: {'name': name, 'type': _type, 'type2': _type2});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeAnnotationOnEnumConstant = messageAnnotationOnEnumConstant;
 

pkg/front_end/lib/src/fasta/source/source_loader.dart

@@ -12,12 +12,21 @@ import 'package:front_end/src/fasta/type_inference/interface_resolver.dart'
     show InterfaceResolver;
 
 import 'package:kernel/ast.dart'
-    show Arguments, Expression, Library, LibraryDependency, Program;
+    show
+        Arguments,
+        Class,
+        Expression,
+        Library,
+        LibraryDependency,
+        Program,
+        Supertype;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
+import 'package:kernel/type_environment.dart' show TypeEnvironment;
+
 import '../../api_prototype/file_system.dart';
 
 import '../../base/instrumentation.dart'
@@ -46,6 +55,7 @@ import '../fasta_codes.dart'
         Message,
         SummaryTemplate,
         Template,
+        templateAmbiguousSupertypes,
         templateCyclicClassHierarchy,
         templateExtendingEnum,
         templateExtendingRestricted,
@@ -563,10 +573,37 @@ class SourceLoader<L> extends Loader<L> {
   }
 
   void computeHierarchy() {
-    hierarchy = new ClassHierarchy(computeFullProgram());
+    List<List> ambiguousTypesRecords = [];
+    hierarchy = new ClassHierarchy(computeFullProgram(),
+        onAmbiguousSupertypes: (Class cls, Supertype a, Supertype b) {
+      if (ambiguousTypesRecords != null) {
+        ambiguousTypesRecords.add([cls, a, b]);
+      }
+    });
+    for (List record in ambiguousTypesRecords) {
+      handleAmbiguousSupertypes(record[0], record[1], record[2]);
+    }
+    ambiguousTypesRecords = null;
     ticker.logMs("Computed class hierarchy");
   }
 
+  void handleAmbiguousSupertypes(Class cls, Supertype a, Supertype b) {
+    String name = cls.name;
+    TypeEnvironment env = new TypeEnvironment(coreTypes, hierarchy,
+        strongMode: target.strongMode);
+
+    if (cls.isSyntheticMixinImplementation) return;
+
+    if (env.isSubtypeOf(a.asInterfaceType, b.asInterfaceType)) return;
+    addProblem(
+        templateAmbiguousSupertypes.withArguments(
+            name, a.asInterfaceType, b.asInterfaceType),
+        cls.fileOffset,
+        cls.fileUri);
+  }
+
+  void ignoreAmbiguousSupertypes(Class cls, Supertype a, Supertype b) {}
+
   void computeCoreTypes(Program program) {
     coreTypes = new CoreTypes(program);
     ticker.logMs("Computed core types");
@@ -646,8 +683,9 @@ class SourceLoader<L> extends Loader<L> {
     // target those forwarding stubs.
     // TODO(paulberry): could we make this unnecessary by not clearing class
     // inference info?
-    typeInferenceEngine.classHierarchy =
-        hierarchy = new ClassHierarchy(computeFullProgram());
+    typeInferenceEngine.classHierarchy = hierarchy = new ClassHierarchy(
+        computeFullProgram(),
+        onAmbiguousSupertypes: ignoreAmbiguousSupertypes);
     ticker.logMs("Performed top level inference");
   }
 

pkg/front_end/messages.yaml

@@ -1796,6 +1796,7 @@ UndefinedMethod:
       C c;
       c.foo();
     }
+
 SourceOutlineSummary:
   template: |
     Built outlines for #count compilation units (#count2 bytes) in #string, that is,
@@ -1822,3 +1823,7 @@ CantInferTypeDueToCircularity:
   template: "Can't infer the type of '#string': circularity found during type inference."
   tip: "Specify the type explicitly."
   severity: ERROR
+
+AmbiguousSupertypes:
+  template: "'#name' can't implement both '#type' and '#type2'"
+  severity: ERROR

pkg/kernel/lib/class_hierarchy.dart

@@ -11,16 +11,25 @@ import 'type_algebra.dart';
 
 import 'src/incremental_class_hierarchy.dart' show IncrementalClassHierarchy;
 
+typedef HandleAmbiguousSupertypes = void Function(Class, Supertype, Supertype);
+
 /// Interface for answering various subclassing queries.
 /// TODO(scheglov) Several methods are not used, or used only in tests.
 /// Check if these methods are not useful and should be removed .
 abstract class ClassHierarchy {
-  factory ClassHierarchy(Program program) {
+  factory ClassHierarchy(Program program,
+      {HandleAmbiguousSupertypes onAmbiguousSupertypes}) {
     int numberOfClasses = 0;
     for (var library in program.libraries) {
       numberOfClasses += library.classes.length;
     }
-    return new ClosedWorldClassHierarchy._internal(program, numberOfClasses)
+    onAmbiguousSupertypes ??= (Class cls, Supertype a, Supertype b) {
+      if (!cls.isSyntheticMixinImplementation) {
+        throw "$cls can't implement both $a and $b";
+      }
+    };
+    return new ClosedWorldClassHierarchy._internal(
+        program, numberOfClasses, onAmbiguousSupertypes)
       .._initialize();
   }
 
@@ -271,6 +280,8 @@ abstract class ClassHierarchy {
 
 /// Implementation of [ClassHierarchy] for closed world.
 class ClosedWorldClassHierarchy implements ClassHierarchy {
+  final HandleAmbiguousSupertypes _onAmbiguousSupertypes;
+
   /// The [Program] that this class hierarchy represents.
   final Program _program;
 
@@ -281,7 +292,8 @@ class ClosedWorldClassHierarchy implements ClassHierarchy {
 
   final Map<Class, _ClassInfo> _infoFor = <Class, _ClassInfo>{};
 
-  ClosedWorldClassHierarchy._internal(this._program, int numberOfClasses)
+  ClosedWorldClassHierarchy._internal(
+      this._program, int numberOfClasses, this._onAmbiguousSupertypes)
       : classes = new List<Class>(numberOfClasses);
 
   @override
@@ -446,11 +458,11 @@ class ClosedWorldClassHierarchy implements ClassHierarchy {
         var superType1 = identical(info1, next)
             ? type1
             : Substitution.fromInterfaceType(type1).substituteType(
-                info1.genericSuperTypes[next.classNode].asInterfaceType);
+                info1.genericSuperTypes[next.classNode].first.asInterfaceType);
         var superType2 = identical(info2, next)
             ? type2
             : Substitution.fromInterfaceType(type2).substituteType(
-                info2.genericSuperTypes[next.classNode].asInterfaceType);
+                info2.genericSuperTypes[next.classNode].first.asInterfaceType);
         if (superType1 == superType2) {
           candidate = superType1;
           ++numCandidatesAtThisDepth;
@@ -466,7 +478,7 @@ class ClosedWorldClassHierarchy implements ClassHierarchy {
     _ClassInfo superInfo = _infoFor[superclass];
     if (!info.isSubtypeOf(superInfo)) return null;
     if (superclass.typeParameters.isEmpty) return superclass.asRawSupertype;
-    return info.genericSuperTypes[superclass];
+    return info.genericSuperTypes[superclass]?.first;
   }
 
   @override
@@ -624,7 +636,8 @@ class ClosedWorldClassHierarchy implements ClassHierarchy {
   @override
   ClassHierarchy applyChanges(Iterable<Class> classes) {
     if (classes.isEmpty) return this;
-    return new ClassHierarchy(_program);
+    return new ClassHierarchy(_program,
+        onAmbiguousSupertypes: _onAmbiguousSupertypes);
   }
 
   void _initialize() {
@@ -900,20 +913,30 @@ class ClosedWorldClassHierarchy implements ClassHierarchy {
         superInfo.ownsGenericSuperTypeMap = false;
       } else {
         // Copy over the super type entries.
-        subInfo.genericSuperTypes ??= <Class, Supertype>{};
-        subInfo.genericSuperTypes.addAll(superInfo.genericSuperTypes);
+        subInfo.genericSuperTypes ??= <Class, List<Supertype>>{};
+        superInfo.genericSuperTypes
+            ?.forEach((Class key, List<Supertype> types) {
+          for (Supertype type in types) {
+            subInfo.recordGenericSuperType(key, type, _onAmbiguousSupertypes);
+          }
+        });
       }
     } else {
       // Copy over all transitive generic super types, and substitute the
       // free variables with those provided in [supertype].
       Class superclass = supertype.classNode;
       var substitution = Substitution.fromPairs(
           superclass.typeParameters, supertype.typeArguments);
-      subInfo.genericSuperTypes ??= <Class, Supertype>{};
-      superInfo.genericSuperTypes?.forEach((Class key, Supertype type) {
-        subInfo.genericSuperTypes[key] = substitution.substituteSupertype(type);
+      subInfo.genericSuperTypes ??= <Class, List<Supertype>>{};
+      superInfo.genericSuperTypes?.forEach((Class key, List<Supertype> types) {
+        for (Supertype type in types) {
+          subInfo.recordGenericSuperType(key,
+              substitution.substituteSupertype(type), _onAmbiguousSupertypes);
+        }
       });
-      subInfo.genericSuperTypes[superclass] = supertype;
+
+      subInfo.recordGenericSuperType(
+          superclass, supertype, _onAmbiguousSupertypes);
     }
   }
 
@@ -1151,7 +1174,7 @@ class _ClassInfo {
   ///
   /// In this case, a single map object `{A: A<String>, Q: Q<int>}` may be
   /// shared by the classes `B` and `C`.
-  Map<Class, Supertype> genericSuperTypes;
+  Map<Class, List<Supertype>> genericSuperTypes;
 
   /// If true, this is the current "owner" of [genericSuperTypes], meaning
   /// we may add additional entries to the map or transfer ownership to another
@@ -1178,6 +1201,17 @@ class _ClassInfo {
   List<Member> interfaceSetters;
 
   _ClassInfo(this.classNode);
+
+  void recordGenericSuperType(Class cls, Supertype type,
+      HandleAmbiguousSupertypes onAmbiguousSupertypes) {
+    List<Supertype> existing = genericSuperTypes[cls];
+    if (existing == null) {
+      genericSuperTypes[cls] = <Supertype>[type];
+    } else if (type != existing.first) {
+      existing.add(type);
+      onAmbiguousSupertypes(classNode, existing.first, type);
+    }
+  }
 }
 
 /// An immutable set of classes, internally represented as an interval list.

tests/language_2/language_2_dart2js.status

@@ -1419,9 +1419,6 @@ redirecting_factory_default_values_test/02: MissingCompileTimeError
 redirecting_factory_long_test: RuntimeError
 redirecting_factory_reflection_test: RuntimeError
 regress_20394_test/01: MissingCompileTimeError
-regress_22976_test/01: RuntimeError
-regress_22976_test/02: Pass # Incorrectly pass, we are ignoring an error due to #31118
-regress_22976_test/none: Pass # Incorrectly pass, we are ignoring an error due to #31118
 regress_24283_test: RuntimeError
 regress_27617_test/1: Crash # Assertion failure: Unexpected constructor j:constructor(Foo._) in ConstructorDataImpl._getConstructorConstant
 regress_28217_test/01: MissingCompileTimeError
@@ -2012,9 +2009,6 @@ redirecting_factory_default_values_test/02: MissingCompileTimeError
 redirecting_factory_long_test: RuntimeError
 redirecting_factory_reflection_test: RuntimeError
 regress_20394_test/01: MissingCompileTimeError
-regress_22976_test/01: Pass # Incorrectly pass, we are ignoring an error due to #31118
-regress_22976_test/02: Pass # Incorrectly pass, we are ignoring an error due to #31118
-regress_22976_test/none: Pass # Incorrectly pass, we are ignoring an error due to #31118
 regress_24283_test: RuntimeError
 regress_27617_test/1: Crash # Assertion failure: Unexpected constructor j:constructor(Foo._) in ConstructorDataImpl._getConstructorConstant
 regress_28217_test/01: MissingCompileTimeError
@@ -2590,9 +2584,6 @@ regress_13462_0_test: CompileTimeError
 regress_13462_1_test: CompileTimeError
 regress_18535_test: CompileTimeError
 regress_20394_test/01: MissingCompileTimeError
-regress_22976_test/01: Pass # Incorrectly pass, we are ignoring an error due to #31118
-regress_22976_test/02: Pass # Incorrectly pass, we are ignoring an error due to #31118
-regress_22976_test/none: Pass # Incorrectly pass, we are ignoring an error due to #31118
 regress_23408_test: Crash # Assertion failure: Missing scope info for j:method(_loadLibraryWrapper).
 regress_24283_test: RuntimeError
 regress_27617_test/1: Crash # Assertion failure: Unexpected constructor j:constructor(Foo._) in ConstructorDataImpl._getConstructorConstant
@@ -3346,9 +3337,6 @@ regress_13462_1_test: CompileTimeError
 regress_18535_test: CompileTimeError
 regress_20394_test/01: MissingCompileTimeError
 regress_21795_test: RuntimeError
-regress_22976_test/01: Pass # Incorrectly pass, we are ignoring an error due to #31118
-regress_22976_test/02: Pass # Incorrectly pass, we are ignoring an error due to #31118
-regress_22976_test/none: Pass # Incorrectly pass, we are ignoring an error due to #31118
 regress_23408_test: Crash # NoSuchMethodError: The getter 'closureClassEntity' was called on null.
 regress_24283_test: RuntimeError, OK # Requires 64 bit numbers.
 regress_27617_test/1: Crash # Assertion failure: Unexpected constructor j:constructor(Foo._) in ConstructorDataImpl._getConstructorConstant

tests/language_2/language_2_dartdevc.status

@@ -546,7 +546,6 @@ redirecting_factory_default_values_test/02: MissingCompileTimeError
 redirecting_factory_default_values_test/03: MissingCompileTimeError
 redirecting_factory_infinite_steps_test/01: MissingCompileTimeError
 redirecting_factory_malbounded_test/01: MissingCompileTimeError
-regress_22976_test/01: CompileTimeError
 regress_23089_test: Crash
 regress_23408_test: CompileTimeError # Issue 31533
 regress_25550_test: CompileTimeError

tests/language_2/language_2_kernel.status

@@ -15,6 +15,9 @@ generic_no_such_method_dispatcher_test: RuntimeError # Issue 31424
 mock_writable_final_field_test: RuntimeError # Issue 31424
 no_such_method_subtype_test: RuntimeError # Issue 31424
 
+[ $fasta ]
+regress_22976_test/*: CompileTimeError # Issue 31935
+
 [ $compiler == dartk && $mode == debug && $runtime == vm && $strong ]
 bad_named_parameters_test/01: Crash # Issue(http://dartbug.com/31630)
 bad_named_parameters_test/02: Crash # Issue(http://dartbug.com/31630)
@@ -628,7 +631,6 @@ redirecting_factory_infinite_steps_test/01: MissingCompileTimeError
 redirecting_factory_long_test: RuntimeError # Fasta bug: Bad compilation of type arguments for redirecting factory.
 redirecting_factory_malbounded_test/01: MissingCompileTimeError
 regress_22443_test: CompileTimeError # KernelVM bug: Deferred loading kernel issue 28335.
-regress_22976_test/01: CompileTimeError # Issue 31402 (Variable declaration)
 regress_23089_test: Crash
 regress_23408_test: CompileTimeError # KernelVM bug: Deferred loading kernel issue 28335.
 regress_23408_test: RuntimeError
@@ -1496,7 +1498,6 @@ regress_13462_0_test: SkipByDesign
 regress_13462_1_test: SkipByDesign
 regress_18535_test: SkipByDesign
 regress_22443_test: CompileTimeError # KernelVM bug: Deferred loading kernel issue 28335.
-regress_22976_test/01: CompileTimeError # Issue 31402 (Variable declaration)
 regress_23089_test: Crash
 regress_23408_test: CompileTimeError # KernelVM bug: Deferred loading kernel issue 28335.
 regress_23408_test: RuntimeError