fixes #173, ability to use native JS indexers

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 91 matching lines @@
   JS.Program emitLibrary(LibraryUnit library) {
     String jsDefaultValue = null;
 
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, compiler).reify();
 
     var unit = library.library;
     if (unit.directives.isNotEmpty) {
       var libraryDir = unit.directives.first;
       if (libraryDir is LibraryDirective) {
-        var jsName = getAnnotationValue(libraryDir, _isJsNameAnnotation);
+        var jsName = findAnnotation(libraryDir.element, _isJsNameAnnotation);
         jsDefaultValue = getConstantField(jsName, 'name', types.stringType);
       }
     }
     if (jsDefaultValue == null) jsDefaultValue = '{}';
 
     // TODO(jmesserly): visit scriptTag, directives?
 
     _loader.collectElements(currentLibrary, library.partsThenLibrary);
 
     for (var unit in library.partsThenLibrary) {
@@ skipping 198 matching lines @@
       return js.statement('let # = #;', [dartClassName, jsTypeName]);
     }
     return null;
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     // If we've already emitted this class, skip it.
     var classElem = node.element;
     var type = classElem.type;
-    var jsName = getAnnotationValue(node, _isJsNameAnnotation);
+    var jsName = findAnnotation(classElem, _isJsNameAnnotation);
 
     if (jsName != null) return _emitJsType(node.name.name, jsName);
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var methods = <MethodDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration && !member.isStatic) {
         fields.add(member);
       } else if (member is MethodDeclaration) {
         methods.add(member);
       }
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(classElem), _emitClassMethods(node, ctors, fields));
 
     String jsPeerName;
-    var jsPeer = getAnnotationValue(node, _isJsPeerInterface);
+    var jsPeer = findAnnotation(classElem, _isJsPeerInterface);
     if (jsPeer != null) {
       jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
     }
 
     var body = _finishClassMembers(
         classElem, classExpr, ctors, fields, methods, jsPeerName);
 
     var result = _finishClassDef(type, body);
 
     if (jsPeerName != null) {
@@ skipping 104 matching lines @@
     var type = element.type;
     var isObject = type.isObject;
 
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
     var jsMethods = <JS.Method>[];
     if (ctors.isEmpty && !isObject) {
       jsMethods.add(_emitImplicitConstructor(node, fields));
     }
 
-    bool hasJsPeer = getAnnotationValue(node, _isJsPeerInterface) != null;
+    bool hasJsPeer = findAnnotation(element, _isJsPeerInterface) != null;
 
     bool hasIterator = false;
     for (var m in node.members) {
       if (m is ConstructorDeclaration) {
         jsMethods.add(_emitConstructor(m, type, fields, isObject));
       } else if (m is MethodDeclaration) {
         jsMethods.add(_emitMethodDeclaration(type, m));
 
         if (!hasJsPeer && m.isGetter && m.name.name == 'iterator') {
           hasIterator = true;
@@ skipping 909 matching lines @@
     var vars = {};
     var lhs = _bindLeftHandSide(vars, left, context: context);
     var inc = AstBuilder.binaryExpression(lhs, op, right);
     inc.staticElement = element;
     inc.staticType = getStaticType(left);
     return new JS.MetaLet(vars, [_emitSet(lhs, inc)]);
   }
 
   JS.Expression _emitSet(Expression lhs, Expression rhs) {
     if (lhs is IndexExpression) {
-      return _emitSend(_getTarget(lhs), '[]=', [lhs.index, rhs]);
+      var target = _getTarget(lhs);
+      if (_useNativeJsIndexer(target.staticType)) {
+        return js.call(
+            '#[#] = #', [_visit(target), _visit(lhs.index), _visit(rhs)]);
+      }
+      return _emitSend(target, '[]=', [lhs.index, rhs]);
     }
 
     Expression target = null;
     SimpleIdentifier id;
     if (lhs is PropertyAccess) {
       target = _getTarget(lhs);
       id = lhs.propertyName;
     } else if (lhs is PrefixedIdentifier) {
       target = lhs.prefix;
       id = lhs.identifier;
@@ skipping 770 matching lines @@
         _visitList(args)
       ]);
     }
 
     // Generic dispatch to a statically known method.
     return js.call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
-    return _emitSend(_getTarget(node), '[]', [node.index]);
+    var target = _getTarget(node);
+    if (_useNativeJsIndexer(target.staticType)) {
+      return new JS.PropertyAccess(_visit(target), _visit(node.index));
+    }
+    return _emitSend(target, '[]', [node.index]);
   }
 
+  // TODO(jmesserly): ideally we'd check the method and see if it is marked
+  // `external`, but that doesn't work because it isn't in the element model.
+  bool _useNativeJsIndexer(DartType type) =>
+      findAnnotation(type.element, _isJsNameAnnotation) != null;
+
   /// Gets the target of a [PropertyAccess] or [IndexExpression].
   /// Those two nodes are special because they're both allowed on left side of
   /// an assignment expression and cascades.
   Expression _getTarget(node) {
     assert(node is IndexExpression || node is PropertyAccess);
     return node.isCascaded ? _cascadeTarget : node.target;
   }
 
   @override
   visitConditionalExpression(ConditionalExpression node) {
@@ skipping 495 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);
 }