dartfmt pkg/compiler

pkg/compiler/lib/src/closure.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.
 
 library closureToClassMapper;
 
 import 'common.dart';
-import 'common/names.dart' show
-    Identifiers;
-import 'common/resolution.dart' show
-    Parsing,
-    Resolution;
-import 'common/tasks.dart' show
-    CompilerTask;
-import 'compiler.dart' show
-    Compiler;
+import 'common/names.dart' show Identifiers;
+import 'common/resolution.dart' show Parsing, Resolution;
+import 'common/tasks.dart' show CompilerTask;
+import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
 import 'dart_types.dart';
 import 'elements/elements.dart';
-import 'elements/modelx.dart' show
-    BaseFunctionElementX,
-    ClassElementX,
-    ElementX,
-    LocalFunctionElementX;
+import 'elements/modelx.dart'
+    show BaseFunctionElementX, ClassElementX, ElementX, LocalFunctionElementX;
 import 'elements/visitor.dart' show ElementVisitor;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'resolution/tree_elements.dart' show TreeElements;
 import 'tokens/token.dart' show Token;
 import 'tree/tree.dart';
 import 'util/util.dart';
-import 'universe/universe.dart' show
-    Universe;
+import 'universe/universe.dart' show Universe;
 
 class ClosureTask extends CompilerTask {
   Map<Node, ClosureClassMap> closureMappingCache;
   ClosureTask(Compiler compiler)
       : closureMappingCache = new Map<Node, ClosureClassMap>(),
         super(compiler);
 
   String get name => "Closure Simplifier";
 
-  ClosureClassMap computeClosureToClassMapping(Element element,
-                                               Node node,
-                                               TreeElements elements) {
+  ClosureClassMap computeClosureToClassMapping(
+      Element element, Node node, TreeElements elements) {
     return measure(() {
       ClosureClassMap cached = closureMappingCache[node];
       if (cached != null) return cached;
 
       ClosureTranslator translator =
           new ClosureTranslator(compiler, elements, closureMappingCache);
 
       // The translator will store the computed closure-mappings inside the
       // cache. One for given node and one for each nested closure.
       if (node is FunctionExpression) {
@@ skipping 45 matching lines @@
 /// non-elements.
 abstract class CapturedVariable implements Element {}
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
 class ClosureFieldElement extends ElementX
     implements FieldElement, CapturedVariable, PrivatelyNamedJSEntity {
   /// The [BoxLocal] or [LocalElement] being accessed through the field.
   final Local local;
 
-  ClosureFieldElement(String name,
-                      this.local,
-                      ClosureClassElement enclosing)
+  ClosureFieldElement(String name, this.local, ClosureClassElement enclosing)
       : super(name, ElementKind.FIELD, enclosing);
 
   /// Use [closureClass] instead.
   @deprecated
   get enclosingElement => super.enclosingElement;
 
   ClosureClassElement get closureClass => super.enclosingElement;
 
   MemberElement get memberContext => closureClass.methodElement.memberContext;
 
   @override
   Entity get declaredEntity => local;
   @override
   Entity get rootOfScope => closureClass;
 
   bool get hasNode => false;
 
   Node get node {
-    throw new SpannableAssertionFailure(local,
-        'Should not access node of ClosureFieldElement.');
+    throw new SpannableAssertionFailure(
+        local, 'Should not access node of ClosureFieldElement.');
   }
 
   bool get hasResolvedAst => hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(this, null, treeElements);
   }
 
   Expression get initializer {
-    throw new SpannableAssertionFailure(local,
-        'Should not access initializer of ClosureFieldElement.');
+    throw new SpannableAssertionFailure(
+        local, 'Should not access initializer of ClosureFieldElement.');
   }
 
   bool get isInstanceMember => true;
   bool get isAssignable => false;
 
   DartType computeType(Resolution resolution) => type;
 
   DartType get type {
     if (local is LocalElement) {
       LocalElement element = local;
@@ skipping 16 matching lines @@
   @override
   ConstantExpression get constant => null;
 }
 
 // TODO(ahe): These classes continuously cause problems.  We need to find
 // a more general solution.
 class ClosureClassElement extends ClassElementX {
   DartType rawType;
   DartType thisType;
   FunctionType callType;
+
   /// Node that corresponds to this closure, used for source position.
   final FunctionExpression node;
 
   /**
    * The element for the declaration of the function expression.
    */
   final LocalFunctionElement methodElement;
 
   final List<ClosureFieldElement> _closureFields = <ClosureFieldElement>[];
 
-  ClosureClassElement(this.node,
-                      String name,
-                      Compiler compiler,
-                      LocalFunctionElement closure)
+  ClosureClassElement(
+      this.node, String name, Compiler compiler, LocalFunctionElement closure)
       : this.methodElement = closure,
-        super(name,
-              closure.compilationUnit,
-              // By assigning a fresh class-id we make sure that the hashcode
-              // is unique, but also emit closure classes after all other
-              // classes (since the emitter sorts classes by their id).
-              compiler.getNextFreeClassId(),
-              STATE_DONE) {
+        super(
+            name,
+            closure.compilationUnit,
+            // By assigning a fresh class-id we make sure that the hashcode
+            // is unique, but also emit closure classes after all other
+            // classes (since the emitter sorts classes by their id).
+            compiler.getNextFreeClassId(),
+            STATE_DONE) {
     JavaScriptBackend backend = compiler.backend;
     ClassElement superclass = methodElement.isInstanceMember
         ? backend.helpers.boundClosureClass
         : backend.helpers.closureClass;
     superclass.ensureResolved(compiler.resolution);
     supertype = superclass.thisType;
     interfaces = const Link<DartType>();
     thisType = rawType = new InterfaceType(this);
     allSupertypesAndSelf =
         superclass.allSupertypesAndSelf.extendClass(thisType);
@@ skipping 32 matching lines @@
 class BoxLocal extends Local {
   final String name;
   final ExecutableElement executableContext;
 
   BoxLocal(this.name, this.executableContext);
 }
 
 // TODO(ngeoffray, ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
 class BoxFieldElement extends ElementX
-    implements TypedElement, CapturedVariable, FieldElement,
+    implements
+        TypedElement,
+        CapturedVariable,
+        FieldElement,
         PrivatelyNamedJSEntity {
   final BoxLocal box;
 
-  BoxFieldElement(String name, this.variableElement,
-      BoxLocal box)
+  BoxFieldElement(String name, this.variableElement, BoxLocal box)
       : this.box = box,
         super(name, ElementKind.FIELD, box.executableContext);
 
   DartType computeType(Resolution resolution) => type;
 
   DartType get type => variableElement.type;
 
   @override
   Entity get declaredEntity => variableElement;
   @override
@@ skipping 46 matching lines @@
   String get name => 'this';
 
   ClassElement get enclosingClass => executableContext.enclosingClass;
 }
 
 /// Call method of a closure class.
 class SynthesizedCallMethodElementX extends BaseFunctionElementX
     implements MethodElement {
   final LocalFunctionElement expression;
 
-  SynthesizedCallMethodElementX(String name,
-                                LocalFunctionElementX other,
-                                ClosureClassElement enclosing)
+  SynthesizedCallMethodElementX(
+      String name, LocalFunctionElementX other, ClosureClassElement enclosing)
       : expression = other,
         super(name, other.kind, other.modifiers, enclosing) {
     asyncMarker = other.asyncMarker;
     functionSignature = other.functionSignature;
   }
 
   /// Use [closureClass] instead.
   @deprecated
   get enclosingElement => super.enclosingElement;
 
@@ skipping 32 matching lines @@
   List<VariableElement> boxedLoopVariables = const <VariableElement>[];
 
   ClosureScope(this.boxElement, this.capturedVariables);
 
   bool hasBoxedLoopVariables() => !boxedLoopVariables.isEmpty;
 
   bool isCapturedVariable(VariableElement variable) {
     return capturedVariables.containsKey(variable);
   }
 
-  void forEachCapturedVariable(f(LocalVariableElement variable,
-                                 BoxFieldElement boxField)) {
+  void forEachCapturedVariable(
+      f(LocalVariableElement variable, BoxFieldElement boxField)) {
     capturedVariables.forEach(f);
   }
 }
 
 class ClosureClassMap {
   // The closure's element before any translation. Will be null for methods.
   final LocalFunctionElement closureElement;
   // The closureClassElement will be null for methods that are not local
   // closures.
   final ClosureClassElement closureClassElement;
@@ skipping 16 matching lines @@
   final Map<Node, ClosureScope> capturingScopes = new Map<Node, ClosureScope>();
 
   /// Variables that are used in a try must be treated as boxed because the
   /// control flow can be non-linear.
   ///
   /// Also parameters to a `sync*` generator must be boxed, because of the way
   /// we rewrite sync* functions. See also comments in [useLocal].
   /// TODO(johnniwinter): Add variables to this only if the variable is mutated.
   final Set<Local> variablesUsedInTryOrGenerator = new Set<Local>();
 
-  ClosureClassMap(this.closureElement,
-                  this.closureClassElement,
-                  this.callElement,
-                  this.thisLocal);
+  ClosureClassMap(this.closureElement, this.closureClassElement,
+      this.callElement, this.thisLocal);
 
   void addFreeVariable(Local element) {
     assert(freeVariableMap[element] == null);
     freeVariableMap[element] = null;
   }
 
   Iterable<Local> get freeVariables => freeVariableMap.keys;
 
   bool isFreeVariable(Local element) {
     return freeVariableMap.containsKey(element);
   }
 
-  void forEachFreeVariable(f(Local variable,
-                             CapturedVariable field)) {
+  void forEachFreeVariable(f(Local variable, CapturedVariable field)) {
     freeVariableMap.forEach(f);
   }
 
   Local getLocalVariableForClosureField(ClosureFieldElement field) {
     return field.local;
   }
 
   bool get isClosure => closureElement != null;
 
   bool capturingScopesBox(Local variable) {
     return capturingScopes.values.any((scope) {
       return scope.boxedLoopVariables.contains(variable);
     });
   }
 
   bool isVariableBoxed(Local variable) {
     CapturedVariable copy = freeVariableMap[variable];
     if (copy is BoxFieldElement) {
       return true;
     }
     return capturingScopesBox(variable);
   }
 
-  void forEachCapturedVariable(void f(Local variable,
-                                      CapturedVariable field)) {
+  void forEachCapturedVariable(void f(Local variable, CapturedVariable field)) {
     freeVariableMap.forEach((variable, copy) {
       if (variable is BoxLocal) return;
       f(variable, copy);
     });
     capturingScopes.values.forEach((ClosureScope scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 
-  void forEachBoxedVariable(void f(LocalVariableElement local,
-                                   BoxFieldElement field)) {
+  void forEachBoxedVariable(
+      void f(LocalVariableElement local, BoxFieldElement field)) {
     freeVariableMap.forEach((variable, copy) {
       if (!isVariableBoxed(variable)) return;
       f(variable, copy);
     });
     capturingScopes.values.forEach((ClosureScope scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 
   void removeMyselfFrom(Universe universe) {
@@ skipping 31 matching lines @@
   Set<LocalVariableElement> mutatedVariables = new Set<LocalVariableElement>();
 
   MemberElement outermostElement;
   ExecutableElement executableContext;
 
   // The closureData of the currentFunctionElement.
   ClosureClassMap closureData;
 
   bool insideClosure = false;
 
-  ClosureTranslator(this.compiler,
-                    this.elements,
-                    this.closureMappingCache);
+  ClosureTranslator(this.compiler, this.elements, this.closureMappingCache);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   /// Generate a unique name for the [id]th closure field, with proposed name
   /// [name].
   ///
   /// The result is used as the name of [ClosureFieldElement]s, and must
   /// therefore be unique to avoid breaking an invariant in the element model
   /// (classes cannot declare multiple fields with the same name).
   ///
@@ skipping 24 matching lines @@
     return _capturedVariableMapping.containsKey(element);
   }
 
   void addCapturedVariable(Node node, Local variable) {
     if (_capturedVariableMapping[variable] != null) {
       reporter.internalError(node, 'In closure analyzer.');
     }
     _capturedVariableMapping[variable] = null;
   }
 
-  void setCapturedVariableBoxField(Local variable,
-      BoxFieldElement boxField) {
+  void setCapturedVariableBoxField(Local variable, BoxFieldElement boxField) {
     assert(isCapturedVariable(variable));
     _capturedVariableMapping[variable] = boxField;
   }
 
   BoxFieldElement getCapturedVariableBoxField(Local variable) {
     return _capturedVariableMapping[variable];
   }
 
   void translateFunction(Element element, FunctionExpression node) {
     // For constructors the [element] and the [:elements[node]:] may differ.
     // The [:elements[node]:] always points to the generative-constructor
     // element, whereas the [element] might be the constructor-body element.
     visit(node); // [visitFunctionExpression] will call [visitInvokable].
     // When variables need to be boxed their [_capturedVariableMapping] is
     // updated, but we delay updating the similar freeVariableMapping in the
     // closure datas that capture these variables.
     // The closures don't have their fields (in the closure class) set, either.
     updateClosures();
   }
 
   void translateLazyInitializer(VariableElement element,
-                                VariableDefinitions node,
-                                Expression initializer) {
-    visitInvokable(element, node, () { visit(initializer); });
+      VariableDefinitions node, Expression initializer) {
+    visitInvokable(element, node, () {
+      visit(initializer);
+    });
     updateClosures();
   }
 
   // This function runs through all of the existing closures and updates their
   // free variables to the boxed value. It also adds the field-elements to the
   // class representing the closure.
   void updateClosures() {
     for (Expression closure in closures) {
       // The captured variables that need to be stored in a field of the closure
       // class.
@@ skipping 13 matching lines @@
           assert(fromElement is! BoxLocal);
           // The variable has not been boxed.
           fieldCaptures.add(fromElement);
         } else {
           // A boxed element.
           data.freeVariableMap[fromElement] = boxFieldElement;
           boxes.add(boxFieldElement.box);
         }
       });
       ClosureClassElement closureClass = data.closureClassElement;
-      assert(closureClass != null ||
-             (fieldCaptures.isEmpty && boxes.isEmpty));
+      assert(closureClass != null || (fieldCaptures.isEmpty && boxes.isEmpty));
 
       void addClosureField(Local local, String name) {
         ClosureFieldElement closureField =
             new ClosureFieldElement(name, local, closureClass);
         closureClass.addField(closureField, reporter);
         data.freeVariableMap[local] = closureField;
       }
 
       // Add the box elements first so we get the same ordering.
       // TODO(sra): What is the canonical order of multiple boxes?
@@ skipping 25 matching lines @@
 
   void useLocal(Local variable) {
     // If the element is not declared in the current function and the element
     // is not the closure itself we need to mark the element as free variable.
     // Note that the check on [insideClosure] is not just an
     // optimization: factories have type parameters as function
     // parameters, and type parameters are declared in the class, not
     // the factory.
     bool inCurrentContext(Local variable) {
       return variable == executableContext ||
-             variable.executableContext == executableContext;
+          variable.executableContext == executableContext;
     }
 
     if (insideClosure && !inCurrentContext(variable)) {
       closureData.addFreeVariable(variable);
     } else if (inTryStatement) {
       // Don't mark the this-element or a self-reference. This would complicate
       // things in the builder.
       // Note that nested (named) functions are immutable.
       if (variable != closureData.thisLocal &&
           variable != closureData.closureElement &&
@@ skipping 24 matching lines @@
 
   visit(Node node) => node.accept(this);
 
   visitNode(Node node) => node.visitChildren(this);
 
   visitVariableDefinitions(VariableDefinitions node) {
     if (node.type != null) {
       visit(node.type);
     }
     for (Link<Node> link = node.definitions.nodes;
-         !link.isEmpty;
-         link = link.tail) {
+        !link.isEmpty;
+        link = link.tail) {
       Node definition = link.head;
       LocalElement element = elements[definition];
       assert(element != null);
       if (!element.isInitializingFormal) {
         declareLocal(element);
       }
       // We still need to visit the right-hand sides of the init-assignments.
       // For SendSets don't visit the left again. Otherwise it would be marked
       // as mutated.
       if (definition is Send) {
         Send assignment = definition;
         Node arguments = assignment.argumentsNode;
         if (arguments != null) {
           visit(arguments);
         }
       } else {
         visit(definition);
       }
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     MemberElement member = executableContext.memberContext;
     DartType type = elements.getType(node);
     // TODO(karlklose,johnniwinther): if the type is null, the annotation is
     // from a parameter which has been analyzed before the method has been
     // resolved and the result has been thrown away.
-    if (compiler.options.enableTypeAssertions && type != null &&
+    if (compiler.options.enableTypeAssertions &&
+        type != null &&
         type.containsTypeVariables) {
       if (insideClosure && member.isFactoryConstructor) {
         // This is a closure in a factory constructor.  Since there is no
         // [:this:], we have to mark the type arguments as free variables to
         // capture them in the closure.
         type.forEachTypeVariable((TypeVariableType variable) {
           useTypeVariableAsLocal(variable);
         });
       }
       if (member.isInstanceMember && !member.isField) {
         // In checked mode, using a type variable in a type annotation may lead
         // to a runtime type check that needs to access the type argument and
         // therefore the closure needs a this-element, if it is not in a field
         // initializer; field initatializers are evaluated in a context where
         // the type arguments are available in locals.
         registerNeedsThis();
       }
     }
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
       registerNeedsThis();
     } else {
       Element element = elements[node];
       if (element != null && element.isTypeVariable) {
-        if (outermostElement.isConstructor ||
-            outermostElement.isField) {
+        if (outermostElement.isConstructor || outermostElement.isField) {
           TypeVariableElement typeVariable = element;
           useTypeVariableAsLocal(typeVariable.type);
         } else {
           registerNeedsThis();
         }
       }
     }
     node.visitChildren(this);
   }
 
   visitSend(Send node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       LocalElement localElement = element;
       useLocal(localElement);
     } else if (element != null && element.isTypeVariable) {
       TypeVariableElement variable = element;
       analyzeType(variable.type);
     } else if (node.receiver == null &&
-               Elements.isInstanceSend(node, elements)) {
+        Elements.isInstanceSend(node, elements)) {
       registerNeedsThis();
     } else if (node.isSuperCall) {
       registerNeedsThis();
     } else if (node.isTypeTest || node.isTypeCast) {
       TypeAnnotation annotation = node.typeAnnotationFromIsCheckOrCast;
       DartType type = elements.getType(annotation);
       analyzeType(type);
     } else if (node.isTypeTest) {
       DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
       analyzeType(type);
@@ skipping 31 matching lines @@
   visitLiteralMap(LiteralMap node) {
     DartType type = elements.getType(node);
     analyzeType(type);
     node.visitChildren(this);
   }
 
   void analyzeTypeVariables(DartType type) {
     type.forEachTypeVariable((TypeVariableType typeVariable) {
       // Field initializers are inlined and access the type variable as
       // normal parameters.
-      if (!outermostElement.isField &&
-          !outermostElement.isConstructor) {
+      if (!outermostElement.isField && !outermostElement.isConstructor) {
         registerNeedsThis();
       } else {
         useTypeVariableAsLocal(typeVariable);
       }
     });
   }
 
   void analyzeType(DartType type) {
     // TODO(johnniwinther): Find out why this can be null.
     if (type == null) return;
     if (outermostElement.isClassMember &&
         compiler.backend.classNeedsRti(outermostElement.enclosingClass)) {
-      if (outermostElement.isConstructor ||
-          outermostElement.isField) {
+      if (outermostElement.isConstructor || outermostElement.isField) {
         analyzeTypeVariables(type);
       } else if (outermostElement.isInstanceMember) {
         if (type.containsTypeVariables) {
           registerNeedsThis();
         }
       }
     }
   }
 
   // If variables that are declared in the [node] scope are captured and need
@@ skipping 74 matching lines @@
       // condition or body are indeed flagged as mutated.
       if (node.conditionStatement != null) visit(node.conditionStatement);
       if (node.body != null) visit(node.body);
 
       // See if we have declared loop variables that need to be boxed.
       if (node.initializer == null) return;
       VariableDefinitions definitions =
           node.initializer.asVariableDefinitions();
       if (definitions == null) return;
       for (Link<Node> link = definitions.definitions.nodes;
-           !link.isEmpty;
-           link = link.tail) {
+          !link.isEmpty;
+          link = link.tail) {
         Node definition = link.head;
         LocalVariableElement element = elements[definition];
         // Non-mutated variables should not be boxed.  The mutatedVariables set
         // gets cleared when 'inNewScope' returns, so check it here.
         if (isCapturedVariable(element) && mutatedVariables.contains(element)) {
           boxedLoopVariables.add(element);
         }
       }
     });
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     scopeData.boxedLoopVariables = boxedLoopVariables;
   }
 
   /** Returns a non-unique name for the given closure element. */
   String computeClosureName(Element element) {
     Link<String> parts = const Link<String>();
     String ownName = element.name;
     if (ownName == null || ownName == "") {
       parts = parts.prepend("closure");
     } else {
       parts = parts.prepend(ownName);
     }
     for (Element enclosingElement = element.enclosingElement;
-         enclosingElement != null &&
-             (enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY
-              || enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR
-              || enclosingElement.kind == ElementKind.CLASS
-              || enclosingElement.kind == ElementKind.FUNCTION
-              || enclosingElement.kind == ElementKind.GETTER
-              || enclosingElement.kind == ElementKind.SETTER);
-         enclosingElement = enclosingElement.enclosingElement) {
+        enclosingElement != null &&
+            (enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
+                enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
+                enclosingElement.kind == ElementKind.CLASS ||
+                enclosingElement.kind == ElementKind.FUNCTION ||
+                enclosingElement.kind == ElementKind.GETTER ||
+                enclosingElement.kind == ElementKind.SETTER);
+        enclosingElement = enclosingElement.enclosingElement) {
       // TODO(johnniwinther): Simplify computed names.
       if (enclosingElement.isGenerativeConstructor ||
           enclosingElement.isGenerativeConstructorBody ||
           enclosingElement.isFactoryConstructor) {
-        parts = parts.prepend(
-            Elements.reconstructConstructorName(enclosingElement));
+        parts = parts
+            .prepend(Elements.reconstructConstructorName(enclosingElement));
       } else {
         String surroundingName =
             Elements.operatorNameToIdentifier(enclosingElement.name);
         parts = parts.prepend(surroundingName);
       }
       // A generative constructors's parent is the class; the class name is
       // already part of the generative constructor's name.
       if (enclosingElement.kind == ElementKind.GENERATIVE_CONSTRUCTOR) break;
     }
     StringBuffer sb = new StringBuffer();
     parts.printOn(sb, '_');
     return sb.toString();
   }
 
   JavaScriptBackend get backend => compiler.backend;
 
-  ClosureClassMap globalizeClosure(FunctionExpression node,
-                                   LocalFunctionElement element) {
+  ClosureClassMap globalizeClosure(
+      FunctionExpression node, LocalFunctionElement element) {
     String closureName = computeClosureName(element);
-    ClosureClassElement globalizedElement = new ClosureClassElement(
-        node, closureName, compiler, element);
+    ClosureClassElement globalizedElement =
+        new ClosureClassElement(node, closureName, compiler, element);
     // Extend [globalizedElement] as an instantiated class in the closed world.
-    compiler.world.registerClass(
-        globalizedElement, isDirectlyInstantiated: true);
-    FunctionElement callElement =
-        new SynthesizedCallMethodElementX(Identifiers.call,
-                                          element,
-                                          globalizedElement);
+    compiler.world
+        .registerClass(globalizedElement, isDirectlyInstantiated: true);
+    FunctionElement callElement = new SynthesizedCallMethodElementX(
+        Identifiers.call, element, globalizedElement);
     backend.maybeMarkClosureAsNeededForReflection(
         globalizedElement, callElement, element);
     MemberElement enclosing = element.memberContext;
     enclosing.nestedClosures.add(callElement);
     globalizedElement.addMember(callElement, reporter);
     globalizedElement.computeAllClassMembers(compiler);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     ThisLocal thisElement = closureData.thisLocal;
 
-    return new ClosureClassMap(element, globalizedElement,
-                               callElement, thisElement);
+    return new ClosureClassMap(
+        element, globalizedElement, callElement, thisElement);
   }
 
-  void visitInvokable(ExecutableElement element,
-                      Node node,
-                      void visitChildren()) {
+  void visitInvokable(
+      ExecutableElement element, Node node, void visitChildren()) {
     bool oldInsideClosure = insideClosure;
     Element oldFunctionElement = executableContext;
     ClosureClassMap oldClosureData = closureData;
 
     insideClosure = outermostElement != null;
     LocalFunctionElement closure;
     executableContext = element;
     if (insideClosure) {
       closure = element;
       closures.add(node);
       closureData = globalizeClosure(node, closure);
     } else {
       outermostElement = element;
       ThisLocal thisElement = null;
       if (element.isInstanceMember || element.isGenerativeConstructor) {
         thisElement = new ThisLocal(element);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
     }
     closureMappingCache[node] = closureData;
 
     inNewScope(node, () {
       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.
       if (element is FunctionElement &&
           (compiler.backend.methodNeedsRti(element) ||
-           compiler.options.enableTypeAssertions)) {
+              compiler.options.enableTypeAssertions)) {
         analyzeTypeVariables(type);
       }
 
       visitChildren();
     });
 
-
     ClosureClassMap savedClosureData = closureData;
     bool savedInsideClosure = insideClosure;
 
     // Restore old values.
     insideClosure = oldInsideClosure;
     closureData = oldClosureData;
     executableContext = oldFunctionElement;
 
     // Mark all free variables as captured and use them in the outer function.
     Iterable<Local> freeVariables = savedClosureData.freeVariables;
@@ skipping 71 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements Entity {
   Entity get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }