Wrapperless dart:html and friends

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/dart/ast/token.dart';
@@ skipping 626 matching lines @@
     if (type.mixins.isNotEmpty) {
       var mixins = type.mixins.map(_emitTypeName).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
+  /// field.  Note that the Dart names are always symbolized to avoid
+  /// conflicts.  They will be installed as extension methods on the underlying
+  /// native type.
+  List<JS.Method> _emitNativeFieldAccessors(FieldDeclaration node) {
+    // TODO(vsm): Can this by meta-programmed?
+    // E.g., dart.nativeField(symbol, jsName)
+    // Alternatively, perhaps it could be meta-programmed directly in
+    // dart.registerExtensions?
+    var jsMethods = <JS.Method>[];
+    if (!node.isStatic) {
+      for (var decl in node.fields.variables) {
+        var field = decl.element;
+        var name = decl.name.name;
+        var annotation = findAnnotation(field, isJsName);
+        if (annotation != null) {
+          name = getConstantField(annotation, 'name', types.stringType)
+              ?.toStringValue();
+        }
+        // Generate getter
+        var fn = new JS.Fun([], js.statement('{ return this.#; }', [name]));
+        var method =
+            new JS.Method(_elementMemberName(field.getter), fn, isGetter: true);
+        jsMethods.add(method);
+
+        // Generate setter
+        if (!decl.isFinal) {
+          var value = new JS.TemporaryId('value');
+          fn = new JS.Fun(
+              [value], js.statement('{ this.# = #; }', [name, value]));
+          method = new JS.Method(_elementMemberName(field.setter), fn,
+              isSetter: true);
+          jsMethods.add(method);
+        }
+      }
+    }
+    return jsMethods;
+  }
+
   List<JS.Method> _emitClassMethods(ClassDeclaration node,
       List<ConstructorDeclaration> ctors, List<FieldDeclaration> fields) {
     var element = node.element;
     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 = 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;
           jsMethods.add(_emitIterable(type));
         }
+      } else if (m is FieldDeclaration && _extensionTypes.contains(element)) {
+        jsMethods.addAll(_emitNativeFieldAccessors(m));
       }
     }
 
     // If the type doesn't have an `iterator`, but claims to implement Iterable,
     // we inject the adaptor method here, as it's less code size to put the
     // helper on a parent class. This pattern is common in the core libraries
     // (e.g. IterableMixin<E> and IterableBase<E>).
     //
     // (We could do this same optimization for any interface with an `iterator`
     // method, but that's more expensive to check for, so it doesn't seem worth
@@ skipping 80 matching lines @@
     var name = classElem.name;
     var body = <JS.Statement>[];
 
     if (_extensionTypes.contains(classElem)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
         }
       }
+      for (var f in fields) {
+        if (!f.isStatic) {
+          for (var d in f.fields.variables) {
+            if (d.element.isPublic) {
+              dartxNames.add(
+                  _elementMemberName(d.element.getter, allowExtensions: false));
+            }
+          }
+        }
+      }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
 
     body.add(_emitClassHeritageWorkaround(cls));
 
     // TODO(jmesserly): we should really just extend native Array.
     if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
@@ skipping 2203 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) &&
-        !_extensionTypes.contains(type.element) &&
-        !_isNullable(target)) {
-      return false;
-    }
-    return true;
+
+    // If the target could be `null`, we need static dispatch.
+    // If the target may be an extension type, we also use static dispatch
+    // as we don't symbolize object properties like hashCode.
+    return _isNullable(target) ||
+        (_extensionTypes.contains(type.element) && target is! SuperExpression);
   }
 
   /// 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;
     }
     bool isStatic = member is ClassMemberElement && member.isStatic;
     var name = _emitMemberName(memberId.name,
@@ skipping 566 matching lines @@
       // conflict. We could use practically any character for this.
       name = '+$name';
     }
 
     // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
     var baseType = type;
     while (baseType is TypeParameterType) {
       baseType = baseType.element.bound;
     }
     if (allowExtensions &&
+        baseType != null &&
         _extensionTypes.contains(baseType.element) &&
         !_isObjectProperty(name)) {
       return js.call('dartx.#', _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
@@ skipping 126 matching lines @@
 
   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');
+    finder._addExtensionTypes('dart:html');
+    finder._addExtensionTypes('dart:indexed_db');
+    finder._addExtensionTypes('dart:svg');
+    finder._addExtensionTypes('dart:web_audio');
+    finder._addExtensionTypes('dart:web_gl');
+    finder._addExtensionTypes('dart:web_sql');
 
     // 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) {
@@ skipping 34 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);
 }