dart2dart Rename statics as globals.

lib/compiler/implementation/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.
 
 class LocalPlaceholder implements Hashable {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int hashCode() => identifier.hashCode();
   String toString() =>
@@ skipping 14 matching lines @@
     final element = elements[node];
     if (element !== null) {
       collector.tryMakeLocalPlaceholder(element, node.selector);
     }
   }
 
   visitGetterSend(Send node) {
     final element = elements[node];
     // element === null means dynamic property access.
     if (element === null) return;
-    // We don't want to rename non top-level element access
-    // unless it's a local variable.
     if (element.isPrefix()) {
       // Node is prefix part in case of source 'lib.somesetter = 5;'
       collector.makeNullPlaceholder(node);
-      return;
+    } else if (Elements.isStaticOrTopLevel(element)) {
+      // Unqualified or prefixed top level or static.
+      collector.makeElementPlaceholder(node.selector, element);
     } else if (!element.isTopLevel()) {
       // May get FunctionExpression here in selector
       // in case of A(int this.f());
       if (node.selector is Identifier) {
         collector.tryMakeLocalPlaceholder(element, node.selector);
       } else {
         assert(node.selector is FunctionExpression);
       }
-      return;
-    }
-    // Unqualified <class> in static invocation, why it's not a type annotation?
-    // Another option would be to process in visitStaticSend, NB:
-    // those elements are not top-level.
-    // OR: unqualified top level.
-    collector.makeElementPlaceholder(node.selector, element);
-    if (node.receiver !== null) {
-      // <lib prefix>.<top level>.
-      collector.makeNullPlaceholder(node.receiver);  // Cut library prefix.
     }
   }
 
   visitStaticSend(Send node) {
     final element = elements[node];
-    if (!element.isTopLevel()) return;
+    if (element.isConstructor() || element.isFactoryConstructor()) return;
+    collector.makeElementPlaceholder(node.selector, element);
     // Another ugly case: <lib prefix>.<top level> is represented as
     // receiver: lib prefix, selector: top level.
-    collector.makeElementPlaceholder(node.selector, element);
-    if (node.receiver !== null) {
+    if (element.isTopLevel() && node.receiver !== null) {
       assert(elements[node.receiver].isPrefix());
       // Hack: putting null into map overrides receiver of original node.
       collector.makeNullPlaceholder(node.receiver);
     }
   }
 
   internalError(String reason, [Node node]) {
     collector.internalError(reason, node);
   }
 }
@@ skipping 56 matching lines @@
       // Example:
       // interface I { I(); }
       // class C implements I { C(); }  don't rename this case.
       // OR I.named() inside C, rename first part.
       if (element.defaultImplementation !== null
           && element.defaultImplementation !== element) {
         FunctionElement implementingFactory = element.defaultImplementation;
         tryMakeConstructorNamePlaceholder(implementingFactory.cachedNode,
             element.getEnclosingClass());
       }
-    } else if (element.isTopLevel()) {
+    } 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);
     }
   }
 
   void collectFieldDeclarationPlaceholders(
       Element element, VariableDefinitions node) {
-    if (element.isTopLevel()) {
+    if (Elements.isStaticOrTopLevel(element)) {
       Node fieldNode = element.parseNode(compiler);
       if (fieldNode is Identifier) {
         makeElementPlaceholder(fieldNode, element);
       } else if (fieldNode is SendSet) {
         makeElementPlaceholder(fieldNode.selector, element);
       } else {
         unreachable();
       }
     }
   }
@@ skipping 92 matching lines @@
   visitNode(Node node) { node.visitChildren(this); }  // We must go deeper.
 
   visitSend(Send send) {
     new SendVisitor(this, treeElements).visitSend(send);
     send.visitChildren(this);
   }
 
   visitSendSet(SendSet send) {
     final element = treeElements[send];
     if (element !== null) {
-      if (element.isTopLevel()) {
+      if (Elements.isStaticOrTopLevel(element)) {
         assert(element is VariableElement || element.isSetter());
         makeElementPlaceholder(send.selector, element);
       } else {
         assert(send.selector is Identifier);
         tryMakeLocalPlaceholder(element, send.selector);
       }
     }
     send.visitChildren(this);
   }
 
@@ skipping 128 matching lines @@
     }
     node.visitChildren(this);
   }
 
   visitTypedef(Typedef node) {
     assert(currentElement is TypedefElement);
     makeElementPlaceholder(node.name, currentElement);
     node.visitChildren(this);
   }
 }