Generate metadata

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 345 matching lines @@
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(classElem), _emitClassMethods(node, ctors, fields));
 
     String jsPeerName;
     var jsPeer = findAnnotation(classElem, _isJsPeerInterface);
     if (jsPeer != null) {
       jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
     }
 
-    var body = _finishClassMembers(
-        classElem, classExpr, ctors, fields, methods, jsPeerName);
+    var body = _finishClassMembers(classElem, classExpr, ctors, fields, 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.
       // If we wanted to support laziness, we could defer the hookup until
       // the end of the Dart library cycle load.
       assert(_loader.isLoaded(classElem));
 
@@ skipping 156 matching lines @@
     var parentType = findSupertype(t, _implementsIterable);
     if (parentType != null) return null;
 
     // Otherwise, emit the adapter method, which wraps the Dart iterator in
     // an ES6 iterator.
     return new JS.Method(js.call('$_SYMBOL.iterator'), js.call(
         'function() { return new dart.JsIterator(this.#); }',
         [_emitMemberName('iterator', type: t)]));
   }
 
+  JS.Expression _instantiateAnnotation(Annotation node) {
+    var element = node.element;
+    if (element is ConstructorElement) {
+      return _emitInstanceCreationExpression(
+          element, element.returnType, node.constructorName, node.arguments, true);

[Jennifer Messerly, 2015/06/09 23:29:53]

./tool/format.sh ?  :)

[vsm, 2015/06/10 13:28:27]

Done.  Sorry - uploaded too early.

+    } else {
+      return _visit(node.name);
+    }
+  }
+
   /// Emit class members that need to come after the class declaration, such
   /// as static fields. See [_emitClassMethods] for things that are emitted
   /// inside the ES6 `class { ... }` node.
   JS.Statement _finishClassMembers(ClassElement classElem,
       JS.ClassExpression cls, List<ConstructorDeclaration> ctors,
       List<FieldDeclaration> fields, List<MethodDeclaration> methods,
-      String jsPeerName) {
+      List<Annotation> metadata, String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
 
     if (jsPeerName != null) {
       var dartxNames = [];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
         }
       }
@@ skipping 59 matching lines @@
           var property =
               new JS.Property(memberName, new JS.ArrayInitializer(parts));
           if (node.isStatic) {
             tStatics.add(property);
             sNames.add(memberName);
           } else {
             tMethods.add(property);
           }
         }
       }
+
       var tCtors = [];
       for (ConstructorDeclaration node in ctors) {
         var memberName = _constructorName(node.element);
         var element = node.element;
         var parts =
             _emitFunctionTypeParts(element.type, dynamicIsBottom: false);
         var property =
             new JS.Property(memberName, new JS.ArrayInitializer(parts));
         tCtors.add(property);
       }
+
       build(name, elements) {
         var o =
             new JS.ObjectInitializer(elements, multiline: elements.length > 1);
         var e = js.call('() => #', o);
         var p = new JS.Property(_propertyName(name), e);
         return p;
       }
       var sigFields = [];
       if (!tCtors.isEmpty) sigFields.add(build('constructors', tCtors));
       if (!tMethods.isEmpty) sigFields.add(build('methods', tMethods));
@@ skipping 18 matching lines @@
       var methodNames = [];
       for (var e in extensions) {
         methodNames.add(_elementMemberName(e));
       }
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
         name,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
 
+    // Metadata
+    if (metadata.isNotEmpty) {
+      body.add(js.statement('#[dart.metadata] = () => #;', [
+        name,
+        new JS.ArrayInitializer(metadata.map(_instantiateAnnotation).toList())
+      ]));
+    }
+
     return _statement(body);
   }
 
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
     var members = <ExecutableElement>[];
     if (_extensionTypes.contains(element)) return members;
 
     // Collect all extension types we implement.
     var type = element.type;
     var types = new Set<ClassElement>();
@@ skipping 1048 matching lines @@
 
   void _flushLibraryProperties(List<JS.Statement> body) {
     if (_properties.isEmpty) return;
     body.add(js.statement('dart.copyProperties(#, { # });', [
       _exportsVar,
       _properties.map(_emitTopLevelProperty)
     ]));
     _properties.clear();
   }
 
