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 440 matching lines @@
     if (_isNumberInJS(from) && _isNumberInJS(to)) {
       // Make sure to check when converting to int.
       if (from != types.intType && to == types.intType) {
         return js.call('dart.asInt(#)', [fromExpr]);
       }
 
       // A no-op in JavaScript.
       return fromExpr;
     }
 
-    return js.call('dart.as(#, #)', [fromExpr, _emitTypeName(to)]);
+    return js.call('dart.as(#, #)', [fromExpr, _emitType(to)]);
   }
 
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
     var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
     if (typeofName != null) {
       result = js.call('typeof # == #', [lhs, js.string(typeofName, "'")]);
     } else {
       // Always go through a runtime helper, because implicit interfaces.
-      result = js.call('dart.is(#, #)', [lhs, _emitTypeName(type)]);
+      result = js.call('dart.is(#, #)', [lhs, _emitType(type)]);
     }
 
     if (node.notOperator != null) {
       return js.call('!#', result);
     }
     return result;
   }
 
   String _jsTypeofName(DartType t) {
     if (_isNumberInJS(t)) return 'number';
     if (t == types.stringType) return 'string';
     if (t == types.boolType) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement element = node.element;
 
     JS.Expression body = annotate(
         js.call('dart.typedef(#, () => #)', [
           js.string(element.name, "'"),
-          _emitTypeName(element.type, lowerTypedef: true)
+          _emitType(element.type, lowerTypedef: true)
         ]),
         node,
         element);
 
     var typeFormals = element.typeParameters;
     if (typeFormals.isNotEmpty) {
       return _defineClassTypeArguments(element, typeFormals,
           js.statement('const # = #;', [element.name, body]));
     } else {
       return js.statement('# = #;', [_emitTopLevelName(element), body]);
     }
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) {
     // TODO(jmesserly): should only happen for erroneous code.
     if (node.type == null) return js.call('dart.dynamic');
-    return _emitTypeName(node.type);
+    return _emitType(node.type);
   }
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
 
     // Forward all generative constructors from the base class.
     var methods = <JS.Method>[];
 
     var supertype = element.supertype;
@@ skipping 207 matching lines @@
     // Create static fields for each enum value
     for (var i = 0; i < fields.length; ++i) {
       result.add(js.statement('#.# = dart.const(new #(#));',
           [id, fields[i].name, id, js.number(i)]));
     }
 
     // Create static values list
     var values = new JS.ArrayInitializer(new List<JS.Expression>.from(
         fields.map((f) => js.call('#.#', [id, f.name]))));
     result.add(js.statement('#.values = dart.const(dart.list(#, #));',
-        [id, values, _emitTypeName(type)]));
+        [id, values, _emitType(type)]));
 
     return _statement(result);
   }
 
   /// Wraps a possibly generic class in its type arguments.
   JS.Statement _defineClassTypeArguments(TypeDefiningElement element,
       List<TypeParameterElement> formals, JS.Statement body) {
     assert(formals.isNotEmpty);
     var genericDef =
         js.statement('# = dart.generic((#) => { #; return #; });', [
       _emitTopLevelName(element, suffix: r'$'),
       _emitTypeFormals(formals),
       body,
       element.name
     ]);
 
     var dynType = fillDynamicTypeArgs(element.type);
-    var genericInst = _emitTypeName(dynType, lowerGeneric: true);
+    var genericInst = _emitType(dynType, lowerGeneric: true);
     return js.statement(
         '{ #; # = #; }', [genericDef, _emitTopLevelName(element), genericInst]);
   }
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
       for (var typeArg in typeArguments) {
         var typeElement = typeArg.element;
         // FIXME(vsm): This does not track mutual recursive dependences.
@@ skipping 24 matching lines @@
     _loader.startTopLevel(element);
 
     // Find the super type
     JS.Expression heritage;
     var supertype = type.superclass;
     if (_deferIfNeeded(supertype, element)) {
       // Fall back to raw type.
       supertype = fillDynamicTypeArgs(supertype.element.type);
       _hasDeferredSupertype.add(element);
     }
-    heritage = _emitTypeName(supertype);
+    heritage = _emitType(supertype);
 
     if (type.mixins.isNotEmpty) {
-      var mixins = type.mixins.map(_emitTypeName).toList();
+      var mixins = type.mixins.map(_emitType).toList();
       mixins.insert(0, heritage);
       heritage = js.call('dart.mixin(#)', [mixins]);
     }
 
     _loader.finishTopLevel(element);
 
     return heritage;
   }
 
   /// Provide Dart getters and setters that forward to the underlying native
