fixes #40, extension methods for primitive types

lib/src/codegen/js_codegen.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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 37 matching lines @@
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final AbstractCompiler compiler;
   final CompilerOptions options;
   final TypeRules rules;
   final LibraryInfo libraryInfo;
 
-  /// The global extension method table.
-  final HashMap<String, List<InterfaceType>> _extensionMethods;
+  /// The global extension type table.
+  final HashSet<ClassElement> _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
   final HashSet<FieldElement> _fieldsNeedingStorage;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
@@ skipping 13 matching lines @@
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _exportsVar = new JS.TemporaryId('exports');
   final _namedArgTemp = new JS.TemporaryId('opts');
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
   JSCodegenVisitor(AbstractCompiler compiler, this.libraryInfo,
-      this._extensionMethods, this._fieldsNeedingStorage)
+      this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options,
         rules = compiler.rules {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
   }
 
   LibraryElement get currentLibrary => libraryInfo.library;
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
@@ skipping 448 matching lines @@
       ]));
     }
 
     // Interfaces
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         name,
         new JS.ArrayInitializer(
             classElem.interfaces.map(_emitTypeName).toList())
       ]));
+
+      // If a concrete class implements one of our extensions, we might need to
+      // add forwarders.
+      var extensions = _extensionsToImplement(classElem);
+      if (extensions.isNotEmpty) {
+        // Get the dynamic substitution of the extension interface, as we only
+        // care about what methods it has, not their implementation.
+        var jsTypes = extensions
+            .map((e) => _emitTypeName(fillDynamicTypeArgs(e.type, types)));
+        body.add(js.statement('dart.implementExtension(#, () => #);', [
+          name,
+          new JS.ArrayInitializer(jsTypes.toList(growable: false))
+        ]));
+      }
     }
 
     // Named constructors
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
         body.add(js.statement('dart.defineNamedConstructor(#, #);', [
           name,
           _emitMemberName(member.name.name, isStatic: true)
         ]));
       }
@@ skipping 18 matching lines @@
       for (MethodDeclaration node in methods) {
         if (!(node.isSetter || node.isGetter || node.isAbstract)) {
           var name = node.name.name;
           var element = node.element;
           var inheritedElement =
               classElem.lookUpInheritedConcreteMethod(name, currentLibrary);
           if (inheritedElement != null &&
               inheritedElement.type == element.type) continue;
           var unary = node.parameters.parameters.isEmpty;
           var memberName = _emitMemberName(name,
-              type: cType, unary: unary, isStatic: node.isStatic);
+              type: cType,
+              unary: unary,
+              isStatic: node.isStatic,
+              declaration: true);
           var parts =
               _emitFunctionTypeParts(element.type, dynamicIsBottom: false);
           var property =
               new JS.Property(memberName, new JS.ArrayInitializer(parts));
           if (node.isStatic) {
             tStatics.add(property);
             sNames.add(memberName);
           } else tMethods.add(property);
         }
       }
@@ skipping 27 matching lines @@
       if (!sigFields.isEmpty) {
         var sig = new JS.ObjectInitializer(sigFields);
         var classExpr = new JS.Identifier(name);
         body.add(js.statement('dart.setSignature(#, #);', [classExpr, sig]));
       }
     }
 
     return _statement(body);
   }
 
+  Set<ClassElement> _extensionsToImplement(ClassElement element) {
+    var extensions = new Set<ClassElement>();
+    if (_extensionTypes.contains(element)) return extensions;
+
+    // Collect all extension types we implement.
+    _collectExtensions(element.type, extensions);
+    if (extensions.isEmpty) return extensions;
+
+    // Filter out extensions implemented by our superclass or mixins.
+    var s = element.supertype.element;
+    if (!s.isAbstract) extensions.removeAll(_extensionsToImplement(s));
+    for (var mixin in element.mixins) {
+      var m = mixin.element;
+      if (!m.isAbstract) extensions.removeAll(_extensionsToImplement(m));
+    }
+    return extensions;
+  }
+
+  /// Collections the type and all supertypes, including interfaces, but
+  /// excluding [Object].
+  void _collectExtensions(InterfaceType type, Set<ClassElement> types) {
+    if (type.isObject) return;
+    var element = type.element;
+    if (_extensionTypes.contains(element)) types.add(element);
+    for (var m in type.mixins.reversed) {
+      _collectExtensions(m, types);
+    }
+    for (var i in type.interfaces) {
+      _collectExtensions(i, types);
+    }
+    _collectExtensions(type.superclass, types);
+  }
+
   JS.Statement _overrideField(FieldElement e) {
     var cls = e.enclosingElement;
     return js.statement('dart.virtualField(#, #)', [
       cls.name,
       _emitMemberName(e.name, type: cls.type)
     ]);
   }
 
   /// Generates the implicit default constructor for class C of the form
   /// `C() : super() {}`.
