Fix #29003

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1256 matching lines @@
       {List<FieldDeclaration> fields}) {
     String name = element.name;
     var heritage = _emitClassHeritage(element);
     var typeParams = _emitTypeFormals(element.typeParameters);
     var jsFields = fields?.map(_emitTypeScriptField)?.toList();
 
     return new JS.ClassExpression(new JS.Identifier(name), heritage, methods,
         typeParams: typeParams, fields: jsFields);
   }
 
+  /// In some corner cases, a mixin may have its own mixins.
+  /// E.g., M2 is a valid mixin:
+  ///
+  /// class M1 { int foo() => 42; }
+  /// class M2 = Object with M1;
+  /// class M3 = Object with M2;
+  ///
+  /// We expand out the list of mixins to treat M1 and M2 as separate
+  /// applications.
+  List<InterfaceType> _flattenMixins(List<InterfaceType> mixins) {

[Jennifer Messerly, 2017/03/27 22:15:15]

I don't think this is correct in general?

it will expand out mixins arbitrarily, yes it happens to work with "class M2 =
Object with M1;" but it won't work with:

    class M2 extends Object with M1 { foo() => 123 }

... the method "foo" above would just get discarded?

For the moment, that may be disallowed by another check, but in general
flattening out seems really bad. For example:

library 1:
    // Private!
    class _M1 { int foo() => 42; }
    class M2 = Object with _M1;

library 2:

    class M3 extends M2 {} // does this expand to _M1 ??


... with this fix, wouldn't we try to generate a private reference to M1 from
library2  ... that might happen to work but it's very unsafe.

Finally ... this would support invalid things like:
    class M1 { int foo() => 42; }
    class M2 { int foo() => 42; }
    class M3 = Object with M1, M2;
    class M4 extends Object with M3 {} // not actually valid??

I described this in more detail here:
https://github.com/dart-lang/sdk/issues/29003#issuecomment-285471442

... what's going on here is that "class M2 = Object with M1;" is like a special
form of typedef.

I think the way to support this is handling the special case "type A = Object
with B" in visitClassTypeAlias. That has a lot less risk of accidentally causing
other breakage.

+    if (mixins.any((m) => m.mixins.isNotEmpty)) {
+      // Clone, so we do not overwrite.
+      mixins = new List<InterfaceType>.from(mixins);
+      for (int i = 0; i < mixins.length; ++i) {
+        var mixin = mixins[i];
+        if (mixin.mixins.isNotEmpty) {
+          var indirectMixins = _flattenMixins(mixin.mixins);
+          mixins.insertAll(i, indirectMixins);
+          i += indirectMixins.length;
+        }
+      }
+    }
+    return mixins;
+  }
+
   JS.Expression _emitClassHeritage(ClassElement element) {
     var type = element.type;
     if (type.isObject) return null;
 
     _loader.startTopLevel(element);
 
     // List of "direct" supertypes (supertype + mixins)
-    var basetypes = [type.superclass]..addAll(type.mixins);
+    var basetypes = [type.superclass]..addAll(_flattenMixins(type.mixins));
 
     // If any of these are recursive (via type parameter), defer setting
     // the real superclass.
     if (basetypes.any((t) => _deferIfNeeded(t, element))) {
       // Fall back to raw type
       basetypes =
           basetypes.map((t) => fillDynamicTypeArgs(t.element.type)).toList();
       _hasDeferredSupertype.add(element);
     }
 
@@ skipping 419 matching lines @@
         var newBaseClass = _callHelper('global.#', [peer]);
         body.add(_callHelperStatement(
             'setExtensionBaseClass(#, #);', [className, newBaseClass]));
       }
     } else if (_hasDeferredSupertype.contains(classElem)) {
       // TODO(vsm): consider just threading the deferred supertype through
       // instead of recording classElem in a set on the class and recomputing
       var newBaseClass = _emitType(classElem.type.superclass,
           nameType: false, subClass: classElem, className: className);
       if (classElem.type.mixins.isNotEmpty) {
-        var mixins = classElem.type.mixins
+        var mixins = _flattenMixins(classElem.type.mixins)
             .map((t) => _emitType(t, nameType: false))
             .toList();
         mixins.insert(0, newBaseClass);
         newBaseClass = _callHelper('mixin(#)', [mixins]);
       }
       var deferredBaseClass = _callHelperStatement(
           'setBaseClass(#, #);', [className, newBaseClass]);
       if (typeFormals.isNotEmpty) return deferredBaseClass;
       body.add(deferredBaseClass);
     }
@@ skipping 4302 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }