dart2dart: Support for inner functions in new IR.

sdk/lib/_internal/compiler/implementation/ir/ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 188 matching lines @@
   // arguments, and what the arguments are.
   final Map<Element, int> variableIndex;
   final List<Element> index2variable;
   final List<ir.Parameter> freeVars;
   final List<ir.Primitive> assignedVars;
 
   ConstExpBuilder constantBuilder;
 
   final List<ConstDeclaration> localConstants;
 
+  FunctionElement currentFunction;
+  final DetectClosureVariables closureLocals;
+
   /// Construct a top-level visitor.
   IrBuilder(TreeElements elements, Compiler compiler, this.sourceFile)
       : returnContinuation = new ir.Continuation.retrn(),
         parameters = <ir.Parameter>[],
         variableIndex = <Element, int>{},
         freeVars = null,
         assignedVars = <ir.Primitive>[],
         index2variable = <Element>[],
         localConstants = <ConstDeclaration>[],
+        closureLocals = new DetectClosureVariables(elements),
         super(elements, compiler) {
           constantBuilder = new ConstExpBuilder(this);
         }
 
   /// Construct a delimited visitor.
   IrBuilder.delimited(IrBuilder parent)
       : sourceFile = parent.sourceFile,
         returnContinuation = parent.returnContinuation,
         parameters = parent.parameters,
         variableIndex = parent.variableIndex,
         freeVars = new List<ir.Parameter>.generate(
             parent.assignedVars.length, (_) => new ir.Parameter(null),
             growable: false),
         assignedVars = new List<ir.Primitive>.generate(
             parent.assignedVars.length, (_) => null),
         index2variable = new List<Element>.from(parent.index2variable),
         constantBuilder = parent.constantBuilder,
         localConstants = parent.localConstants,
