Tag closures with their 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 317 matching lines @@
   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);
 
     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);
     if (jsPeer != null) {
       jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
     }
 
-    var body =
-        _finishClassMembers(classElem, classExpr, ctors, fields, jsPeerName);
+    var body = _finishClassMembers(
+        classElem, classExpr, ctors, fields, methods, 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 162 matching lines @@
     return new JS.Method(js.call('$_SYMBOL.iterator'), js.call(
         'function() { return new dart.JsIterator(this.#); }',
         [_emitMemberName('iterator', type: t)]));
   }
 
   /// 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, String jsPeerName) {
+      List<FieldDeclaration> fields, List<MethodDeclaration> methods,
+      String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
     body.add(new JS.ClassDeclaration(cls));
 
     // TODO(jmesserly): we should really just extend native Array.
     if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
       body.add(js.statement('dart.setBaseClass(#, dart.global.#);', [
         classElem.name,
         _propertyName(jsPeerName)
       ]));
@@ skipping 21 matching lines @@
     // Instance fields, if they override getter/setter pairs
     for (FieldDeclaration member in fields) {
       for (VariableDeclaration fieldDecl in member.fields.variables) {
         var field = fieldDecl.element;
         if (_fieldsNeedingStorage.contains(field)) {
           body.add(_overrideField(field));
         }
       }
     }
 
+    {

[vsm, 2015/05/18 17:35:10]

Add comment to this block ... e.g, // Emit signatures

[Leaf, 2015/05/19 00:02:21]

Done.

+      var tStatics = [];
+      var tMethods = [];
+      var sNames = [];
+      var cType = classElem.type;
+      for (MethodDeclaration node in methods) {
+        if (!(node.isSetter || node.isGetter || node.isAbstract)) {
+          var name = node.name.name;
+          var element = node.element;
+          var unary = node.parameters.parameters.isEmpty;
+          var memberName = _emitMemberName(name,
+              type: cType, unary: unary, isStatic: node.isStatic);
+          var property =
+              new JS.Property(memberName, _emitTypeName(element.type));
+          if (node.isStatic) {
+            tStatics.add(property);
+            sNames.add(memberName);
+          } else tMethods.add(property);
+        }
+      }
+      build(name, elements) {
+        var o =
+            new JS.ObjectInitializer(elements, vertical: elements.length > 1);
+        var e = js.call('() => #', o);
+        var p = new JS.Property(_propertyName(name), e);
+        return p;
+      }
+      var sigFields = [];
+      if (!tMethods.isEmpty) sigFields.add(build('methods', tMethods));
+      if (!tStatics.isEmpty) {
+        assert(!sNames.isEmpty);
+        var aNames = new JS.Property(
+            _propertyName('names'), new JS.ArrayInitializer(sNames));
+        sigFields.add(build('statics', tStatics));
+        sigFields.add(aNames);
+      }
+
+      var sig = new JS.ObjectInitializer(sigFields);
+      var classExpr = new JS.Identifier(name);
+      body.add(js.statement('dart.setSignature(#, #);', [classExpr, sig]));
+    }
+
     return _statement(body);
   }
 
   JS.Statement _overrideField(FieldElement e) {
     var cls = e.enclosingElement;
     return js.statement('dart.virtualField(#, #)', [
       cls.name,
       _emitMemberName(e.name, type: cls.type)
     ]);
   }
@@ skipping 317 matching lines @@
     if (node.isGetter || node.isSetter) {
       // Add these later so we can use getter/setter syntax.
       _properties.add(node);
       return null;
     }
 
     var body = <JS.Statement>[];
     _flushLibraryProperties(body);
 
     var name = node.name.name;
-    body.add(js.comment('Function $name: ${node.element.type}'));
 
-    body.add(new JS.FunctionDeclaration(
-        new JS.Identifier(name), _visit(node.functionExpression)));
+    var id = new JS.Identifier(name);
+    body.add(new JS.FunctionDeclaration(id, _visit(node.functionExpression)));
+    body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
+        .toStatement());
 
     if (isPublic(name)) _addExport(name);
     return _statement(body);
   }
 
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
     return new JS.Method(_propertyName(name), _visit(node.functionExpression),
         isGetter: node.isGetter, isSetter: node.isSetter);
   }
 