@@ skipping 223 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 = _emitType(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 64 matching lines @@
       List<MethodDeclaration> methods,
       ClassElement classElem,
       List<ConstructorDeclaration> ctors,
       List<ExecutableElement> extensions,
       JS.Expression className,
       List<JS.Statement> body) {
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         className,
         new JS.ArrayInitializer(new List<JS.Expression>.from(
-            classElem.interfaces.map(_emitTypeName)))
+            classElem.interfaces.map(_emitType)))
       ]));
     }
 
     var tStatics = <JS.Property>[];
     var tMethods = <JS.Property>[];
     var sNames = <JS.Expression>[];
     for (MethodDeclaration node in methods) {
       if (!(node.isSetter || node.isGetter || node.isAbstract)) {
         var name = node.name.name;
         var element = node.element;
@@ skipping 451 matching lines @@
           body.add(js.statement('if (# === void 0) # = #;',
               [jsParam, jsParam, _defaultParamValue(param)]));
         }
       }
 
       // TODO(jmesserly): various problems here, see:
       // https://github.com/dart-lang/dev_compiler/issues/161
       var paramType = param.element.type;
       if (!constructor && _hasUnsoundTypeParameter(paramType)) {
         body.add(js
-            .statement('dart.as(#, #);', [jsParam, _emitTypeName(paramType)]));
+            .statement('dart.as(#, #);', [jsParam, _emitType(paramType)]));
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
   bool _isUnsoundTypeParameter(DartType t) =>
       t is TypeParameterType && t.element.enclosingElement is ClassElement;
 
   bool _hasUnsoundTypeParameter(DartType t) =>
       _isUnsoundTypeParameter(t) ||
@@ skipping 360 matching lines @@
     _superAllowed = savedSuperAllowed;
     _asyncStarController = savedController;
 
     DartType returnType = _getExpectedReturnType(element);
     JS.Expression gen = new JS.Fun(jsParams, jsBody,
         isGenerator: true, returnType: emitTypeRef(returnType));
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
 
-    var T = _emitTypeName(returnType);
+    var T = _emitType(returnType);
     return js.call('dart.#(#)', [
       kind,
       [gen, T]..addAll(visitFormalParameterList(parameters, destructure: false))
     ]);
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
@@ skipping 42 matching lines @@
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
 
     _loader.declareBeforeUse(element);
 
     // type literal
     if (element is TypeDefiningElement) {
-      var typeName = _emitTypeName(fillDynamicTypeArgs(element.type));
+      var typeName = _emitType(fillDynamicTypeArgs(element.type));
 
       // If the type is a type literal expression in Dart code, wrap the raw
       // runtime type in a "Type" instance.
       if (!_isInForeignJS && _isTypeLiteral(node)) {
         typeName = js.call('dart.wrapType(#)', typeName);
       }
 
       return typeName;
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
       return _emitTopLevelName(element);
     }
 
     var name = element.name;
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
     if (element is ClassMemberElement && element is! ConstructorElement) {
       bool isStatic = element.isStatic;
       var type = element.enclosingElement.type;
       var member = _emitMemberName(name, isStatic: isStatic, type: type);
 
       // For static methods, we add the raw type name, without generics or
       // library prefix. We don't need those because static calls can't use
       // the generic type.
       if (isStatic) {
-        var dynType = _emitTypeName(fillDynamicTypeArgs(type));
+        var dynType = _emitType(fillDynamicTypeArgs(type));
         return new JS.PropertyAccess(dynType, member);
       }
 
       // For instance members, we add implicit-this.
       // For method tear-offs, we ensure it's a bound method.
       var tearOff = element is MethodElement && !inInvocationContext(node);
       var code = (tearOff) ? 'dart.bind(this, #)' : 'this.#';
       return js.call(code, member);
     }
 