+        currentFunction = parent.currentFunction,
+        closureLocals = parent.closureLocals,
         super(parent.elements, parent.compiler);
 
   /**
    * Builds the [ir.FunctionDefinition] for a function element. In case the
    * function uses features that cannot be expressed in the IR, this function
    * returns `null`.
    */
   ir.FunctionDefinition buildFunction(FunctionElement functionElement) {
     return nullIfGiveup(() => buildFunctionInternal(functionElement));
   }
 
   ir.FunctionDefinition buildFunctionInternal(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
+    currentFunction = element;
     ast.FunctionExpression function = element.node;
     assert(function != null);
     assert(!function.modifiers.isExternal);
     assert(elements[function] != null);
 
+    closureLocals.visit(function);
+
     root = current = null;
 
     FunctionSignature signature = element.functionSignature;
-    signature.orderedForEachParameter((parameterElement) {
+    signature.orderedForEachParameter((ParameterElement parameterElement) {
+      // TODO(asgerf): Handle parameters with default values. (Use a ConstExp)
+      if (parameterElement.initializer != null) {
+        giveup(parameterElement.node, 'Function parameter with default value');
+      }
       ir.Parameter parameter = new ir.Parameter(parameterElement);
       parameters.add(parameter);
-      variableIndex[parameterElement] = assignedVars.length;
-      assignedVars.add(parameter);
-      index2variable.add(parameterElement);
+      if (isClosureVariable(parameterElement)) {
+        add(new ir.SetClosureVariable(parameterElement, parameter));
+      } else {
+        variableIndex[parameterElement] = assignedVars.length;
+        assignedVars.add(parameter);
+        index2variable.add(parameterElement);
+      }
     });
 
     visit(function.body);
     ensureReturn(function);
-    return new ir.FunctionDefinition(returnContinuation, parameters, root,
-        localConstants);
+    return new ir.FunctionDefinition(element, returnContinuation, parameters,
+        root, localConstants);
   }
 
   ConstantSystem get constantSystem => compiler.backend.constantSystem;
 
   bool get isOpen => root == null || current != null;
 
   // Plug an expression into the 'hole' in the context being accumulated.  The
   // empty context (just a hole) is represented by root (and current) being
   // null.  Since the hole in the current context is filled by this function,
   // the new hole must be in the newly added expression---which becomes the
@@ skipping 229 matching lines @@
         reachingDefinition.substituteFor(bodyBuilder.freeVars[i]);
       } else {
         condBuilder.assignedVars[i].substituteFor(bodyBuilder.freeVars[i]);
       }
       reachingDefinition.substituteFor(condBuilder.freeVars[i]);
     }
   }
 
   ir.Primitive visitFor(ast.For node) {
     assert(isOpen);
+    // TODO(asgerf): Handle closure variables declared in a for-loop.
+    if (node.initializer is ast.VariableDefinitions) {
+      ast.VariableDefinitions definitions = node.initializer;
+      for (ast.Node definition in definitions.definitions.nodes) {
+        Element element = elements[definition];
+        if (isClosureVariable(element)) {
+          return giveup(definition, 'Closure variable in for loop initializer');
+        }
+      }
+    }
+
     // For loops use three named continuations: the entry to the condition,
     // the entry to the body, and the loop exit (break).  The CPS translation
     // of [[for (initializer; condition; update) body; successor]] is:
     //
     // [[initializer]];
     // let cont loop(x, ...) =
     //     let cont exit() = [[successor]] in
     //     let cont body() = [[body]]; [[update]]; loop(v, ...) in
     //     let prim cond = [[condition]] in
     //     branch cond (body, exit) in
@@ skipping 196 matching lines @@
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         VariableElement element = elements[definition];
         ConstExp value = constantBuilder.visit(definition.arguments.head);
         localConstants.add(new ConstDeclaration(element, value));
       }
     } else {
       for (ast.Node definition in node.definitions.nodes) {
         Element element = elements[definition];
+        ir.Primitive initialValue;
         // Definitions are either SendSets if there is an initializer, or
         // Identifiers if there is no initializer.
         if (definition is ast.SendSet) {
           assert(!definition.arguments.isEmpty);
           assert(definition.arguments.tail.isEmpty);
-          ir.Primitive initialValue = visit(definition.arguments.head);
+          initialValue = visit(definition.arguments.head);
+        } else {
+          assert(definition is ast.Identifier);
+          // The initial value is null.
+          // TODO(kmillikin): Consider pooling constants.
+          initialValue = makePrimConst(constantSystem.createNull());
+          add(new ir.LetPrim(initialValue));
+        }
+        if (isClosureVariable(element)) {
+          add(new ir.SetClosureVariable(element, initialValue,
+                                          isDeclaration: true));
+        } else {
           // In case a primitive was introduced for the initializer expression,
           // use this variable element to help derive a good name for it.
           initialValue.useElementAsHint(element);
           variableIndex[element] = assignedVars.length;
           assignedVars.add(initialValue);
           index2variable.add(element);
-        } else {
-          assert(definition is ast.Identifier);
-          // The initial value is null.
-          // TODO(kmillikin): Consider pooling constants.
-          ir.Constant constant = makePrimConst(constantSystem.createNull());
-          constant.useElementAsHint(element);
-          add(new ir.LetPrim(constant));
-          variableIndex[element] = assignedVars.length;
-          assignedVars.add(constant);
-          index2variable.add(element);
         }
       }
     }
     return null;
   }
 
   // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
   //   where (C', x) = Build(e, C)
   //
   // Return without a subexpression is translated as if it were return null.
@@ skipping 186 matching lines @@
   ir.Primitive visitAssert(ast.Send node) {
     assert(isOpen);
     return giveup(node, 'Assert');
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(isOpen);
     return visit(node.expression);
   }
 