+  bool _executesAtTopLevel(AstNode node) {
+    var ancestor = node.getAncestor((n) => n is FunctionBody ||
+        (n is FieldDeclaration && n.staticKeyword == null) ||
+        (n is ConstructorDeclaration && n.constKeyword == null));
+    return ancestor == null;
+  }
+
+  bool _typeIsLoaded(DartType type) {
+    if (type is FunctionType && (type.name == '' || type.name == null)) {
+      return (_typeIsLoaded(type.returnType) &&
+          type.optionalParameterTypes.every(_typeIsLoaded) &&
+          type.namedParameterTypes.values.every(_typeIsLoaded) &&
+          type.normalParameterTypes.every(_typeIsLoaded));
+    }
+    if (type.isDynamic || type.isVoid || type.isBottom) return true;
+    return _loader.isLoaded(type.element);
+  }
+
+  JS.Expression _emitFunctionTagged(JS.Expression clos, DartType type,
+      {topLevel: false}) {
+    var name = type.name;
+    var lazy = topLevel && !_typeIsLoaded(type);

[Jennifer Messerly, 2015/05/19 18:19:01]

Definitely not something that needs to be changed for this CL, but...

The goal of Loader was to avoid duplication like this, where you need to capture
the same dependencies twice, once in a boolean expression (_typeIsLoaded), and
again when emitting (_emitFunctionTypeParts).

An alternative design would remove this function, and have it work more like:

    if (topLevel) _loader.startTopLevel();
    ... emit stuff ...
    bool lazy = topLevel && _loader.finishTopLevel();

That won't work right now, because startTopLevel requires an argument, which is
what Element we're emitting. there's no notion of "anonymous" top level code.

Interestingly, this suggests another design. Right now, if we want to make
something lazy, it's handled here. But instead, we could just say the whole
top-level element needs to be lazy. That way, if the element ends up lazy for
some other reason, we won't add a nested lazy here too. The alternative design
would then be:

    var e = _loader.currentElement;
    if (topLevel) _loader.startTopLevel(e);
    ... emit stuff ...
    if (topLevel) _loader.finishTopLevel(e);

And then the existing laziness logic for the "currentElement" will handle it.
e.g. a field will become a lazy property.
(note: looking at it now, it seems start/finishTopLevel don't really need the
element. They assert that it's the current element anyway.)

[Leaf, 2015/05/19 22:31:12]

Acknowledged.

+
+    if (type is FunctionType && (name == '' || name == null)) {
+      if (type.returnType.isDynamic &&
+          type.optionalParameterTypes.isEmpty &&
+          type.namedParameterTypes.isEmpty &&
+          type.normalParameterTypes.every((t) => t.isDynamic)) {
+        return js.call('dart.fn(#)', [clos]);
+      }
+      if (lazy) {
+        return js.call('dart.fn(#, () => #)', [clos, _emitTypeName(type)]);
+      }
+      return js.call('dart.fn(#, #)', [clos, _emitFunctionTypeParts(type)]);
+    }
+    throw 'Function has non function type: $type';
+  }
+
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
     var parent = node.parent;
     if (parent is FunctionDeclaration &&
         parent.parent is! FunctionDeclarationStatement) {
       return new JS.Fun(params, _visit(node.body));
     } else {
       String code;
       AstNode body;
       var nodeBody = node.body;
       if (nodeBody is ExpressionFunctionBody) {
         code = '(#) => #';
         body = nodeBody.expression;
       } else {
         code = '(#) => { #; }';
         body = nodeBody;
       }
-      return js.call(code, [params, _visit(body)]);
+      var clos = js.call(code, [params, _visit(body)]);
+      if (parent.parent is! FunctionDeclarationStatement) {

[Jennifer Messerly, 2015/05/19 18:19:01]

maybe pull out `parent.parent is! FunctionDeclarationStatement` into a local
since we use it twice?


var inFunctionStatement = parent.parent is FunctionDeclarationStatement;
...

if (!inFunctionStatement) { ... }

sort of related
https://github.com/dart-lang/dev_compiler/issues/143#issuecomment-103614170

[Leaf, 2015/05/19 22:31:13]

Done.

+        var type = getStaticType(node);
+        return _emitFunctionTagged(clos, type,
+            topLevel: _executesAtTopLevel(node));
+      }
+      return clos;
     }
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
 
     // Use an => function to bind this.
     // Technically we only need to do this if the function actually closes over
     // `this`, but it seems harmless enough to just do it always.
     var name = new JS.Identifier(func.name.name);
     return new JS.Block([
-      js.comment("// Function ${func.name.name}: ${func.element.type}\n"),
-      js.statement('let # = #;', [name, _visit(func.functionExpression)])
+      js.statement('let # = #;', [name, _visit(func.functionExpression)]),
+      _emitFunctionTagged(name, func.element.type).toStatement()
     ]);
   }
 
   /// Writes a simple identifier. This can handle implicit `this` as well as
   /// going through the qualified library name if necessary.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
