Handle forwarding constructors to unnamed mixin applications

tests/compiler/dart2js/kernel/compile_from_dill_test_helper.dart

 // Copyright (c) 2017, 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.
 
 // Helper to test compilation equivalence between source and .dill based
 // compilation.
 library dart2js.kernel.compile_from_dill_test_helper;
 
 import 'dart:async';
 
 import 'package:compiler/compiler_new.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/kernel/element_map.dart';
 import 'package:compiler/src/kernel/kernel_backend_strategy.dart';
 import 'package:compiler/src/kernel/kernel_strategy.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
+import 'package:compiler/src/resolution/class_hierarchy.dart';
 import 'package:compiler/src/resolution/enum_creator.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/world.dart';
 import 'package:expect/expect.dart';
 import '../memory_compiler.dart';
 import '../equivalence/check_functions.dart';
 import '../equivalence/check_helpers.dart';
 import '../serialization/helper.dart';
 import 'test_helpers.dart';
 
@@ skipping 41 matching lines @@
 }
 
 class Generic<T> {
   method(o) => o is T;
 }
 
 var toplevel;
 
 typedef Typedef();
 
+class Mixin1 {
+  var field1;
+}
+
+class Mixin2 {
+  var field2;
+}
+
+class MixinSub1 extends Object with Mixin1 {
+}
+
+class MixinSub2 extends Object with Mixin1, Mixin2 {
+}
+
 main() {
   foo();
   bar(true);
   [];
   <int>[];
   {};
   new Object();
   new Class.named('');
   new SubClass().method();
   Class.staticField;
@@ skipping 42 matching lines @@
   x = new Generic<int>().method(x);
   x = testAsGeneric(x);
   x = testAsFunction(x);
   print(x);
   var f = (x) {
     return 400 + x;
   };
   x = f(x);
   x = Object;
   x = Typedef;
+  new MixinSub2();
+  new MixinSub1();
   return x;
 }
 typedef NoArg();
 @NoInline()
 testIs(o) => o is Generic<int> || o is NoArg;
 @NoInline()
 testAsGeneric(o) => o as Generic<int>;
 @NoInline()
 testAsFunction(o) => o as NoArg;
 '''
@@ skipping 113 matching lines @@
     Uri entryPoint, Map<String, String> memorySourceFiles,
     {bool skipWarnings: false,
     bool skipErrors: false,
     bool verbose: false,
     List<String> options: const <String>[],
     bool expectAstEquivalence: false,
     bool expectIdenticalOutput: true}) async {
   enableDebugMode();
   EnumCreator.matchKernelRepresentationForTesting = true;
   Elements.usePatchedDart2jsSdkSorting = true;
+  useOptimizedMixins = true;
 
   entryPoint =
       await createTemp(entryPoint, memorySourceFiles, printSteps: true);
 
   print('---- compile from ast ----------------------------------------------');
   DiagnosticCollector collector = new DiagnosticCollector();
   OutputCollector collector1 = new OutputCollector();
   Compiler compiler1 = compilerFor(
       entryPoint: entryPoint,
       diagnosticHandler: collector,
@@ skipping 39 matching lines @@
       if (output1.text == output2.text) return;
       List<String> lines1 = output1.text.split('\n');
       List<String> lines2 = output2.text.split('\n');
       int prefix = 0;
       while (prefix < lines1.length && prefix < lines2.length) {
         if (lines1[prefix] != lines2[prefix]) {
           break;
         }
         prefix++;
       }
+      if (prefix > 0) prefix--;
       int suffix1 = lines1.length - 1;
       int suffix2 = lines2.length - 1;
       while (suffix1 >= 0 && suffix2 >= 0) {
         if (lines1[suffix1] != lines2[suffix2]) {
           break;
         }
         suffix1--;
         suffix2--;
       }
+      if (suffix1 + 1 < lines1.length) suffix1++;
+      if (suffix2 + 1 < lines2.length) suffix2++;
       print('--- from source, lines [${prefix}-${suffix1}] ------------------');
       lines1.sublist(prefix, suffix1 + 1).forEach(print);
       print('--- from dill, lines [${prefix}-${suffix2}] --------------------');
       lines2.sublist(prefix, suffix2 + 1).forEach(print);
     });
   });
 
   KernelFrontEndStrategy frontendStrategy = compiler2.frontendStrategy;
   KernelToElementMap elementMap = frontendStrategy.elementMap;
 
@@ skipping 67 matching lines @@
       Map<String, BufferedOutputSink> map2 = collector2.outputMap[outputType];
       checkSets(map1.keys, map2.keys, 'output', equality);
       map1.forEach((String name, BufferedOutputSink output1) {
         BufferedOutputSink output2 = map2[name];
         Expect.stringEquals(output1.text, output2.text);
       });
     });
   }
   return ResultKind.success;
 }