+  ir.Primitive continueWithExpression(ir.Expression build(ir.Continuation k)) {
+    ir.Parameter v = new ir.Parameter(null);
+    ir.Continuation k = new ir.Continuation([v]);
+    ir.Expression expression = build(k);
+    add(new ir.LetCont(k, expression));
+    return v;
+  }
+
   ir.Primitive translateClosureCall(ir.Primitive receiver,
                                     Selector closureSelector,
                                     ast.NodeList arguments) {
     Selector namedCallSelector = new Selector(closureSelector.kind,
                      "call",
                      closureSelector.library,
                      closureSelector.argumentCount,
                      closureSelector.namedArguments);
     List<ir.Primitive> args = arguments.nodes.mapToList(visit, growable:false);
-    ir.Parameter v = new ir.Parameter(null);
-    ir.Continuation k = new ir.Continuation([v]);
-    ir.Expression invoke =
-        new ir.InvokeMethod(receiver, namedCallSelector, k, args);
-    add(new ir.LetCont(k, invoke));
-    return v;
+    return continueWithExpression(
+        (k) => new ir.InvokeMethod(receiver, namedCallSelector, k, args));
   }
 
   ir.Primitive visitClosureSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     ir.Primitive closureTarget;
     if (element == null) {
       closureTarget = visit(node.selector);
+    } else if (isClosureVariable(element)) {
+      closureTarget = new ir.GetClosureVariable(element);
+      add(new ir.LetPrim(closureTarget));
     } else {
       assert(Elements.isLocal(element));
       closureTarget = lookupLocal(element);
     }
     Selector closureSelector = elements.getSelector(node);
     return translateClosureCall(closureTarget, closureSelector,
         node.argumentsNode);
   }
 
   /// If [node] is null, returns this.