@@ skipping 329 matching lines @@
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
     var memberName = _emitMemberName(node.name.name,
-        type: type, unary: params.isEmpty, isStatic: node.isStatic);
+        type: type,
+        unary: params.isEmpty,
+        isStatic: node.isStatic,
+        declaration: true);
     return new JS.Method(memberName, new JS.Fun(params, _visit(node.body)),
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
@@ skipping 651 matching lines @@
     body.add(js.statement('dart.copyProperties(#, { # });', [
       _exportsVar,
       _properties.map(_emitTopLevelProperty)
     ]));
     _properties.clear();
   }
 
   @override
   visitConstructorName(ConstructorName node) {
     var typeName = _visit(node.type);
-    if (node.name != null || node.staticElement.isFactory) {
-      var namedCtor = _constructorName(node.staticElement);
+    var element = node.staticElement;
+    if (node.name != null || element.isFactory) {
+      var namedCtor = _constructorName(element);
       return new JS.PropertyAccess(typeName, namedCtor);
     }
     return typeName;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     emitNew() {
-      var ctor = _visit(node.constructorName);
+      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 = _visit(node.constructorName.type);
+        var ctorName = node.constructorName.name;
+        if (ctorName != null) {
+          ctor = new JS.PropertyAccess(ctor, _propertyName(ctorName.name));
+        }
+      } else {
+        ctor = _visit(node.constructorName);
+        isFactory = element.isFactory;
+      }
       var args = _visit(node.argumentList);
-      var isFactory = node.staticElement.isFactory;
       return isFactory ? new JS.Call(ctor, args) : new JS.New(ctor, args);
     }
     if (node.isConst) return _emitConst(node, emitNew);
     return emitNew();
   }
 
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
@@ skipping 639 matching lines @@
       return new JS.New(_emitTypeName(types.symbolType), [name]);
     }
     return _emitConst(node, emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     emitList() {
       JS.Expression list = new JS.ArrayInitializer(_visitList(node.elements));
       ParameterizedType type = node.staticType;
-      if (type.typeArguments.any((a) => a != types.dynamicType)) {
-        list = js.call('dart.setType(#, #)', [list, _emitTypeName(type)]);
+      var elementType = type.typeArguments.single;
+      if (elementType != types.dynamicType) {
+        list = js.call('dart.list(#, #)', [list, _emitTypeName(elementType)]);
       }
       return list;
     }
     if (node.constKeyword != null) return _emitConst(node, emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
@@ skipping 128 matching lines @@
   ///
   /// This follows the same pattern as EcmaScript 6 Map:
   /// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map>
   ///
   /// Unary minus looks like: `x['unary-']()`. Note that [unary] must be passed
   /// for this transformation to happen, otherwise binary minus is assumed.
   ///
   /// Equality is a bit special, it is generated via the Dart `equals` runtime
   /// helper, that checks for null. The user defined method is called '=='.
   ///
-  JS.Expression _emitMemberName(String name,
-      {DartType type, bool unary: false, bool isStatic: false}) {
+  JS.Expression _emitMemberName(String name, {DartType type, bool unary: false,
+      bool isStatic: false, bool declaration: false}) {
 
     // Static members skip the rename steps.
     if (isStatic) return _propertyName(name);
 
     if (name.startsWith('_')) {
       return _privateNames.putIfAbsent(
           name, () => _initSymbol(new JS.TemporaryId(name)));
     }
 
-    // Check for extension method:
-    var extLibrary = _findExtensionLibrary(name, type);
-
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (name == '-' && unary) {
       name = 'unary-';
     }
 
-    if (extLibrary != null) {
-      return _extensionMethodName(name, extLibrary);
+    // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
+    if (!declaration && _extensionTypes.contains(type.element)) {
+      // Special case `length`. We can call it directly.
+      if (name != 'length') return js.call('dartx.#', _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
-  LibraryElement _findExtensionLibrary(String name, DartType type) {
-    if (type is! InterfaceType) return null;
-
-    var extLibrary = null;
-    var extensionTypes = _extensionMethods[name];
-    if (extensionTypes != null) {
-      // Normalize the type to ignore generics.
-      type = fillDynamicTypeArgs(type, types);
-      for (var t in extensionTypes) {
-        if (rules.isSubTypeOf(type, t)) {
-          assert(extLibrary == null || extLibrary == t.element.library);
-          extLibrary = t.element.library;
-        }
-      }
-    }
-    return extLibrary;
-  }
-
-  JS.Expression _extensionMethodName(String name, LibraryElement library) {
-    var extName = '\$$name';
-    if (library == currentLibrary) {
-      // TODO(jacobr): need to do a better job ensuring that extension method
-      // name symbols do not conflict with other symbols before we can let
-      // user defined libraries define extension methods.
-      if (_extensionMethodNames.add(extName)) {
-        _initSymbol(new JS.Identifier(extName));
-        _addExport(extName);
-      }
-      return new JS.Identifier(extName);
-    }
-    return js.call('#.#', [_libraryName(library), _propertyName(extName)]);
-  }
-
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Choose a canonical name from the library element.
   /// This never uses the library's name (the identifier in the `library`
   /// declaration) as it doesn't have any meaningful rules enforced.
   JS.Identifier _libraryName(LibraryElement library) {
     if (library == currentLibrary) return _exportsVar;
     return _imports.putIfAbsent(
         library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
   DartType getStaticType(Expression e) => rules.getStaticType(e);
 }
 
 class JSGenerator extends CodeGenerator {
-  /// For fast lookup of extension methods, we first check the name, then do a
-  /// (possibly expensive) subtype test to see if it matches one of the types
-  /// that declares that method.
-  final _extensionMethods = new HashMap<String, List<InterfaceType>>();
+  final _extensionTypes = new HashSet<ClassElement>();
 
-  JSGenerator(AbstractCompiler context) : super(context) {
-
+  JSGenerator(AbstractCompiler compiler) : super(compiler) {
     // TODO(jacobr): determine the the set of types with extension methods from
     // the annotations rather than hard coding the list once the analyzer
     // supports summaries.
-    var extensionTypes = [types.listType, types.iterableType];
-    for (var type in extensionTypes) {
-      type = fillDynamicTypeArgs(type, rules.provider);
-      var e = type.element;
-      var names = new HashSet<String>()
-        ..addAll(e.methods.map((m) => m.name))
-        ..addAll(e.accessors.map((m) => m.name));
-      for (var name in names) {
-        _extensionMethods.putIfAbsent(name, () => []).add(type);
-      }
+    var context = compiler.context;
+    var src = context.sourceFactory.forUri('dart:_interceptors');
+    var interceptors = context.computeLibraryElement(src);
+    for (var t in ['JSArray', 'JSString', 'JSInt', 'JSDouble', 'JSBool']) {
+      _addExtensionType(interceptors.getType(t).type);
     }
   }
 
-  TypeProvider get types => rules.provider;
+  void _addExtensionType(InterfaceType t) {
+    if (t.isObject || !_extensionTypes.add(t.element)) return;
+    t = fillDynamicTypeArgs(t, rules.provider);
+    t.interfaces.forEach(_addExtensionType);
+    t.mixins.forEach(_addExtensionType);
+    _addExtensionType(t.superclass);
+  }
 
   String generateLibrary(LibraryUnit unit, LibraryInfo info) {
     var fields = findFieldsNeedingStorage(unit);
-    var codegen =
-        new JSCodegenVisitor(compiler, info, _extensionMethods, fields);
+    var codegen = new JSCodegenVisitor(compiler, info, _extensionTypes, fields);
     var module = codegen.emitLibrary(unit);
     var dir = path.join(outDir, jsOutputPath(info, root));
     return writeJsLibrary(module, dir, emitSourceMaps: options.emitSourceMaps);
   }
 }
 
 /// Choose a canonical name from the library element.
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
@@ skipping 35 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }