Work in progress: changes to interpretation

frog/gen.dart

 // Copyright (c) 2012, 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 38 matching lines @@
     // These are essentially always used through literals - just include them
     world.numImplType.markUsed();
     world.stringImplType.markUsed();
 
     // Only include isolate-specific code if isolates are used.
     if (world.corelib.types['Isolate'].isUsed
         || world.coreimpl.types['ReceivePortImpl'].isUsed) {
 
       // Generate callbacks from JS to isolate code if needed
       if (corejs.useWrap0 || corejs.useWrap1) {
-        genMethod(world.coreimpl.types['IsolateContext'].getMember('eval'));
-        genMethod(world.coreimpl.types['EventLoop'].getMember('run'));
+        invokeMethod(world.coreimpl.types['IsolateContext'].getMember('eval'));
+        invokeMethod(world.coreimpl.types['EventLoop'].getMember('run'));
       }
 
       corejs.useIsolates = true;
       MethodMember isolateMain =
         world.coreimpl.lookup('startRootIsolate', main.span);
       var isolateMainTarget = new TypeValue(world.coreimpl.topType, main.span);
       mainCall = isolateMain.invoke(metaGen, null, isolateMainTarget,
           new Arguments(null, [main._get(metaGen, main.definition, null)]));
     }
 
@@ skipping 24 matching lines @@
     type.markUsed();
     type.isTested = true;
     // (e.g. Math, console, process)
     type.isTested = !type.isTop && !(type.isNative &&
         type.members.getValues().every((m) => m.isStatic && !m.isFactory));
     final members = new List.from(type.members.getValues());
     members.addAll(type.constructors.getValues());
     type.factories.forEach((f) => members.add(f));
     for (var member in members) {
       if (member is PropertyMember) {
-        if (member.getter != null) genMethod(member.getter);
-        if (member.setter != null) genMethod(member.setter);
+        if (member.getter != null) invokeMethod(member.getter);
+        if (member.setter != null) invokeMethod(member.setter);
       }
 
-      if (member is MethodMember) genMethod(member);
+      if (member is MethodMember) invokeMethod(member);
     }
   }
 
   void writeAllDynamicStubs(List<Library> libs) =>
     getAllTypes(libs).forEach((Type type) {
       if (type.isClass || type.isFunction) _writeDynamicStubs(type);
     });
 
   List<Type> getAllTypes(List<Library> libs) {
     List<Type> types = <Type>[];
@@ skipping 99 matching lines @@
         writer.comment('// ********** Code for ${type.jsname} **************');
         _writeDynamicStubs(type);
       }
       // Type check functions for builtin JS types
       if (type.typeCheckCode != null) {
         writer.writeln(type.typeCheckCode);
       }
     }
   }
 
