Resynthesize mixins from Kernel.

pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.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 fasta.kernel_library_builder;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
@@ skipping 127 matching lines @@
     // library scope.
     Scope constructorScope =
         new Scope(constructors, null, null, isModifiable: false);
     ClassBuilder cls = new SourceClassBuilder(
         documentationComment,
         metadata,
         modifiers,
         className,
         typeVariables,
         applyMixins(supertype,
-            subclassName: className, typeVariables: typeVariables),
+            isSyntheticMixinImplementation: true,
+            subclassName: className,
+            typeVariables: typeVariables),
         interfaces,
         classScope,
         constructorScope,
         this,
         new List<ConstructorReferenceBuilder>.from(constructorReferences),
         charOffset);
     constructorReferences.clear();
     Map<String, TypeVariableBuilder> typeVariablesByName =
         checkTypeVariables(typeVariables, cls);
     void setParent(String name, MemberBuilder member) {
@@ skipping 51 matching lines @@
         }
       }
     }
     return typeVariablesByName;
   }
 
   KernelTypeBuilder applyMixin(
       KernelTypeBuilder supertype, KernelTypeBuilder mixin, String signature,
       {String documentationComment,
       List<MetadataBuilder> metadata,
+      bool isSyntheticMixinImplementation: false,
       String name,
       List<TypeVariableBuilder> typeVariables,
       int modifiers: abstractMask,
       List<KernelTypeBuilder> interfaces,
       int charOffset: -1}) {
     var constructors = <String, MemberBuilder>{};
     bool isNamed = name != null;
     SourceClassBuilder builder;
     if (isNamed) {
       modifiers |= namedMixinApplicationMask;
@@ skipping 17 matching lines @@
           interfaces,
           new Scope(<String, MemberBuilder>{}, <String, MemberBuilder>{},
               scope.withTypeVariables(typeVariables),
               isModifiable: false),
           new Scope(constructors, null, null, isModifiable: false),
           this,
           <ConstructorReferenceBuilder>[],
           charOffset,
           null,
           mixin);
+      builder.cls.isSyntheticMixinImplementation =
+          isSyntheticMixinImplementation;
       addBuilder(name, builder, charOffset);
       if (!isNamed) {
         mixinApplicationClasses[name] = builder;
       }
     }
     return addNamedType(name, <KernelTypeBuilder>[], charOffset)
       ..bind(isNamed ? builder : null);
   }
 
   KernelTypeBuilder applyMixins(KernelTypeBuilder type,
       {List<MetadataBuilder> metadata,
+      bool isSyntheticMixinImplementation: false,
       String name,
       String subclassName,
       List<TypeVariableBuilder> typeVariables,
       int modifiers: abstractMask,
       List<KernelTypeBuilder> interfaces,
       int charOffset: -1}) {
     if (type is KernelMixinApplicationBuilder) {
       subclassName ??= name;
       List<List<String>> signatureParts = <List<String>>[];
       Map<String, String> unresolved = <String, String>{};
@@ skipping 122 matching lines @@
                   .toList(),
               -1);
         }
         KernelNamedTypeBuilder mixin = type.mixins[i];
         for (var type in mixin.arguments ?? const []) {
           type.bind(variables[type.name]);
         }
         checkArguments(supertype);
         checkArguments(mixin);
         supertype = applyMixin(supertype, mixin, signature,
+            isSyntheticMixinImplementation: true,
             typeVariables:
                 new List<TypeVariableBuilder>.from(variables.values));
       }
       KernelNamedTypeBuilder mixin = type.mixins.last;
 
       Set<String> supertypeArguments = new Set<String>();
       for (var part in currentSignatureParts) {
         supertypeArguments.addAll(part);
       }
       String signature = name == null ? computeSignature() : "";
@@ skipping 20 matching lines @@
         for (var type in mixin.arguments ?? const []) {
           type.bind(variables[type.name]);
         }
       }
       checkArguments(supertype);
       checkArguments(mixin);
 
       KernelNamedTypeBuilder t = applyMixin(supertype, mixin, signature,
           metadata: metadata,
           name: name,
+          isSyntheticMixinImplementation: isSyntheticMixinImplementation,
           typeVariables: typeVariables,
           modifiers: modifiers,
           interfaces: interfaces,
           charOffset: charOffset);
       if (name == null) {
         var builder = t.builder;
         t = addNamedType(
             t.name, freeTypes.keys.map((k) => freeTypes[k]).toList(), -1);
         if (builder != null) {
           t.bind(builder);
@@ skipping 410 matching lines @@
           mixinApplicationClasses.putIfAbsent(name, () => builder);
       if (existing != builder) {
         part.scope.local.remove(name);
       }
     });
     super.includePart(part);
     nativeMethods.addAll(part.nativeMethods);
     boundlessTypeVariables.addAll(part.boundlessTypeVariables);
   }
 }