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));
         }
       }
     }
 
+    // Emit the signature on the class recording the runtime type information
+    {
+      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);
+
+    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) {
+    var inDecl = parent is FunctionDeclaration;
+    var inStmt = parent.parent is FunctionDeclarationStatement;
+    if (inDecl && !inStmt) {
       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 (!inStmt) {
+        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 77 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);
 }