@@ skipping 18 matching lines @@
   }
 
   ir.Primitive visitDynamicSend(ast.Send node) {
     assert(isOpen);
     Selector selector = elements.getSelector(node);
     ir.Primitive receiver = visitReceiver(node.receiver);
     List<ir.Primitive> arguments = new List<ir.Primitive>();
     for (ast.Node n in node.arguments) {
       arguments.add(visit(n));
     }
-    ir.Parameter v = new ir.Parameter(null);
-    ir.Continuation k = new ir.Continuation([v]);
-    ir.Expression invoke =
-        createDynamicInvoke(node, selector, receiver, k, arguments);
-    add(new ir.LetCont(k, invoke));
-    return v;
+    return continueWithExpression(
+        (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
   }
 
   _GetterElements translateGetter(ast.Send node, Selector selector) {
     Element element = elements[node];
     ir.Primitive result;
     ir.Primitive receiver;
     ir.Primitive index;
 
     if (Elements.isErroneousElement(element)) {
-      giveup(node, 'Erroneous element on GetterSend');
-      return null;
+      return giveup(node, 'Erroneous element on GetterSend');
     }
 
     if (element != null && element.isConst) {
       // Reference to constant local, top-level or static field
-
       result = translateConstant(node);
+    } else if (isClosureVariable(element)) {
+      result = new ir.GetClosureVariable(element);
+      add(new ir.LetPrim(result));
     } else if (Elements.isLocal(element)) {
       // Reference to local variable
-
       result = lookupLocal(element);
     } else if (element == null ||
                Elements.isInstanceField(element) ||
                Elements.isInstanceMethod(element) ||
                selector.isIndex ||
                node.isSuperCall) {
     // Dynamic dispatch to a getter. Sometimes resolution will suggest a target
     // element, but in these cases we must still emit a dynamic dispatch. The
     // target element may be an instance method in case we are converting a
     // method to a function object.
 
       receiver = visitReceiver(node.receiver);
       List<ir.Primitive> arguments = new List<ir.Primitive>();
       if (selector.isIndex) {
         index = visit(node.arguments.head);
         arguments.add(index);
       }
 
-      ir.Parameter v = new ir.Parameter(null);
-      ir.Continuation k = new ir.Continuation([v]);
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.INDEX);
-      ir.Expression invoke =
-          createDynamicInvoke(node, selector, receiver, k, arguments);
-      add(new ir.LetCont(k, invoke));
-      result = v;
-    } else if (element.isField || element.isGetter ||
-        // Access to a static field or getter (non-static case handled above).
-        // Even if there is only a setter, we compile as if it was a getter,
-        // so the vm can fail at runtime.
-
-        element.isSetter) {
-      ir.Parameter v = new ir.Parameter(null);
-      ir.Continuation k = new ir.Continuation([v]);
+      result = continueWithExpression(
+          (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
+    } else if (element.isField || element.isGetter || element.isSetter) {
+      // Access to a static field or getter (non-static case handled above).
+      // Even if there is only a setter, we compile as if it was a getter,
+      // so the vm can fail at runtime.
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.SETTER);
-      ir.Expression invoke =
-          new ir.InvokeStatic(element, selector, k, []);
-      add(new ir.LetCont(k, invoke));
-      result = v;
+      result = continueWithExpression(
+          (k) => new ir.InvokeStatic(element, selector, k, []));
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // Convert a top-level or static function to a function object.
-
       result = translateConstant(node);
     } else {
       throw "Unexpected SendSet getter: $node, $element";
     }
     return new _GetterElements(
         result: result,index: index, receiver: receiver);
   }
 
   ir.Primitive visitGetterSend(ast.Send node) {
     assert(isOpen);
@@ skipping 145 matching lines @@
       if (type.isMalformed) return giveup(node, "Malformed type for is");
       ir.Primitive receiver = visit(node.receiver);
       ir.IsCheck isCheck = new ir.IsCheck(receiver, type);
       add(new ir.LetPrim(isCheck));
       return node.isIsNotCheck ? buildNegation(isCheck) : isCheck;
     }
     if (op.source == "as") {
       DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
       if (type.isMalformed) return giveup(node, "Malformed type for as");
       ir.Primitive receiver = visit(node.receiver);
-      ir.Parameter v = new ir.Parameter(null);
-      ir.Continuation k = new ir.Continuation([v]);
-      ir.AsCast asCast = new ir.AsCast(receiver, type, k);
-      add(new ir.LetCont(k, asCast));
-      return v;
+      return continueWithExpression(
+          (k) => new ir.AsCast(receiver, type, k));
     }
     return giveup(node);
   }
 
   // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
   //   where (C', xs) = arguments.fold(Build, C)
   ir.Primitive visitStaticSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     // TODO(lry): support constructors / factory calls.
     if (element.isConstructor) return giveup(node, 'StaticSend: constructor');
     // TODO(lry): support foreign functions.
     if (element.isForeign(compiler)) return giveup(node, 'StaticSend: foreign');
     // TODO(lry): for elements that could not be resolved emit code to throw a
     // [NoSuchMethodError].
     if (element.isErroneous) return giveup(node, 'StaticSend: erroneous');
     // TODO(lry): generate IR for object identicality.
     if (element == compiler.identicalFunction) {
       return giveup(node, 'StaticSend: identical');
     }
 
     Selector selector = elements.getSelector(node);
 
     // TODO(lry): support default arguments, need support for locals.
     List<ir.Definition> arguments = node.arguments.mapToList(visit,
                                                              growable:false);
-    ir.Parameter v = new ir.Parameter(null);
-    ir.Continuation k = new ir.Continuation([v]);
-    ir.Expression invoke =
-        new ir.InvokeStatic(element, selector, k, arguments);
-    add(new ir.LetCont(k, invoke));
-    return v;
+    return continueWithExpression(
+        (k) => new ir.InvokeStatic(element, selector, k, arguments));
   }
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(isOpen);
     if (node.isPropertyAccess) {
       return visitGetterSend(node);
     } else {
       return visitDynamicSend(node);
     }
   }
 
   visitTypePrefixSend(ast.Send node) {
     compiler.internalError(node, "visitTypePrefixSend should not be called.");
   }
 
   ir.Primitive visitTypeLiteralSend(ast.Send node) {
     assert(isOpen);
     // If the user is trying to invoke the type literal or variable,
     // it must be treated as a function call.
     if (node.argumentsNode != null) {
-      // TODO(sigurdm): Change this to match proposed semantics of issue #19725.
-      return visitDynamicSend(node);
+      // TODO(sigurdm): Handle this to match proposed semantics of issue #19725.
+      return giveup(node, 'Type literal invoked as function');
     }
 
     DartType type = elements.getTypeLiteralType(node);
     if (type is TypeVariableType) {
       ir.Primitive prim = new ir.ReifyTypeVar(type.element);
       add(new ir.LetPrim(prim));
       return prim;
     } else {
       return translateConstant(node);
     }
   }
 
