Support for dart:typed_data

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 js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/task/dart.dart' show PublicNamespaceBuilder;
 
 import 'ast_builder.dart' show AstBuilder;
 import 'reify_coercions.dart' show CoercionReifier, Tuple2;
 
@@ skipping 188 matching lines @@
           isLazy: _isDartRuntime || !_loader.libraryIsLoaded(lib));
     });
 
     // TODO(jmesserly): scriptTag support.
     // Enable this if we know we're targetting command line environment?
     // It doesn't work in browser.
     // var jsBin = compiler.options.runnerOptions.v8Binary;
     // String scriptTag = null;
     // if (library.library.scriptTag != null) scriptTag = '/usr/bin/env $jsBin';
     return moduleBuilder.build(
-        currentModuleName,
-        _jsModuleValue,
-        _exportsVar,
-        items);
+        currentModuleName, _jsModuleValue, _exportsVar, items);
   }
 
   void _emitModuleItem(AstNode node) {
     // Attempt to group adjacent properties.
     if (node is! FunctionDeclaration) _flushLibraryProperties(_moduleItems);
 
     var code = _visit(node);
     if (code != null) _moduleItems.add(code);
   }
 
@@ skipping 197 matching lines @@
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(classElem), _emitClassMethods(node, ctors, fields),
         typeParams: _emitTypeParams(classElem).toList(),
         fields:
             _emitFieldDeclarations(classElem, fields, staticFields).toList());
 
     String jsPeerName;
     var jsPeer = findAnnotation(classElem, isJsPeerInterface);
