optimize self-references in generic type definitions

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';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 1033 matching lines @@
   }
 
   void _setBaseClass(ClassElement classElem, JS.Expression className,
       List<JS.Statement> body) {
     String jsPeerName = _getJSPeerName(classElem);
     JS.Expression newBaseClass;
     if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
       // TODO(jmesserly): we should really just extend Array in the first place.
       newBaseClass = js.call('dart.global.#', [jsPeerName]);
     } else if (_hasDeferredSupertype.contains(classElem)) {
-      newBaseClass = _emitTypeName(classElem.type.superclass);
+      newBaseClass = _emitTypeName(classElem.type.superclass,
+          subClass: classElem, className: className);
     }
     if (newBaseClass != null) {
       body.add(
           js.statement('dart.setBaseClass(#, #);', [className, newBaseClass]));
     }
   }
 
   void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
       List<JS.Statement> body, JS.Expression className) {
     for (ConstructorDeclaration member in ctors) {
@@ skipping 1149 matching lines @@
     }
     return typeParts;
   }
 
   /// Emits a Dart [type] into code.
   ///
   /// If [lowerTypedef] is set, a typedef will be expanded as if it were a
   /// function type. Similarly if [lowerGeneric] is set, the `List$()` form
   /// will be used instead of `List`. These flags are used when generating
   /// the definitions for typedefs and generic types, respectively.
+  ///
+  /// If [subClass] is set, then we are setting the base class for the given
+  /// class and should emit the given [className], which will already be
+  /// defined.
   JS.Expression _emitTypeName(DartType type,
-      {bool lowerTypedef: false, bool lowerGeneric: false}) {
+      {bool lowerTypedef: false,
+      bool lowerGeneric: false,
+      ClassElement subClass,

[Harry Terkelsen, 2016/05/09 18:04:19]

had to add 2 named args just for this one case :( not sure if there's a nicer
way?

[Jennifer Messerly, 2016/05/09 18:16:36]

Hmmm. You could pass it down as a function from `(DartType) -> JS.Expression`
that returns null if it doesn't need to replace. Not sure that's a lot better
though :)

Another idea is to do the classic recursive function split, where you have an
outer function and an inner function, with the outer one taking fewer
parameters. So _emitType and _emitTypeInternal

BTW at some point we were thinking renaming `_emitTypeName` to `_emitType` would
be good? Since "TypeName" sounds like the AST node TypeName, but the parameter
is a DartType not a TypeName.

+      JS.Expression className}) {
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
       return js.call('dart.dynamic');
     } else if (type.isBottom) {
       return js.call('dart.bottom');
     }
 
     _loader.declareBeforeUse(type.element);
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
     var element = type.element;
     if (name == '' || name == null || lowerTypedef) {
       // TODO(jmesserly): should we change how typedefs work? They currently
       // go through use similar logic as generic classes. This makes them
       // different from universal function types.
       var ft = type as FunctionType;
       var parts = _emitFunctionTypeParts(ft, lowerTypedef: lowerTypedef);
       return js.call('dart.functionType(#)', [parts]);
     }
 
     if (type is TypeParameterType) {
       return new JS.Identifier(name);
     }
 
+    if (type == subClass?.type) {
+      return className;
+    }
+
     if (type is ParameterizedType) {
       var args = type.typeArguments;
       Iterable jsArgs = null;
       if (args.any((a) => !a.isDynamic)) {
-        jsArgs = args.map(_emitTypeName);
+        jsArgs = args.map(
+            (x) => _emitTypeName(x, subClass: subClass, className: className));
       } else if (lowerGeneric) {
         jsArgs = [];
       }
       if (jsArgs != null) {
         var genericName = _emitTopLevelName(element, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
     return _emitTopLevelName(element);
@@ skipping 2124 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';