anchor.diff:      });
     }
   
  -  visitFunctionDeclaration(FunctionDeclaration node) {
  -    node.visitChildren(this);
  -    LocalFunctionElement localFunction =
  -        elements.getFunctionDefinition(node.function);
  -    declareLocal(localFunction);
  -  }
  -
     visitTryStatement(TryStatement node) {
       // TODO(ngeoffray): implement finer grain state.
       bool oldInTryStatement = inTryStatement;
  
positive.code:     closureMappingCache[node] = closureData;
  
      inNewScope(node, () {
        // We have to declare the implicit 'this' parameter.
        if (!insideClosure && closureData.thisLocal != null) {
          declareLocal(closureData.thisLocal);
        }
        // If we are inside a named closure we have to declare ourselve. For
        // simplicity we declare the local even if the closure does not have a
        // name.
        // It will simply not be used.
        if (insideClosure) {
          declareLocal(closure);
        }
  
        if (executableContext.isFactoryConstructor &&
            compiler.backend.classNeedsRti(executableContext.enclosingElement)) {
          // Declare the type parameters in the scope. Generative
          // constructors just use 'this'.
          ClassElement cls = executableContext.enclosingClass;
          cls.typeVariables.forEach((TypeVariableType typeVariable) {
            declareLocal(new TypeVariableLocal(typeVariable, executableContext));
          });
        }
  
        DartType type = element.type;
        // If the method needs RTI, or checked mode is set, we need to
        // escape the potential type variables used in that closure.
  
negative.code:     useLocal(new TypeVariableLocal(typeVariable, outermostElement));
    }
  
    void declareLocal(LocalVariableElement element) {
      scopeVariables.add(element);
    }
  
  