Fixed lambdas that have the same name as one of their parameters/locals

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 663 matching lines @@
   Set<String> captures;
 
   MethodGenerator(this.method, this.enclosingMethod)
       : writer = new CodeWriter(), needsThis = false {
     if (enclosingMethod != null) {
       _scope = new BlockScope(this, enclosingMethod._scope);
       captures = new Set();
     } else {
       _scope = new BlockScope(this, null);
     }
-    // For named lambdas, add the name to this scope so we can call it
-    // recursively.
-    if (enclosingMethod != null && method.name != '') {
-      MethodMember m = method; // lambdas must be MethodMembers
-      _scope.create(m.name, m.functionType, m.definition.span, isFinal:true);
-    }
     _usedTemps = new Set();
     _freeTemps = [];
   }
 
   Library get library() => method.library;
 
   // TODO(jimhug): Where does this really belong?
   MemberSet findMembers(String name) {
     return library._findMembers(name);
   }
@@ skipping 440 matching lines @@
 
   _popBlock() {
     _scope = _scope.parent;
   }
 
   MethodMember _makeLambdaMethod(String name, FunctionDefinition func) {
     var meth = new MethodMember(name, method.declaringType, func);
     meth.isLambda = true;
     meth.enclosingElement = method;
     meth.resolve();
-    world.gen.genMethod(meth, this);
     return meth;
   }
 
   visitBool(Expression node) {
     // Boolean conversions in if/while/do/for/conditions require non-null bool.
 
     // TODO(jmesserly): why do we have this rule? It seems inconsistent with
     // the rest of the type system, and just causes bogus asserts unless all
     // bools are initialized to false.
     return visitValue(node).convertTo(this, world.nonNullBool, node);
@@ skipping 68 matching lines @@
         value = value.convertTo(this, type, node.values[i]);
         writer.write('${val.code} = ${value.code}');
       }
     }
     writer.writeln(';');
     return false;
 
   }
 
   bool visitFunctionDefinition(FunctionDefinition node) {
-    var name = world.toJsIdentifier(node.name.name);

[Jennifer Messerly, 2011/12/05 23:05:11]

MethodMember "jsname" handles this now.

+    var meth = _makeLambdaMethod(node.name.name, node);
+    var funcValue = _scope.create(meth.name, meth.functionType,
+        method.definition.span, isFinal:true);
 
-    var meth = _makeLambdaMethod(name, node);
-
-    // TODO(jimhug): Pass js name into writeDefinition?
-    var funcValue = _scope.create(name, meth.functionType,
-        method.definition.span, isFinal:true);
+    world.gen.genMethod(meth, this);
     meth.generator.writeDefinition(writer, null);
     return false;
   }
 
   /**
    * Returns true indicating that normal control-flow is interrupted by
    * this statement. (This could be a return, break, throw, or continue.)
    */
   bool visitReturnStatement(ReturnStatement node) {
     if (node.value == null) {
@@ skipping 440 matching lines @@
         node != null ? node.span : null, /*needsTemp:*/false);
     } else {
       _checkNonStatic(node);
       return new Value(method.declaringType, 'this', node != null ? node.span : null,
         /*needsTemp:*/false);
     }
   }
 
   // ******************* Expressions *******************
   visitLambdaExpression(LambdaExpression node) {
-    var name = '';
-    if (node.func.name != null) {
-      name = world.toJsIdentifier(node.func.name.name);
+    var name = (node.func.name != null) ? node.func.name.name : '';
+
+    MethodMember meth = _makeLambdaMethod(name, node.func);
+    final lambdaGen = new MethodGenerator(meth, this);
+    if (name != '') {
+      // Note: we don't want to put this in our enclosing scope because the
+      // name shouldn't be visible except inside the lambda. We also don't want
+      // to put the name directly in the lambda's scope because parameters are
+      // allowed to shadow it. So we create an extra scope for it to go into.
+      lambdaGen._scope.create(name, meth.functionType, meth.definition.span,
+          isFinal:true);
+      lambdaGen._pushBlock();

[Jennifer Messerly, 2011/12/05 23:05:11]

no need to pop the scope, for the same reason we don't pop the scope created in
MethodGenerator ctor. There's no child ptr, only parent ptr.

     }
-
-    var meth = _makeLambdaMethod(name, node.func);
+    lambdaGen.run();
 
     var w = new CodeWriter();
     meth.generator.writeDefinition(w, node);
-
     return new Value(meth.functionType, w.text, node.span);
   }
 
   visitCallExpression(CallExpression node) {
     var target;
     var position = node.target;
     var name = ':call';
     if (node.target is DotExpression) {
       DotExpression dot = node.target;
       target = dot.self.visit(this);
@@ skipping 723 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }