Handle equivalence for generic mixins.

tests/compiler/dart2js/serialization/test_helper.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.serialization_test_helper;
 
 import 'dart:collection';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/constants/values.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/kernel/elements.dart';
 import 'package:compiler/src/kernel/world_builder.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
+import 'package:compiler/src/util/util.dart';
 import 'package:expect/expect.dart';
 import 'test_data.dart';
 
 Check currentCheck;
 
 class Check {
   final Check parent;
   final Object object1;
   final Object object2;
   final String property;
@@ skipping 600 matching lines @@
   } else if (index == count) {
     return [segmentNumber(index - 1)];
   } else {
     return [segmentNumber(index - 1), segmentNumber(index)];
   }
 }
 
 class KernelEquivalence {
   final WorldDeconstructionForTesting testing;
 
+  /// Set of mixin applications assumed to be equivalent.
+  ///
+  /// We need co-inductive reasoning because mixin applications are compared
+  /// structurally and therefore, in the case of generic mixin applications,
+  /// meet themselves through the equivalence check of their type variables.
+  Set<Pair<ClassEntity, ClassEntity>> assumedMixinApplications =
+      new Set<Pair<ClassEntity, ClassEntity>>();
+
   KernelEquivalence(KernelWorldBuilder builder)
       : testing = new WorldDeconstructionForTesting(builder);
 
   TestStrategy get defaultStrategy => new TestStrategy(
       elementEquivalence: entityEquivalence, typeEquivalence: typeEquivalence);
 
   bool entityEquivalence(Element a, Entity b, {TestStrategy strategy}) {
     if (identical(a, b)) return true;
     if (a == null || b == null) return false;
     strategy ??= defaultStrategy;
@@ skipping 27 matching lines @@
             InterfaceType mixinType = testing.getMixinTypeForClass(bClass);
             if (mixinType == null) break;
             bMixinTypes.add(mixinType);
             bClass = testing.getSuperclassForClass(bClass);
           }
           if (aMixinTypes.isNotEmpty || aMixinTypes.isNotEmpty) {
             if (aClass.isNamedMixinApplication &&
                 !strategy.test(a, b, 'name', a.name, b.name)) {
               return false;
             }
-            return strategy.testTypeLists(
-                a, b, 'mixinTypes', aMixinTypes, bMixinTypes);
+            Pair<ClassEntity, ClassEntity> pair =
+                new Pair<ClassEntity, ClassEntity>(aClass, bClass);
+            if (assumedMixinApplications.contains(pair)) {
+              return true;
+            } else {
+              assumedMixinApplications.add(pair);
+              bool result = strategy.testTypeLists(
+                  a, b, 'mixinTypes', aMixinTypes, bMixinTypes);
+              assumedMixinApplications.remove(pair);
+              return result;
+            }
           }
           return strategy.test(a, b, 'name', a.name, b.name) &&
               strategy.testElements(
                   a, b, 'library', a.library, testing.getLibraryForClass(b));
         }
         return false;
       case ElementKind.LIBRARY:
         if (b is KLibrary) {
           LibraryElement libraryA = a;
           return libraryA.canonicalUri == testing.getLibraryUri(b);
@@ skipping 105 matching lines @@
               strategy.testTypeLists(a, b, 'namedParameterTypes',
                   aType.namedParameterTypes, b.namedParameterTypes);
         }
         return false;
       default:
         throw new UnsupportedError('Unsupported equivalence: '
             '$a (${a.runtimeType}) vs $b (${b.runtimeType})');
     }
   }
 }