dartfmt pkg/compiler

pkg/compiler/lib/src/dart_backend/placeholder_collector.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.
 
 part of dart_backend;
 
 class LocalPlaceholder {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int get hashCode => identifier.hashCode;
-  String toString() =>
-      'local_placeholder[id($identifier), nodes($nodes)]';
+  String toString() => 'local_placeholder[id($identifier), nodes($nodes)]';
 }
 
 class FunctionScope {
   final Set<String> parameterIdentifiers;
   final Set<LocalPlaceholder> localPlaceholders;
   FunctionScope()
       : parameterIdentifiers = new Set<String>(),
-      localPlaceholders = new Set<LocalPlaceholder>();
+        localPlaceholders = new Set<LocalPlaceholder>();
   void registerParameter(Identifier node) {
     parameterIdentifiers.add(node.source);
   }
 }
 
 class ConstructorPlaceholder {
   final Identifier node;
   final ConstructorElement element;
 
   ConstructorPlaceholder(this.node, this.element);
@@ skipping 94 matching lines @@
           collector.tryMakeLocalPlaceholder(element, node.selector);
         } else {
           assert(node.selector is FunctionExpression);
         }
       }
     }
   }
 
   visitStaticSend(Send node) {
     Element element = elements[node];
-    collector.mirrorRenamer.registerStaticSend(
-        collector.currentElement, element, node);
+    collector.mirrorRenamer
+        .registerStaticSend(collector.currentElement, element, node);
 
-    if (Elements.isUnresolved(element)
-        || element.isDeferredLoaderGetter) {
+    if (Elements.isUnresolved(element) || element.isDeferredLoaderGetter) {
       return;
     }
     if (element.isConstructor || element.isFactoryConstructor) {
       // Rename named constructor in redirection position:
       // class C { C.named(); C.redirecting() : this.named(); }
-      if (node.receiver is Identifier
-          && node.receiver.asIdentifier().isThis()) {
+      if (node.receiver is Identifier &&
+          node.receiver.asIdentifier().isThis()) {
         assert(node.selector is Identifier);
         collector.tryMakeConstructorPlaceholder(node, element);
       }
       return;
     }
     collector.makeElementPlaceholder(node.selector, element);
     // Another ugly case: <lib prefix>.<top level> is represented as
     // receiver: lib prefix, selector: top level.
     if (element.isTopLevel && node.receiver != null) {
       assert(elements[node.receiver].isPrefix);
@@ skipping 13 matching lines @@
 
 class PlaceholderCollector extends Visitor {
   final DiagnosticReporter reporter;
   final MirrorRenamer mirrorRenamer;
   final FunctionElement mainFunction;
   final Set<String> fixedMemberNames; // member names which cannot be renamed.
   final Map<Element, ElementAst> elementAsts;
   final Set<Node> prefixNodesToErase = new Set<Node>();
   final Set<Node> unresolvedNodes = new Set<Node>();
   final Map<Element, Set<Node>> elementNodes = new Map<Element, Set<Node>>();
-  final Map<FunctionElement, FunctionScope> functionScopes
-      = new Map<FunctionElement, FunctionScope>();
+  final Map<FunctionElement, FunctionScope> functionScopes =
+      new Map<FunctionElement, FunctionScope>();
   final Map<LibraryElement, Set<Identifier>> privateNodes =
       new Map<LibraryElement, Set<Identifier>>();
-  final List<DeclarationTypePlaceholder> declarationTypePlaceholders
-      = new List<DeclarationTypePlaceholder>();
-  final Map<String, Set<Identifier>> memberPlaceholders
-      = new Map<String, Set<Identifier>>();
-  final List<ConstructorPlaceholder> constructorPlaceholders
-      = new List<ConstructorPlaceholder>();
+  final List<DeclarationTypePlaceholder> declarationTypePlaceholders =
+      new List<DeclarationTypePlaceholder>();
+  final Map<String, Set<Identifier>> memberPlaceholders =
+      new Map<String, Set<Identifier>>();
+  final List<ConstructorPlaceholder> constructorPlaceholders =
+      new List<ConstructorPlaceholder>();
   Map<String, LocalPlaceholder> currentLocalPlaceholders;
   Element currentElement;
   FunctionElement topmostEnclosingFunction;
   TreeElements treeElements;
 
   get currentFunctionScope => functionScopes.putIfAbsent(
       topmostEnclosingFunction, () => new FunctionScope());
 
-  PlaceholderCollector(this.reporter, this.mirrorRenamer,
-                       this.fixedMemberNames, this.elementAsts,
-                       this.mainFunction);
+  PlaceholderCollector(this.reporter, this.mirrorRenamer, this.fixedMemberNames,
+      this.elementAsts, this.mainFunction);
 
   void collectFunctionDeclarationPlaceholders(
       FunctionElement element, FunctionExpression node) {
     if (element.isConstructor) {
       ConstructorElement constructor = element;
       tryMakeConstructorPlaceholder(node.name, element);
       RedirectingFactoryBody bodyAsRedirectingFactoryBody =
           node.body.asRedirectingFactoryBody();
       if (bodyAsRedirectingFactoryBody != null) {
         // Factory redirection.
         FunctionElement redirectTarget = constructor.immediateRedirectionTarget;
         assert(redirectTarget != null && redirectTarget != element);
         tryMakeConstructorPlaceholder(
-            bodyAsRedirectingFactoryBody.constructorReference,
-            redirectTarget);
+            bodyAsRedirectingFactoryBody.constructorReference, redirectTarget);
       }
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Note: this code should only rename private identifiers for class'
       // fields/getters/setters/methods.  Top-level identifiers are renamed
       // just to escape conflicts and that should be enough as we shouldn't
       // be able to resolve private identifiers for other libraries.
       makeElementPlaceholder(node.name, element);
     } else if (element.isClassMember) {
       if (node.name is Identifier) {
         tryMakeMemberPlaceholder(node.name);
@@ skipping 47 matching lines @@
   void tryMakeLocalPlaceholder(Element element, Identifier node) {
     bool isNamedOptionalParameter() {
       FunctionTypedElement function = element.enclosingElement;
       FunctionSignature signature = function.functionSignature;
       if (!signature.optionalParametersAreNamed) return false;
       for (Element parameter in signature.optionalParameters) {
         if (identical(parameter, element)) return true;
       }
       return false;
     }
-    if (element.isParameter && !isTypedefParameter(element) &&
+    if (element.isParameter &&
+        !isTypedefParameter(element) &&
         isNamedOptionalParameter()) {
       currentFunctionScope.registerParameter(node);
     } else if (Elements.isLocal(element) && !isTypedefParameter(element)) {
       makeLocalPlaceholder(node);
     }
   }
 
   void tryMakeMemberPlaceholder(Identifier node) {
     assert(node != null);
     if (node is Operator) return;
     String identifier = node.source;
     if (fixedMemberNames.contains(identifier)) return;
-    memberPlaceholders.putIfAbsent(
-        identifier, () => new Set<Identifier>()).add(node);
+    memberPlaceholders
+        .putIfAbsent(identifier, () => new Set<Identifier>())
+        .add(node);
   }
 
   void makeTypePlaceholder(Node node, DartType type) {
     Send send = node.asSend();
     if (send != null) {
       // Prefix.
       assert(send.receiver is Identifier);
       assert(send.selector is Identifier);
       makeErasePrefixPlaceholder(send.receiver);
       node = send.selector;
     }
     makeElementPlaceholder(node, type.element);
   }
 
   void makeTypeVariablePlaceholder(Node node, TypeVariableType type) {
     Send send = node.asSend();
     if (send != null) {
       // Prefix.
       assert(send.receiver is Identifier);
       assert(send.selector is Identifier);
       makeErasePrefixPlaceholder(send.receiver);
       node = send.selector;
     }
     tryMakeMemberPlaceholder(node);
   }
 
   void makeOmitDeclarationTypePlaceholder(TypeAnnotation type) {
     if (type == null) return;
-    declarationTypePlaceholders.add(
-        new DeclarationTypePlaceholder(type, false));
+    declarationTypePlaceholders
+        .add(new DeclarationTypePlaceholder(type, false));
   }
 
   void makeVarDeclarationTypePlaceholder(VariableDefinitions node) {
     // TODO(smok): Maybe instead of calling this method and
     // makeDeclaratioTypePlaceholder have type declaration placeholder
     // collector logic in visitVariableDefinitions when resolver becomes better
     // and/or catch syntax changes.
     if (node.type == null) return;
     bool requiresVar = !node.modifiers.isFinalOrConst;
-    declarationTypePlaceholders.add(
-        new DeclarationTypePlaceholder(node.type, requiresVar));
+    declarationTypePlaceholders
+        .add(new DeclarationTypePlaceholder(node.type, requiresVar));
   }
 
   /// Marks [node] to be erased in the output.
   /// This is done for library prefixes because they are not used in the output
   /// because all imports are flattened and conflicts are renamed away.
   void makeErasePrefixPlaceholder(Node node) {
     assert(node is Identifier || node is Send);
     prefixNodesToErase.add(node);
   }
 
@@ skipping 21 matching lines @@
     elementNodes.putIfAbsent(element, () => new Set<Node>()).add(node);
   }
 
   /// Marks [node] to be renamed per-library if it names an instance member
   /// and has a private name.
   void tryMakePrivateIdentifier(Node node, Element element) {
     if (node is Identifier &&
         !Elements.isStaticOrTopLevel(element) &&
         !Elements.isLocal(element) &&
         Name.isPrivateName(node.source)) {
-      privateNodes.putIfAbsent(
-          currentElement.library, () => new Set<Identifier>()).add(node);
+      privateNodes
+          .putIfAbsent(currentElement.library, () => new Set<Identifier>())
+          .add(node);
     }
   }
 
   void makeUnresolvedPlaceholder(Node node) {
     unresolvedNodes.add(node);
   }
 
   void makeLocalPlaceholder(Identifier identifier) {
     LocalPlaceholder getLocalPlaceholder() {
       String name = identifier.source;
@@ skipping 29 matching lines @@
     // First deconstruct the constructor, there are 4 possibilities:
     //  ClassName()
     //  prefix.ClassName()
     //  ClassName.constructorName()
     //  prefix.ClassName.constructorName()
     if (node is Send) {
       if (node.receiver is Send) {
         Send receiver = node.receiver;
         // prefix.ClassName.constructorName()
         assert(treeElements[receiver.receiver] != null &&
-               treeElements[receiver.receiver].isPrefix);
+            treeElements[receiver.receiver].isPrefix);
         prefix = receiver.receiver;
         className = receiver.selector;
         constructorName = node.selector;
       } else {
         Element receiverElement = treeElements[node.receiver];
         if (receiverElement != null && receiverElement.isPrefix) {
           // prefix.ClassName()
           prefix = node.receiver;
           className = node.selector;
         } else {
@@ skipping 18 matching lines @@
     } else if (className.isThis() || className.isSuper()) {
       // Do not rename super and this.
     } else if (className is Identifier) {
       makeElementPlaceholder(className, element.contextClass);
     } else {
       throw "Bad type of constructor name $className";
     }
 
     if (constructorName != null) {
       Element definingConstructor = findDefiningConstructor(element);
-      constructorPlaceholders.add(new ConstructorPlaceholder(constructorName,
-          definingConstructor));
+      constructorPlaceholders.add(
+          new ConstructorPlaceholder(constructorName, definingConstructor));
       tryMakePrivateIdentifier(constructorName, element);
     }
   }
 
   void internalError(String reason, {Node node}) {
     reporter.internalError(node, reason);
   }
 
   visit(Node node) => (node == null) ? null : node.accept(this);
 
-  visitNode(Node node) { node.visitChildren(this); }  // We must go deeper.
+  visitNode(Node node) {
+    node.visitChildren(this);
+  } // We must go deeper.
 
   visitNewExpression(NewExpression node) {
     Send send = node.send;
     DartType type = treeElements.getType(node);
     assert(type != null);
     Element constructor = treeElements[send];
     assert(constructor != null);
     assert(send.receiver == null);
     if (!Elements.isMalformed(constructor)) {
       tryMakeConstructorPlaceholder(node.send.selector, constructor);
@@ skipping 43 matching lines @@
       // that is needed to rename the construct properly.
       element = treeElements[send.selector];
     }
     tryMakePrivateIdentifier(send.selector, element);
     if (element == null) {
       if (send.receiver != null) tryMakeMemberPlaceholder(send.selector);
     } else if (!element.isMalformed) {
       if (Elements.isStaticOrTopLevel(element)) {
         // TODO(smok): Worth investigating why sometimes we get getter/setter
         // here and sometimes abstract field.
-        assert(element.isClass || element is VariableElement ||
-               element.isAccessor || element.isAbstractField ||
-               element.isFunction || element.isTypedef ||
-               element is TypeVariableElement);
+        assert(element.isClass ||
+            element is VariableElement ||
+            element.isAccessor ||
+            element.isAbstractField ||
+            element.isFunction ||
+            element.isTypedef ||
+            element is TypeVariableElement);
         makeElementPlaceholder(send.selector, element);
       } else {
         Identifier identifier = send.selector.asIdentifier();
         if (identifier == null) {
           // Handle optional function expression parameters with default values.
           identifier = send.selector.asFunctionExpression().name;
         }
         if (Elements.isInstanceField(element)) {
           tryMakeMemberPlaceholder(identifier);
         } else {
@@ skipping 32 matching lines @@
       // definitionElement may be null if we're inside variable definitions
       // of a function that is a parameter of another function.
       // TODO(smok): Fix this when resolver correctly deals with
       // such cases.
       if (definitionElement == null) continue;
 
       Send send = definition.asSend();
       Identifier identifier = definition is Identifier
           ? definition
           : definition is Send
-              ? (send.selector is Identifier
-                  ? send.selector
-                  : null)
+              ? (send.selector is Identifier ? send.selector : null)
               : null;
 
       tryMakePrivateIdentifier(identifier, definitionElement);
 
       if (send != null) {
         // May get FunctionExpression here in definition.selector
         // in case of A(int this.f());
         if (send.selector is Identifier) {
           if (definitionElement.isInitializingFormal) {
             tryMakeMemberPlaceholder(send.selector);
           } else {
             tryMakeLocalPlaceholder(definitionElement, send.selector);
           }
         } else {
           assert(send.selector is FunctionExpression);
           if (definitionElement.isInitializingFormal) {
-            tryMakeMemberPlaceholder(
-                send.selector.asFunctionExpression().name);
+            tryMakeMemberPlaceholder(send.selector.asFunctionExpression().name);
           }
         }
       } else if (definition is Identifier) {
         tryMakeLocalPlaceholder(definitionElement, definition);
       } else if (definition is FunctionExpression) {
         // Skip, it will be processed in visitFunctionExpression.
       } else {
         internalError('Unexpected definition structure $definition');
       }
     }
@@ skipping 80 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }