initial sync*, part of #221

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 1099 matching lines @@
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
     return new JS.Method(
-        _elementMemberName(node.element), new JS.Fun(params, _visit(node.body)),
+        _elementMemberName(node.element), _emitJsFunction(params, node.body),
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
@@ skipping 64 matching lines @@
     }
     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;
-    var inDecl = parent is FunctionDeclaration;
     var inStmt = parent.parent is FunctionDeclarationStatement;
-    if (inDecl && !inStmt) {
-      return new JS.Fun(params, _visit(node.body));
+    if (parent is FunctionDeclaration) {
+      return _emitJsFunction(params, node.body);
     } else {
       String code;
       AstNode body;
       var nodeBody = node.body;
       if (nodeBody is ExpressionFunctionBody) {
         code = '(#) => #';
         body = nodeBody.expression;
       } else {
         code = '(#) => { #; }';
         body = nodeBody;
       }
       var clos = js.call(code, [params, _visit(body)]);
       if (!inStmt) {
         var type = getStaticType(node);
         return _emitFunctionTagged(clos, type,
             topLevel: _executesAtTopLevel(node));
       }
       return clos;
     }
   }
 
+  JS.Fun _emitJsFunction(List<JS.Parameter> params, FunctionBody body) {
+    // TODO(jmesserly): async/async*
+    var syncStar = body.isSynchronous && body.star != null;
+    return new JS.Fun(params, _visit(body), isGenerator: syncStar);
+  }
+
   @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 fn = _visit(func.functionExpression);
+    var jsThis = new _JsThisFinder();
+    fn.accept(jsThis);
+
     var name = new JS.Identifier(func.name.name);
+    JS.Statement declareFn;
+    if (jsThis.found) {
+      declareFn = js.statement('let # = #.bind(this);', [name, fn]);
+    } else {
+      declareFn = new JS.FunctionDeclaration(name, fn);
+    }
+
     return new JS.Block([
-      js.statement('let # = #;', [name, _visit(func.functionExpression)]),
+      declareFn,
       _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) {
@@ skipping 381 matching lines @@
 
   @override
   JS.Statement visitAssertStatement(AssertStatement node) =>
       // TODO(jmesserly): only emit in checked mode.
       js.statement('dart.assert(#);', _visit(node.condition));
 
   @override
   JS.Statement visitReturnStatement(ReturnStatement node) {
     var e = node.expression;
     if (e == null) return new JS.Return();
-    return _visit(e).toReturn();
+    return (_visit(e) as JS.Expression).toReturn();
   }
 
   @override
+  JS.Statement visitYieldStatement(YieldStatement node) {
+    JS.Expression jsExpr = _visit(node.expression);
+    return jsExpr.toYieldStatement(star: node.star != null);
+  }
+
+  @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     for (var v in node.variables.variables) {
       _loader.loadDeclaration(v, v.element);
     }
   }
 
   _addExport(String name) {
     if (!_exports.add(name)) throw 'Duplicate top level name found: $name';
   }
 
@@ skipping 913 matching lines @@
   visitInterpolationExpression(InterpolationExpression node) =>
       _visit(node.expression);
 
   @override
   visitBooleanLiteral(BooleanLiteral node) => js.boolean(node.value);
 
   @override
   JS.Expression visitExpression(Expression node) =>
       _unimplementedCall('Unimplemented ${node.runtimeType}: $node');
 
-  @override
-  JS.Statement visitYieldStatement(YieldStatement node) =>
-      _unimplementedCall('Unimplemented yield: $node').toStatement();
-
   JS.Expression _unimplementedCall(String comment) {
     return js.call('dart.throw_(#)', [js.escapedString(comment)]);
   }
 
   @override
   visitNode(AstNode node) {
     // TODO(jmesserly): verify this is unreachable.
     throw 'Unimplemented ${node.runtimeType}: $node';
   }
 
@@ skipping 202 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);
 }
+
+class _JsThisFinder extends JS.BaseVisitor {
+  bool found = false;
+  visitThis(JS.This node) {
+    found = true;
+  }
+  visitNode(JS.Node node) {
+    if (!found) super.visitNode(node);
+  }
+}