-  @override
-  visitConstructorName(ConstructorName node) {
-    var typeName = _visit(node.type);
-    var element = node.staticElement;
-    if (node.name != null || element.isFactory) {
+  _emitConstructorName(ConstructorElement element, DartType type, SimpleIdentifier name) {

[Jennifer Messerly, 2015/06/09 23:29:53]

return type?

[vsm, 2015/06/10 13:28:27]

Done.

+    var typeName = _emitTypeName(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);
+  }
+
+  _emitInstanceCreationExpression(ConstructorElement element, DartType type, SimpleIdentifier name,
+      ArgumentList argumentList, bool isConst) {
+    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);
+        if (name != null) {
+          ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
+        }
+      } else {
+        ctor = _emitConstructorName(element, type, name);
+        isFactory = element.isFactory;
+      }
+      var args = _visit(argumentList);
+      return isFactory ? new JS.Call(ctor, args) : new JS.New(ctor, args);
+    }
+    if (isConst) return _emitConst(emitNew);
+    return emitNew();
+  }
+
+  @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
-    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 = _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);
-      return isFactory ? new JS.Call(ctor, args) : new JS.New(ctor, args);
-    }
-    if (node.isConst) return _emitConst(node, emitNew);
-    return emitNew();
+    var element = node.staticElement;
+    var constructor = node.constructorName;
+    var name = constructor.name;
+    var type = constructor.type.type;
+    return _emitInstanceCreationExpression(
+        element, type, name, node.argumentList, node.isConst);
   }
 
   /// 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.
   bool _isJSBuiltinType(DartType t) =>
       typeIsPrimitiveInJS(t) || rules.isStringType(t);
 
   bool typeIsPrimitiveInJS(DartType t) => rules.isIntType(t) ||
@@ skipping 79 matching lines @@
     var jsExpr = _visit(expr);
     if (_isNonNullableExpression(expr)) return jsExpr;
     return js.call('dart.notNull(#)', jsExpr);
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
+
     var leftType = getStaticType(left);
     var rightType = getStaticType(right);
 
     var code;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
       // We can also do this if both sides are the same primitive type.
       if (_canUsePrimitiveEquality(left, right)) {
         code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
       } else {
@@ skipping 49 matching lines @@
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id =
         new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
     id.staticElement = new TemporaryVariableElement.forNode(id);
     id.staticType = type;
     return id;
   }
 
-  JS.Expression _emitConst(Expression node, JS.Expression expr()) {
+  JS.Expression _emitConst(JS.Expression expr()) {
     // TODO(jmesserly): emit the constants at top level if possible.
     // This wasn't quite working, so disabled for now.
     return js.call('dart.const(#)', expr());
   }
 
   /// Returns a new expression, which can be be used safely *once* on the
   /// left hand side, and *once* on the right side of an assignment.
   /// For example: `expr1[expr2] += y` can be compiled as
   /// `expr1[expr2] = expr1[expr2] + y`.
   ///
@@ skipping 470 matching lines @@
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitSymbolLiteral(SymbolLiteral node) {
     emitSymbol() {
       // TODO(vsm): When we canonicalize, we need to treat private symbols
       // correctly.
       var name = js.string(node.components.join('.'), "'");
       return new JS.New(_emitTypeName(types.symbolType), [name]);
     }
-    return _emitConst(node, emitSymbol);
+    return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     emitList() {
       JS.Expression list = new JS.ArrayInitializer(_visitList(node.elements));
       ParameterizedType type = node.staticType;
       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);
+    if (node.constKeyword != null) return _emitConst(emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
     emitMap() {
       var entries = node.entries;
       var mapArguments = null;
       if (entries.isEmpty) {
@@ skipping 11 matching lines @@
         var values = [];
         for (var e in entries) {
           values.add(_visit(e.key));
           values.add(_visit(e.value));
         }
         mapArguments = new JS.ArrayInitializer(values);
       }
       // TODO(jmesserly): add generic types args.
       return js.call('dart.map(#)', [mapArguments]);
     }
-    if (node.constKeyword != null) return _emitConst(node, emitMap);
+    if (node.constKeyword != null) return _emitConst(emitMap);
     return emitMap();
   }
 
   @override
   JS.LiteralString visitSimpleStringLiteral(SimpleStringLiteral node) =>
       js.escapedString(node.value, node.isSingleQuoted ? "'" : '"');
 
   @override
   JS.Expression visitAdjacentStrings(AdjacentStrings node) =>
       _visitListToBinary(node.strings, '+');
@@ skipping 242 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);
 }