@@ skipping 55 matching lines @@
       (p is NormalFormalParameter)
           ? p.metadata
           : (p as DefaultFormalParameter).parameter.metadata;
 
   JS.ArrayInitializer _emitTypeNames(List<DartType> types,
       [List<FormalParameter> parameters]) {
     var result = <JS.Expression>[];
     for (int i = 0; i < types.length; ++i) {
       var metadata =
           parameters != null ? _parameterMetadata(parameters[i]) : [];
-      var typeName = _emitTypeName(types[i]);
+      var typeName = _emitType(types[i]);
       var value = typeName;
       // TODO(vsm): Make this optional per #268.
       if (metadata.isNotEmpty) {
         metadata = metadata.map(_instantiateAnnotation).toList();
         value = new JS.ArrayInitializer([typeName]..addAll(metadata));
       }
       result.add(value);
     }
     return new JS.ArrayInitializer(result);
   }
 
   JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = _propertyName(name);
-      var value = _emitTypeName(type);
+      var value = _emitType(type);
       properties.add(new JS.Property(key, value));
     });
     return new JS.ObjectInitializer(properties);
   }
 
   /// Emit the pieces of a function type, as an array of return type,
   /// regular args, and optional/named args.
   List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
       {List<FormalParameter> parameters, bool lowerTypedef: false}) {
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
-    var rt = _emitTypeName(type.returnType);
+    var rt = _emitType(type.returnType);
     var ra = _emitTypeNames(parameterTypes, parameters);
 
     List<JS.Expression> typeParts;
     if (namedTypes.isNotEmpty) {
       assert(optionalTypes.isEmpty);
       // TODO(vsm): Pass in annotations here as well.
       var na = _emitTypeProperties(namedTypes);
       typeParts = [rt, ra, na];
     } else if (optionalTypes.isNotEmpty) {
       assert(namedTypes.isEmpty);
@@ skipping 14 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.
-  JS.Expression _emitTypeName(DartType type,
-      {bool lowerTypedef: false, bool lowerGeneric: false}) {
+  ///
+  /// 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 _emitType(DartType type,
+      {bool lowerTypedef: false,
+      bool lowerGeneric: false,
+      ClassElement subClass,
+      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) => _emitType(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 260 matching lines @@
 
   /// If `g` is a generic function type, and `f` is an instantiation of it,
   /// then this will return the type arguments to apply, otherwise null.
   List<JS.Expression> _emitFunctionTypeArguments(DartType g, DartType f,
       [TypeArgumentList typeArgs]) {
     if (g is FunctionType &&
         g.typeFormals.isNotEmpty &&
         f is FunctionType &&
         f.typeFormals.isEmpty) {
       return _recoverTypeArguments(g, f)
-          .map(_emitTypeName)
+          .map(_emitType)
           .toList(growable: false);
     } else if (typeArgs != null) {
       // Dynamic calls may have type arguments, even though the function types
       // are not known.
       // TODO(jmesserly): seems to be mostly broken in Analyzer at the moment:
       // https://github.com/dart-lang/sdk/issues/26368
       return typeArgs.arguments.map(visitTypeName).toList(growable: false);
     }
     return null;
   }
@@ skipping 421 matching lines @@
     if (parent is ClassElement) {
       return getter
           ? parent.getGetter(element.name)
           : parent.getSetter(element.name);
     }
     return null;
   }
 
   JS.Expression _emitConstructorName(
       ConstructorElement element, DartType type, SimpleIdentifier name) {
-    var typeName = _emitTypeName(type);
+    var typeName = _emitType(type);
     if (name != null || element.isFactory) {
       var namedCtor = _constructorName(element);
       return new JS.PropertyAccess(typeName, namedCtor);
     }
     return typeName;
   }
 
   @override
   visitConstructorName(ConstructorName node) {
     return _emitConstructorName(node.staticElement, node.type.type, node.name);
   }
 
   JS.Expression _emitInstanceCreationExpression(
       ConstructorElement element,
       DartType type,
       SimpleIdentifier name,
       ArgumentList argumentList,
       bool isConst) {
     JS.Expression emitNew() {
       JS.Expression ctor;
       bool isFactory = false;
       // var element = node.staticElement;
       if (element == null) {
         // TODO(jmesserly): this only happens if we had a static error.
         // Should we generate a throw instead?
-        ctor = _emitTypeName(type);
+        ctor = _emitType(type);
         if (name != null) {
           ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
         }
       } else {
         ctor = _emitConstructorName(element, type, name);
         isFactory = element.isFactory;
       }
       var args = _visit(argumentList) as List<JS.Expression>;
       return isFactory ? new JS.Call(ctor, args) : new JS.New(ctor, args);
     }
@@ skipping 905 matching lines @@
     var then = visitCatchClause(clause);
 
     // Discard following clauses, if any, as they are unreachable.
     if (clause.exceptionType == null) return then;
 
     // TODO(jmesserly): this is inconsistent with [visitIsExpression], which
     // has special case for typeof.
     return new JS.If(
         js.call('dart.is(#, #)', [
           _visit(_catchParameter),
-          _emitTypeName(clause.exceptionType.type),
+          _emitType(clause.exceptionType.type),
         ]),
         then,
         otherwise);
   }
 
   JS.Statement _statement(List<JS.Statement> statements) {
     // TODO(jmesserly): empty block singleton?
     if (statements.length == 0) return new JS.Block([]);
     if (statements.length == 1) return statements[0];
     return new JS.Block(statements);
@@ skipping 69 matching lines @@
 
   @override
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitSymbolLiteral(SymbolLiteral node) {
     JS.Expression emitSymbol() {
       // TODO(vsm): When we canonicalize, we need to treat private symbols
       // correctly.
       var name = js.string(node.components.join('.'), "'");
-      return js.call('#.new(#)', [_emitTypeName(types.symbolType), name]);
+      return js.call('#.new(#)', [_emitType(types.symbolType), name]);
     }
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     JS.Expression emitList() {
       JS.Expression list = new JS.ArrayInitializer(
           _visitList(node.elements) as List<JS.Expression>);
       ParameterizedType type = node.staticType;
       var elementType = type.typeArguments.single;
       // TODO(jmesserly): analyzer will usually infer `List<Object>` because
       // that is the least upper bound of the element types. So we rarely
       // generate a plain `List<dynamic>` anymore.
       if (!elementType.isDynamic) {
         // dart.list helper internally depends on _interceptors.JSArray.
         _loader.declareBeforeUse(_jsArray);
-        list = js.call('dart.list(#, #)', [list, _emitTypeName(elementType)]);
+        list = js.call('dart.list(#, #)', [list, _emitType(elementType)]);
       }
       return list;
     }
     if (node.constKeyword != null) return _emitConst(emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
@@ skipping 15 matching lines @@
       } else {
         var values = <JS.Expression>[];
         for (var e in entries) {
           values.add(_visit(e.key));
           values.add(_visit(e.value));
         }
         mapArguments = new JS.ArrayInitializer(values);
       }
       var types = <JS.Expression>[];
       if (typeArgs != null) {
-        types.addAll(typeArgs.arguments.map((e) => _emitTypeName(e.type)));
+        types.addAll(typeArgs.arguments.map((e) => _emitType(e.type)));
       }
       return js.call('dart.map(#, #)', [mapArguments, types]);
     }
     if (node.constKeyword != null) return _emitConst(emitMap);
     return emitMap();
   }
 
   @override
   JS.LiteralString visitSimpleStringLiteral(SimpleStringLiteral node) =>
       js.escapedString(node.value, node.isSingleQuoted ? "'" : '"');
@@ skipping 305 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';