fixes #177, FunctionDeclarationStatement and closing over `this`

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 1050 matching lines @@
     var name = node.name.name;
     return new JS.Method(_propertyName(name), _visit(node.functionExpression),
         isGetter: node.isGetter, isSetter: node.isSetter);
   }
 
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
-    if (node.parent is FunctionDeclaration) {
+    var parent = node.parent;
+    if (parent is FunctionDeclaration &&

[Jennifer Messerly, 2015/05/08 21:49:38]

AST is a little wacky here... parent is a FunctionDeclaration which is a
CompilationUnitMember, even though we aren't at top level. Jumping up to
grandparent lets us figure out which one we really are in.

+        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)]);
     }
   }
 
   @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"),
-      new JS.FunctionDeclaration(name, _visit(func.functionExpression))
+      js.statement('let # = #;', [name, _visit(func.functionExpression)])
     ]);
   }
 
   /// 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 1479 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;