+    // Only look at "Native" annotations on registered extension types.
+    // E.g., we're current ignoring the ones in dart:html.
+    if (jsPeer == null && _extensionTypes.contains(classElem)) {
+      jsPeer = findAnnotation(classElem, isNativeAnnotation);
+    }
     if (jsPeer != null) {
       jsPeerName =
           getConstantField(jsPeer, 'name', types.stringType)?.toStringValue();
+      if (jsPeerName.contains(',')) {
+        jsPeerName = jsPeerName.split(',')[0];
+      }
     }
 
     var body = _finishClassMembers(classElem, classExpr, ctors, fields,
         staticFields, methods, node.metadata, jsPeerName);
 
     var result = _finishClassDef(type, body);
 
     if (jsPeerName != null) {
       // This class isn't allowed to be lazy, because we need to set up
       // the native JS type eagerly at this point.
@@ skipping 860 matching lines @@
       t is ParameterizedType && t.typeArguments.any(_hasUnsoundTypeParameter);
 
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
       return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
+  JS.Fun _emitNativeFunctionBody(
+      List<JS.Parameter> params, MethodDeclaration node) {
+    if (node.isStatic) {
+      // TODO(vsm): Do we need to handle this case?
+      return null;
+    }
+
+    String name = node.name.name;
+    var annotation = findAnnotation(node.element, isJsName);
+    if (annotation != null) {
+      name = getConstantField(annotation, 'name', types.stringType)
+          ?.toStringValue();
+    }
+    if (node.isGetter) {
+      return new JS.Fun(params, js.statement('{ return this.#; }', [name]));
+    } else if (node.isSetter) {
+      return new JS.Fun(
+          params, js.statement('{ this.# = #; }', [name, params.last]));
+    } else {
+      return new JS.Fun(
+          params, js.statement('{ return this.#(#); }', [name, params]));
+    }
+  }
+
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
-    if (node.isAbstract || _externalOrNative(node)) {
+    if (node.isAbstract) {
       return null;
     }
 
     var params = _visit(node.parameters) as List<JS.Parameter>;
     if (params == null) params = <JS.Parameter>[];
 
-    var typeParams = _emitTypeParams(node.element).toList();
-    var returnType = emitTypeRef(node.element.returnType);
-    JS.Fun fn = _emitFunctionBody(params, node.body, typeParams, returnType);
+    JS.Fun fn;
+    if (_externalOrNative(node)) {
+      fn = _emitNativeFunctionBody(params, node);
+      // TODO(vsm): Remove if / when we handle the static case above.
+      if (fn == null) return null;
+    } else {
+      var typeParams = _emitTypeParams(node.element).toList();
+      var returnType = emitTypeRef(node.element.returnType);
+      fn = _emitFunctionBody(params, node.body, typeParams, returnType);
+    }
+
     if (node.operatorKeyword != null &&
         node.name.name == '[]=' &&
         params.isNotEmpty) {
       // []= methods need to return the value. We could also address this at
       // call sites, but it's cleaner to instead transform the operator method.
       var returnValue = new JS.Return(params.last);
       var body = fn.body;
       if (JS.Return.foundIn(fn)) {
         // If a return is inside body, transform `(params) { body }` to
         // `(params) { (() => { body })(); return value; }`.
@@ skipping 1578 matching lines @@
       return AstBuilder.methodInvoke(
           newTarget, invoke.methodName, invoke.argumentList.arguments);
     }
   }
 
   bool _requiresStaticDispatch(Expression target, String memberName) {
     var type = getStaticType(target);
     if (!_isObjectProperty(memberName)) {
       return false;
     }
-    if (!type.isObject && !_isJSBuiltinType(type) && !_isNullable(target)) {
+    if (!type.isObject &&
+        !_isJSBuiltinType(type) &&
+        !_extensionTypes.contains(type.element) &&
+        !_isNullable(target)) {
       return false;
     }
     return true;
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
     var member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
@@ skipping 673 matching lines @@
     } else if (type is InterfaceType && type.element == expectedType.element) {
       return type.typeArguments[0];
     } else {
       // TODO(leafp): The above only handles the case where the return type
       // is exactly Future/Stream/Iterable.  Handle the subtype case.
       return DynamicTypeImpl.instance;
     }
   }
 }
 
-class JSGenerator extends CodeGenerator {
-  final _extensionTypes = new HashSet<ClassElement>();
+class _ExtensionFinder extends GeneralizingElementVisitor {
+  final AnalysisContext _context;
+  final HashSet<ClassElement> _extensionTypes;
   final TypeProvider _types;
-  JSGenerator(AbstractCompiler compiler)
-      : _types = compiler.context.typeProvider,
-        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 context = compiler.context;
-    var src = context.sourceFactory.forUri('dart:_interceptors');
-    var interceptors = context.computeLibraryElement(src);
-    for (var t in ['JSArray', 'JSString', 'JSNumber', 'JSBool']) {
-      _addExtensionType(interceptors.getType(t).type);
+
+  _ExtensionFinder(this._context, this._extensionTypes, this._types);
+
+  visitClassElement(ClassElement element) {
+    if (findAnnotation(element, isJsPeerInterface) != null ||
+        findAnnotation(element, isNativeAnnotation) != null) {
+      _addExtensionType(element.type);
     }
-    // TODO(jmesserly): manually add `int` and `double`
-    // Unfortunately our current analyzer rejects "implements int".
-    // Fix was landed, so we can remove this hack once we're updated:
-    // https://github.com/dart-lang/sdk/commit/d7cd11f86a02f55269fc8d9843e7758ebeeb81c8
-    _addExtensionType(_types.intType);
-    _addExtensionType(_types.doubleType);
   }
 
   void _addExtensionType(InterfaceType t) {
     if (t.isObject || !_extensionTypes.add(t.element)) return;
     t = fillDynamicTypeArgs(t, _types) as InterfaceType;
     t.interfaces.forEach(_addExtensionType);
     t.mixins.forEach(_addExtensionType);
     _addExtensionType(t.superclass);
   }
 
+  void _addExtensionTypes(String libraryUri) {
+    var sourceFactory = _context.sourceFactory.forUri(libraryUri);
+    var library = _context.computeLibraryElement(sourceFactory);
+    visitLibraryElement(library);
+  }
+}
+
+class JSGenerator extends CodeGenerator {
+  final _extensionTypes = new HashSet<ClassElement>();
+  final TypeProvider _types;
+
+  JSGenerator(AbstractCompiler compiler)
+      : _types = compiler.context.typeProvider,
+        super(compiler) {
+    // TODO(vsm): Eventually, we want to make this extensible - i.e., find
+    // annotations in user code as well.  It would need to be summarized in
+    // the element model - not searched this way on every compile.
+    var finder = new _ExtensionFinder(context, _extensionTypes, _types);
+    finder._addExtensionTypes('dart:_interceptors');
+    finder._addExtensionTypes('dart:_native_typed_data');
+
+    // TODO(vsm): If we're analyzing against the main SDK, those
+    // types are not explicitly annotated.
+    finder._addExtensionType(_types.intType);
+    finder._addExtensionType(_types.doubleType);
+    finder._addExtensionType(_types.boolType);
+    finder._addExtensionType(_types.stringType);
+  }
+
   String generateLibrary(LibraryUnit unit) {
     // Clone the AST first, so we can mutate it.
     unit = unit.clone();
     var library = unit.library.element.library;
     var fields = findFieldsNeedingStorage(unit, _extensionTypes);
     var rules = new StrongTypeSystemImpl();
     var codegen =
         new JSCodegenVisitor(compiler, rules, library, _extensionTypes, fields);
     var module = codegen.emitLibrary(unit);
     var out = compiler.getOutputPath(library.source.uri);
@@ skipping 25 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);
 }