-  genMethod(Member meth, [MethodGenerator enclosingMethod=null]) {
-    if (!meth.isGenerated && !meth.isAbstract && meth.definition != null) {
-      new MethodGenerator(meth, enclosingMethod).run();
+  Type invokeMethod(Member method, [Value target, Arguments args]) {
+    if (method.isAbstract || method.definition == null) {
+      return method.returnType;
     }
+
+    var s = method.specializer;
+    if (s == null) {
+      s = new MethodSpecializer(method);
+    }
+    return s.run(target, args);
   }
 
   String _prototypeOf(Type type, String name) {
     if (type.isSingletonNative) {
       // e.g. window.console.log$1
       return '${type.jsname}.$name';
     } else if (type.isHiddenNativeType) {
       corejs.ensureDynamicProto();
       _usedDynamicDispatchOnType(type);
       return '\$dynamic("$name").${type.definition.nativeType.name}';
@@ skipping 123 matching lines @@
 
     if (type.isTop) {
       // no preludes for top type
     } else if (type.constructors.length == 0) {
       if (!type.isNative) {
         // TODO(jimhug): More guards to guarantee staticness
         writer.writeln('function ${type.jsname}() {}');
       }
     } else {
       Member standardConstructor = type.constructors[''];
-      if (standardConstructor == null ||
-          standardConstructor.generator == null) {
+      if (standardConstructor == null || !standardConstructor.isUsed) {
         if (!type.isNative) {
           writer.writeln('function ${type.jsname}() {}');
         }
       } else {
         standardConstructor.generator.writeDefinition(writer, null);
       }
 
       for (var c in type.constructors.getValues()) {
-        if (c.generator != null && c != standardConstructor) {
+        if (c.isUsed && c != standardConstructor) {
           c.generator.writeDefinition(writer, null);
         }
       }
     }
 
     // Concrete types (like List<String>) will have this already defined on
     // their prototype from the generic type (like List)
     if (type is! ConcreteType) {
       _maybeIsTest(type, type);
     }
@@ skipping 55 matching lines @@
    *  }
    *
    * The factory method and static member are generated something like this:
    *    var lib_Float32Array = {};
    *    lib_Float32Array.Float32Array$factory = ... ;
    *    lib_Float32Array._construct = ... ;
    *
    * This predicate determines when we need to define lib_Float32Array.
    */
   _typeNeedsHolderForStaticMethods(Type type) {
-    for (var member in type.members.getValues()) {
-      if (member.isMethod) {
-        if (member.isConstructor || member.isStatic) {
-          if (member.isGenerated) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
+    return type.members.getValues().some(
+        (m) => m.isUsed && m.isMethod && (m.isConstructor || m.isStatic));
   }
 
   /**
    * Generates the $inheritsMembers function when it's first used.
    * This is used to mix in specialized generic members from the base class.
    */
   _ensureInheritMembersHelper() {
     if (_mixins != null) return;
     _mixins = new CodeWriter();
     _mixins.comment('// ********** Generic Type Inheritance **************');
@@ skipping 69 matching lines @@
       }
       if (property.setter != null) {
         writer.writeln(
           'set: ${property.declaringType.jsname}.prototype.${property.setter.jsname}');
       }
       writer.exitBlock('});');
     }
   }
 
   _writeMethod(Member m) {
-    if (m.generator != null) {
+    if (m.isUsed) {
       m.generator.writeDefinition(writer, null);
     } else if (m is MethodMember && m.isNative
         && m._providePropertySyntax && !m._provideFieldSyntax) {
       MethodGenerator._maybeGenerateBoundGetter(m, writer);
     }
   }
 
   writeGlobals() {
     if (globals.length > 0) {
       writer.comment('//  ********** Globals **************');
@@ skipping 166 matching lines @@
     if (x.span == null) return 1;
     if (y.span == null) return -1;
 
     // If that fails, compare by name.
     return x.name.compareTo(y.name);
   }
 }
 
 
 /**
- * A naive code generator for Dart.
+ * When inferring types, this will support potentially creating multiple
+ * copies of a method with different signatures. We don't implement that yet,
+ * though. Right now it's just a way of guarding against recursive invokes
+ * and tracking [option.inferTypes] specific state for a method.
  */
+// TODO(jmesserly): better name for this and MethodGenerator? (Perhaps
+// this should be named MethodGenerator and the other one should be
+// MethodInterpreter or something like that.)
+class MethodSpecializer {
+  final Member method;
+  final MethodGenerator enclosingMethod;
+
+  // These are used to track what inferred types are assumed by the generated
+  // code. Eventually we may want to use this as a key and generate multiple
+  // typed copies of a method. However that needs good heuristics to avoid
+  // making the code too big.
+  Value _thisObject;
+  List<VariableValue> _arguments;
+  int _evalCount = 0;
+
+  MethodGenerator generator;
+
+  MethodSpecializer(this.method, [this.enclosingMethod]) {
+    assert(method.specializer === null);
+    // TODO(jmesserly): I don't like side effects from constructors, but
+    // otherwise we rely on our callers to maintain this invariant which isn't
+    // great either.
+    method.specializer = this;
+    reset();
+  }
+
+  reset() {
+    _thisObject = new VariableValue(method.declaringType, 'this', null);
+    _arguments = method.parameters.map(
+        (p) => new VariableValue(p.type, p.name, p.span));
+  }
+
+  // TODO(jmesserly): Should this be renamed invoke?
+  // Also our caller has already taken care of named/missing args, but that's
+  // probably not what we want. Instead that could be handled here, and we
+  // could return a Value that performs the method call. (In other words,
+  // absorb some of MethodMember.invoke's current implementation.)
+  Type run([Value target, Arguments args]) {
+    method.markUsed();
+
+    // If this is the first time we've seen this call, or the argument types are
+    // now different, we'll need to interpret the method body.
+    bool shouldEval = _evalCount == 0;
+    bool infer = options.inferTypes && _evalCount <= options.maxInferenceCalls;
+
+    // Unless type inference is on, ignore passed in target & arg types.
+    if (infer) {
+      // TODO(jmesserly): should unify the target type too!
+      List<Value> argValues;
+      if (args == null) {
+        // TODO(jmesserly): we should always be passing in arguments
+        argValues = method.parameters.map(
+            (p) => new Value(p.type, p.name, p.span));
+      } else {
+        argValues = args.values;
+      }
+
+      for (int i = 0; i < _arguments.length; i++) {
+        var orig = _arguments[i].value;
+        var updated = Value.union(orig, argValues[i]);
+        if (updated !== orig) {
+          _arguments[i] = _arguments[i].replaceValue(updated);
+          shouldEval = true;
+        }
+      }
+    }
+
+    if (shouldEval) {
+      _evalCount++;
+
+      if (infer && _evalCount > options.maxInferenceCalls) {
+        // If we've tried too many times and haven't converged, rerun without
+        // inference.
+        world.info('inference failed to converge for method "${method.name}"',
+            method.span);
+
+        // Discard inferred things so we do a fresh run.
+        reset();
+      }
+
+      // Note: this might replace a generator from higher up on our call stack,
+      // if we're calling this method recursively (which is rather common, e.g.
+      // toString methods are potentially recursive). That's okay: the later
+      // generator will have collected more type info, so let it win.
+      // (Eventually we'll have some specialization, and key these off of the
+      // input types.)
+      generator = new MethodGenerator(method, enclosingMethod);
+      generator.evalBody(_thisObject, new Arguments(null, _arguments));
+    }
+
+    return generator._inferResult();
+  }
+}
+
+
+/** A code generator and abstract interpreter for Dart function/method. */
 class MethodGenerator implements TreeVisitor {
-  Member method;
+  final Member method;
+  final MethodGenerator enclosingMethod;
   CodeWriter writer;
   BlockScope _scope;
-  MethodGenerator enclosingMethod;
   bool needsThis;
   List<String> _paramCode;
 
   // TODO(jmesserly): if we knew temps were always used like a stack, we could
   // reduce the overhead here.
   List<String> _freeTemps;
   Set<String> _usedTemps;
 
   /**
    * The set of variables that this lambda closes that need to capture
    * with Function.prototype.bind. This is any variable that lives inside a
    * reentrant block scope (e.g. loop bodies).
    *
    * This field is null if we don't need to track this.
    */
   Set<String> captures;
 
+  /** The inferred result type. */
+  Value _inferredResult;
   CounterLog counters;
 
-  MethodGenerator(this.method, this.enclosingMethod)
+  MethodGenerator(this.method, [this.enclosingMethod])
       : writer = new CodeWriter(), needsThis = false {
     if (enclosingMethod != null) {
       _scope = new BlockScope(this, enclosingMethod._scope, method.definition);
       captures = new Set();
     } else {
       _scope = new BlockScope(this, null, method.definition);
     }
     _usedTemps = new Set();
     _freeTemps = [];
     counters = world.counters;
   }
 
+  // TODO(jmesserly): do we need anything else here? (e.g. do we need to replace
+  // the scope with an empty scope so variables don't leak?)
+  Value evalExpression(Expression expr) => expr.visit(this);
+
   Library get library() => method.library;
 
   // TODO(jimhug): Where does this really belong?
   MemberSet findMembers(String name) {
     return library._findMembers(name);
   }
 
   bool get isClosure() => (enclosingMethod != null);
 
   bool get isStatic() => method.isStatic;
@@ skipping 29 matching lines @@
     /*
     if (_usedTemps.remove(value.code)) {
       _freeTemps.add(value.code);
     } else {
       world.internalError(
         'tried to free unused value or non-temp "${value.code}"');
     }
     */
   }
 
-  run() {
-    if (method.isGenerated) return;
+  Type _inferResult() {
+    if (method.isNative || !options.inferTypes) {
+      // If it's a native, use the return type.
+      var t = method.returnType;
+      if (t.isBool && (method.library.isCore || method.library.isCoreImpl)) {
+        // We trust our core libraries not to return null from bools.
+        // I hope this trust is well placed!
+        t = world.nonNullBool;
+      }
+      return t;
+    }
 
-    // This avoids any attempts to infer across recursion.
-    method.isGenerated = true;
-    method.generator = this;
+    if (_inferredResult == null) {
+      // Handle the implicit 'return null;'
+      // TODO(jmesserly): this needs to be added in more cases, e.g. if there
+      // is a "return" statement in one control flow path but not another
+      // path.
+      _inferredResult = Value.fromNull(null);
+    }
+    return _inferredResult.type;
+  }
 
-    // Create most generic possible call for this method.
-    var thisObject;
-    if (method.isConstructor) {
-      thisObject = new ObjectValue(false, method.declaringType, method.span);
-      thisObject.initFields();
-    } else {
-      thisObject = new Value(method.declaringType, 'this', null);
-    }
-    var values = [];
-    for (var p in method.parameters) {
-      values.add(new Value(p.type, p.name, null));
-    }
-    var args = new Arguments(null, values);
-
-    evalBody(thisObject, args);
-
-    if (method.definition.nativeBody != null) {
+  _evalNativeBody() {
+    // TODO: the .dynamic here is annoying
+    var nativeBody = method.definition.dynamic.nativeBody;
+    if (nativeBody != null) {
       // Throw away the code--it was just used for tree shaking purposes.
-      writer = new CodeWriter();
-      if (method.definition.nativeBody == '') {
-        method.generator = null;
+      if (nativeBody == '') {
+        // Set this to null so we don't try to write code.
+        writer = null;
       } else {
         _paramCode = map(method.parameters, (p) => p.name);
-        writer.write(method.definition.nativeBody);
+        writer = new CodeWriter();
+        writer.write(nativeBody);
       }
     }
   }
 
+  writeDefinition(CodeWriter defWriter, LambdaExpression lambda/*=null*/) {
+    // No need to write anything for natives with no native body.
+    if (writer == null) return;
 
-  writeDefinition(CodeWriter defWriter, LambdaExpression lambda/*=null*/) {
     // To implement block scope: capture any variables we need to.
     var paramCode = _paramCode;
     var names = null;
     if (captures != null && captures.length > 0) {
       names = new List.from(captures);
       names.sort((x, y) => x.compareTo(y));
       // Prepend these as extra parameters. We'll bind them below.
       paramCode = new List.from(names);
       paramCode.addAll(_paramCode);
     }
@@ skipping 125 matching lines @@
     var field = method.declaringType.getMember(name);
     if (field == null) {
       world.error('bad initializer - no matching field', span);
     }
     if (!field.isField) {
       world.error('"this.${name}" does not refer to a field', span);
     }
     return newObject.setField(field, value, duringInit: true);
   }
 
-  evalBody(Value newObject, Arguments args) {
+  void evalBody(thisObject, Arguments args) {
+    if (method.isConstructor && thisObject is! ObjectValue) {
+      // TODO(jmesserly): fix how contructors interact...
+      thisObject = new ObjectValue(false, method.declaringType, method.span);
+      thisObject.initFields();
+    }
+
     bool fieldsSet = false;
-    if (method.isNative && method.isConstructor && newObject is ObjectValue) {
-      newObject.dynamic.seenNativeInitializer = true;
+    if (method.isNative && method.isConstructor) {
+      thisObject.dynamic.seenNativeInitializer = true;
     }
     // Collects parameters for writing signature in the future.
     _paramCode = [];
     for (int i = 0; i < method.parameters.length; i++) {
       var p = method.parameters[i];
       Value currentArg = null;
-      // TODO(jimhug): bareCount is O(N)
       if (i < args.bareCount) {
         currentArg = args.values[i];
       } else {
-        // Handle named or missing arguments
+        // TODO(jmesserly): right now we're evaluating named/missing args on
+        // the call site side. That should probably move into here.
         currentArg = args.getValue(p.name);
         if (currentArg === null) {
           // Ensure default value for param has been generated
-          p.genValue(method, method.generator);
+          p.genValue(method, this);
           currentArg = p.value;
         }
       }
 
       if (p.isInitializer) {
         _paramCode.add(p.name);
         fieldsSet = true;
-        _initField(newObject, p.name, currentArg, p.definition.span);
+        _initField(thisObject, p.name, currentArg, p.definition.span);
       } else {
         var paramValue = _scope.declareParameter(p);
         _paramCode.add(paramValue.code);
-        if (newObject != null && newObject.isConst) {
+        if (thisObject != null && thisObject.isConst) {
           _scope.assign(p.name, currentArg.convertTo(this, p.type));
         }
       }
     }
 
     var initializerCall = null;
-    final declaredInitializers = method.definition.initializers;
+    var methodDef = method.definition;
+    final declaredInitializers = methodDef.initializers;
     if (declaredInitializers != null) {
       for (var init in declaredInitializers) {
         if (init is CallExpression) {
           if (initializerCall != null) {
             world.error('only one initializer redirecting call is allowed',
                 init.span);
           }
           initializerCall = init;
         } else if (init is BinaryExpression
             && TokenKind.kindFromAssign(init.op.kind) == 0) {
           var left = init.x;
           if (!(left is DotExpression && left.self is ThisExpression
               || left is VarExpression)) {
             world.error('invalid left side of initializer', left.span);
             continue;
           }
           // TODO(jmesserly): eval right side of initializers in static
           // context, so "this." is not in scope
           var initValue = visitValue(init.y);
           fieldsSet = true;
-          _initField(newObject, left.name.name, initValue, left.span);
+          _initField(thisObject, left.name.name, initValue, left.span);
         } else {
           world.error('invalid initializer', init.span);
         }
       }
     }
 
     if (method.isConstructor && initializerCall == null && !method.isNative) {
       var parentType = method.declaringType.parent;
       if (parentType != null && !parentType.isObject) {
         // TODO(jmesserly): we could omit this if all supertypes are using
         // default constructors.
         initializerCall = new CallExpression(
             new SuperExpression(method.span), [], method.span);
       }
     }
 
-    if (method.isConstructor && newObject is ObjectValue) {
-      var fields = newObject.dynamic.fields;
+    if (method.isConstructor && thisObject is ObjectValue) {
+      var fields = thisObject.dynamic.fields;
       for (var field in fields.getKeys()) {
         var value = fields[field];
         if (value !== null) {
           writer.writeln('this.${field.jsname} = ${value.code};');
         }
       }
     }
 
     // TODO(jimhug): Doing this call last does not match spec.
     if (initializerCall != null) {
-      evalInitializerCall(newObject, initializerCall, fieldsSet);
+      evalInitializerCall(thisObject, initializerCall, fieldsSet);
     }
 
-    if (method.isConstructor && newObject !== null && newObject.isConst) {
-      newObject.validateInitialized(method.span);
+    if (method.isConstructor && thisObject !== null && thisObject.isConst) {
+      thisObject.validateInitialized(method.span);
     } else if (method.isConstructor) {
-      var fields = newObject.dynamic.fields;
+      var fields = thisObject.dynamic.fields;
       for (var field in fields.getKeys()) {
         var value = fields[field];
         if (value === null && field.isFinal &&
             field.declaringType == method.declaringType &&
-            !newObject.dynamic.seenNativeInitializer) {
+            !thisObject.dynamic.seenNativeInitializer) {
           world.error('uninitialized final field "${field.name}"',
             field.span, method.span);
         }
       }
     }
 
-    var body = method.definition.body;
+    var body = methodDef.body;
 
     if (body === null) {
       // TODO(jimhug): Move check into resolve on method.
       if (!method.isConstructor && !method.isNative) {
         world.error('unexpected empty body for ${method.name}',
           method.definition.span);
       }
     } else {
       visitStatementsInBlock(body);
     }
+
+    _evalNativeBody();
   }
 
   evalInitializerCall(ObjectValue newObject, CallExpression node,
       [bool fieldsSet = false]) {
     String contructorName = '';
     var targetExp = node.target;
     if (targetExp is DotExpression) {
       DotExpression dot = targetExp;
       targetExp = dot.self;
       contructorName = dot.name.name;
@@ skipping 27 matching lines @@
     while (other != null) {
       if (other == method) {
         world.error('initialization cycle', node.span);
         break;
       }
       other = other.initDelegate;
     }
 
     var newArgs = _makeArgs(node.arguments);
     // ???? wacky stuff ????
-    world.gen.genMethod(m);
+    world.gen.invokeMethod(m);
 
     m._evalConstConstructor(newObject, newArgs);
 
     if (!newObject.isConst) {
       var value = m.invoke(this, node, target, newArgs);
       if (target.type != world.objectType) {
         // No need to actually call Object's empty super constructor.
         writer.writeln('${value.code};');
       }
     }
@@ skipping 214 matching lines @@
     writer.writeln(';');
     return false;
 
   }
 
   bool visitFunctionDefinition(FunctionDefinition node) {
     var meth = _makeLambdaMethod(node.name.name, node);
     var funcValue = _scope.create(meth.name, meth.functionType,
         method.definition.span, isFinal:true);
 
-    world.gen.genMethod(meth, this);
+    new MethodSpecializer(meth, this).run();
     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) {
       // This is essentially "return null".
-      // It can't issue a warning because every type is nullable.
+      // TODO(jmesserly): this should be a warning in non-void methods
       writer.writeln('return;');
+      _inferredResult = Value.union(_inferredResult, Value.fromNull(null));
     } else {
       if (method.isConstructor) {
         world.error('return of value not allowed from constructor', node.span);
       }
       var value = visitTypedValue(node.value, method.returnType);
+      _inferredResult = Value.union(_inferredResult, value);
       writer.writeln('return ${value.code};');
     }
     return true;
   }
 
   bool visitThrowStatement(ThrowStatement node) {
     // Dart allows throwing anything, just like JS
     if (node.value != null) {
       var value = visitValue(node.value);
       // Ensure that we generate a toString() method for things that we throw
@@ skipping 59 matching lines @@
     }
     return true;
   }
 
   bool visitIfStatement(IfStatement node) {
     var test = visitBool(node.test);
     writer.write('if (${test.code}) ');
     var exit1 = node.trueBranch.visit(this);
     if (node.falseBranch != null) {
       writer.write('else ');
-      if (node.falseBranch.visit(this) && exit1) {
-        return true;
-      }
+      var exit2 = node.falseBranch.visit(this);
+      return exit1 && exit2;
     }
     return false;
   }
 
   bool visitWhileStatement(WhileStatement node) {
     var test = visitBool(node.test);
     writer.write('while (${test.code}) ');
     _visitLoop(node, () {
       node.body.visit(this);
     });
@@ skipping 353 matching lines @@
       return new ThisValue(method.declaringType, 'this',
           node != null ? node.span : null);
     }
   }
 
   // ******************* Expressions *******************
   visitLambdaExpression(LambdaExpression node) {
     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,
+      // Note: create a block scope for the lambda's name to go into. This keeps
+      // it from leaking into our current scope, and also allows the lambda's
+      // parameters to shadow it.
+      _pushBlock(node);
+      _scope.create(name, meth.functionType, meth.definition.span,
           isFinal:true);
-      lambdaGen._pushBlock(node);
     }
-    lambdaGen.run();
+
+    // TODO(jmesserly): if we wanted to, we could track this as a function
+    // value, and let it be invoked (or not) by whoever uses it.
+    // (Since the number of lambdas is bounded in the program it may be
+    // viable to track them all individually as Values.)
+    new MethodSpecializer(meth, this).run();
+
+    if (name != '') {
+      _popBlock(node);
+    }
 
     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';
@@ skipping 561 matching lines @@
     }
     return new Arguments(nodes, result);
   }
 }
 
 class ReturnKind {
   static final int IGNORE = 1;
   static final int POST = 2;
   static final int PRE = 3;
 }