@@ skipping 70 matching lines @@
   JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = new JS.LiteralString(name);
       var value = _emitTypeName(type);
       properties.add(new JS.Property(key, value));
     });
     return new JS.ObjectInitializer(properties);
   }
 
+  List<JS.Expression> _emitFunctionTypeParts(FunctionType type) {
+    var returnType = type.returnType;
+    var parameterTypes = type.normalParameterTypes;
+    var optionalTypes = type.optionalParameterTypes;
+    var namedTypes = type.namedParameterTypes;
+    var rt = _emitTypeName(returnType);
+    var ra = _emitTypeNames(parameterTypes);
+    if (!namedTypes.isEmpty) {
+      assert(optionalTypes.isEmpty);
+      var na = _emitTypeProperties(namedTypes);
+      return [rt, ra, na];
+    }
+    if (!optionalTypes.isEmpty) {
+      assert(namedTypes.isEmpty);
+      var oa = _emitTypeNames(optionalTypes);
+      return [rt, ra, oa];
+    }
+    return [rt, ra];
+  }
+
   /// Emits a Dart [type] into code.
   ///
   /// If [lowerTypedef] is set, a typedef will be expanded as if it were a
   /// function type. Similarly if [lowerGeneric] is set, the `List$()` form
   /// will be used instead of `List`. These flags are used when generating
   /// the definitions for typedefs and generic types, respectively.
   JS.Expression _emitTypeName(DartType type,
       {bool lowerTypedef: false, bool lowerGeneric: false}) {
 
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
       return js.call('dart.dynamic');
+    } else if (type.isBottom) {
+      return js.call('dart.bottom');
     }
 
     _loader.declareBeforeUse(type.element);
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
     var element = type.element;
-    if (name == '' || lowerTypedef) {
-      var fnType = type as FunctionType;
-      var returnType = fnType.returnType;
-      var parameterTypes = fnType.normalParameterTypes;
-      var optionalTypes = fnType.optionalParameterTypes;
-      var namedTypes = fnType.namedParameterTypes;
-      if (namedTypes.isEmpty) {
-        if (optionalTypes.isEmpty) {
-          return js.call('dart.functionType(#, #)', [
-            _emitTypeName(returnType),
-            _emitTypeNames(parameterTypes)
-          ]);
-        } else {
-          return js.call('dart.functionType(#, #, #)', [
-            _emitTypeName(returnType),
-            _emitTypeNames(parameterTypes),
-            _emitTypeNames(optionalTypes)
-          ]);
-        }
-      } else {
-        assert(optionalTypes.isEmpty);
-        return js.call('dart.functionType(#, #, #)', [
-          _emitTypeName(returnType),
-          _emitTypeNames(parameterTypes),
-          _emitTypeProperties(namedTypes)
-        ]);
-      }
+    if (name == '' || name == null || lowerTypedef) {
+      var parts = _emitFunctionTypeParts(type as FunctionType);
+      return js.call('dart.functionType(#)', [parts]);
     }
 
     if (type is TypeParameterType) {
       return new JS.Identifier(name);
     }
 
     if (type is ParameterizedType) {
       var args = type.typeArguments;
       var isCurrentClass =
           args.isNotEmpty && _loader.isCurrentElement(type.element);
@@ skipping 1346 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);
 }