+  /// True if [element] is a local variable, local function, or parameter that
+  /// is accessed from an inner function. Recursive self-references in a local
+  /// function count as closure accesses.
+  bool isClosureVariable(Element element) {
+    return closureLocals.isClosureVariable(element);
+  }
+
   ir.Primitive visitSendSet(ast.SendSet node) {
     assert(isOpen);
     Element element = elements[node];
     ast.Operator op = node.assignmentOperator;
     // For complex operators, this is the result of getting (before assigning)
     ir.Primitive originalValue;
     // For []+= style operators, this saves the index.
     ir.Primitive index;
     ir.Primitive receiver;
     // This is what gets assigned.
@@ skipping 41 matching lines @@
         arg = visit(assignArg);
       }
       valueToStore = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([valueToStore]);
       ir.Expression invoke =
           new ir.InvokeMethod(originalValue, operatorSelector, k, [arg]);
       add(new ir.LetCont(k, invoke));
     }
 
     // Set the value
-    if (Elements.isLocal(element)) {
+    if (isClosureVariable(element)) {
+      add(new ir.SetClosureVariable(element, valueToStore));
+    } else if (Elements.isLocal(element)) {
       valueToStore.useElementAsHint(element);
       assignedVars[variableIndex[element]] = valueToStore;
     } else if (Elements.isStaticOrTopLevel(element)) {
       assert(element.isField || element.isSetter);
-      ir.Parameter v = new ir.Parameter(null);
-      ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
-      ir.InvokeStatic invoke =
-          new ir.InvokeStatic(element, selector, k, [valueToStore]);
-      add(new ir.LetCont(k, invoke));
+      continueWithExpression(
+          (k) => new ir.InvokeStatic(element, selector, k, [valueToStore]));
     } else {
       if (element != null && Elements.isUnresolved(element)) {
         return giveup(node, 'SendSet: non-local, non-static, unresolved');
       }
       // Setter or index-setter invocation
-      ir.Parameter v = new ir.Parameter(null);
-      ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.SETTER ||
           selector.kind == SelectorKind.INDEX);
       List<ir.Definition> arguments = selector.isIndexSet
           ? [index, valueToStore]
           : [valueToStore];
-      ir.Expression invoke =
-          createDynamicInvoke(node, selector, receiver, k, arguments);
-      add(new ir.LetCont(k, invoke));
+      continueWithExpression(
+          (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
     }
 
     if (node.isPostfix) {
       assert(originalValue != null);
       return originalValue;
     } else {
       return valueToStore;
     }
   }
 
   ir.Primitive visitNewExpression(ast.NewExpression node) {
     assert(isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     FunctionElement element = elements[node.send];
     if (Elements.isUnresolved(element)) {
       return giveup(node, 'NewExpression: unresolved constructor');
     }
     Selector selector = elements.getSelector(node.send);
     ast.Node selectorNode = node.send.selector;
     GenericType type = elements.getType(node);
     List<ir.Primitive> args =
         node.send.arguments.mapToList(visit, growable:false);
-    ir.Parameter v = new ir.Parameter(null);
-    ir.Continuation k = new ir.Continuation([v]);
-    ir.InvokeConstructor invoke =
-        new ir.InvokeConstructor(type, element,selector, k, args);
-    add(new ir.LetCont(k, invoke));
-    return v;
+    return continueWithExpression(
+        (k) => new ir.InvokeConstructor(type, element,selector, k, args));
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(isOpen);
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
-    ir.Parameter v = new ir.Parameter(null);
-    ir.Continuation k = new ir.Continuation([v]);
-    ir.ConcatenateStrings concat =
-        new ir.ConcatenateStrings(k, [first, second]);
-    add(new ir.LetCont(k, concat));
-    return v;
+    return continueWithExpression(
+        (k) => new ir.ConcatenateStrings(k, [first, second]));
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
     assert(isOpen);
     List<ir.Primitive> arguments = [];
     arguments.add(visitLiteralString(node.string));
     var it = node.parts.iterator;
     while (it.moveNext()) {
       ast.StringInterpolationPart part = it.current;
       arguments.add(visit(part.expression));
       arguments.add(visitLiteralString(part.string));
     }
-    ir.Parameter v = new ir.Parameter(null);
-    ir.Continuation k = new ir.Continuation([v]);
-    ir.ConcatenateStrings concat = new ir.ConcatenateStrings(k, arguments);
-    add(new ir.LetCont(k, concat));
-    return v;
+    return continueWithExpression(
+        (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
   ir.Primitive translateConstant(ast.Node node, [Constant value]) {
     assert(isOpen);
     if (value == null) {
       value = getConstantForNode(node);
     }
     ir.Primitive primitive = makeConst(constantBuilder.visit(node), value);
     add(new ir.LetPrim(primitive));
     return primitive;
   }
 
+  ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
+    return new IrBuilder(elements, compiler, sourceFile)
+           .buildFunctionInternal(elements[node]);
+  }
+
+  ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
+    FunctionElement element = elements[node];
+    ir.FunctionDefinition inner = makeSubFunction(node);
+    ir.CreateFunction prim = new ir.CreateFunction(inner);
+    add(new ir.LetPrim(prim));
+    return prim;
+  }
+
+  ir.Primitive visitFunctionDeclaration(ast.FunctionDeclaration node) {
+    FunctionElement element = elements[node.function];
+    ir.FunctionDefinition inner = makeSubFunction(node.function);
+    if (isClosureVariable(element)) {
+      add(new ir.DeclareFunction(element, inner));
+    } else {
+      ir.CreateFunction prim = new ir.CreateFunction(inner);
+      add(new ir.LetPrim(prim));
+      variableIndex[element] = assignedVars.length;
+      assignedVars.add(prim);
+      index2variable.add(element);
+      prim.useElementAsHint(element);
+    }
+    return null;
+  }
+
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
-  ir.Primitive giveup(ast.Node node, [String reason]) {
+  dynamic giveup(ast.Node node, [String reason]) {
     throw ABORT_IRNODE_BUILDER;
   }
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
@@ skipping 155 matching lines @@
   ConstExp visitConditional(ast.Conditional node) {
     BoolConstant condition = computeConstant(node.condition);
     return visit(condition.isTrue ? node.thenExpression : node.elseExpression);
   }
 
   ConstExp visitNode(ast.Node node) {
     throw "Unexpected constant: $node";
   }
 
 }
+
+/// Classifies local variables and local functions as 'closure variables'.
+/// A closure variable is one that is accessed from an inner function nested
+/// one or more levels inside the one that declares it.
+class DetectClosureVariables extends ast.Visitor {
+  final TreeElements elements;
+  DetectClosureVariables(this.elements);
+
+  FunctionElement currentFunction;
+  Set<Element> usedFromClosure = new Set<Element>();
+  Set<FunctionElement> recursiveFunctions = new Set<FunctionElement>();
+
+  bool isClosureVariable(Element element) => usedFromClosure.contains(element);
+
+  void markAsClosureVariable(Element element) {
+    usedFromClosure.add(element);
+  }
+
+  visit(ast.Node node) => node.accept(this);
+
+  visitNode(ast.Node node) {
+    node.visitChildren(this);
+  }
+
+  visitSend(ast.Send node) {
+    Element element = elements[node];
+    if (Elements.isLocal(element) &&
+        !element.isConst &&
+        element.enclosingElement != currentFunction) {
+      markAsClosureVariable(element);
+    }
+    node.visitChildren(this);
+  }
+
+  visitFunctionExpression(ast.FunctionExpression node) {
+    FunctionElement oldFunction = currentFunction;
+    currentFunction = elements[node];
+    visit(node.body);
+    currentFunction = oldFunction;
+  }
+
+}