Copy OldResolver dispatch logic to SendVisitor and remove OldResolver.

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>();
@@ skipping 19 matching lines @@
 
   ConstructorPlaceholder(this.node, this.element);
 }
 
 class DeclarationTypePlaceholder {
   final TypeAnnotation typeNode;
   final bool requiresVar;
   DeclarationTypePlaceholder(this.typeNode, this.requiresVar);
 }
 
-class SendVisitor extends OldResolvedVisitor {
+class SendVisitor extends Visitor {
+  final TreeElements elements;
   final PlaceholderCollector collector;
 
-  SendVisitor(this.collector, TreeElements elements)
-      : super(elements);
+  SendVisitor(this.collector, this.elements);
 
-  visitOperatorSend(Send node) {
-  }
-
-  visitForeignSend(Send node) {}
-
-  visitSuperSend(Send node) {
+  visitSend(Send node) {
     Element element = elements[node];
-    if (element != null && element.isConstructor) {
-      collector.tryMakeConstructorPlaceholder(node, element);
+    if (elements.isAssert(node)) {
+      return;
+    } else if (elements.isTypeLiteral(node)) {
+      DartType type = elements.getTypeLiteralType(node);
+      if (!type.isDynamic) {
+        if (type is TypeVariableType) {
+          collector.makeTypeVariablePlaceholder(node.selector, type);
+        } else {
+          collector.makeTypePlaceholder(node.selector, type);
+        }
+      }
+    } else if (node.isSuperCall) {
+      if (element != null && element.isConstructor) {
+        collector.tryMakeConstructorPlaceholder(node, element);
+      } else {
+        collector.tryMakeMemberPlaceholder(node.selector);
+      }
+    } else if (node.isOperator) {
+      return;
+    } else if (node.isPropertyAccess) {
+      if (!Elements.isUnresolved(element) && element.impliesType) {
+        collector.makeElementPlaceholder(node, element);
+      } else {
+        visitGetterSend(node);
+      }
+    } else if (element != null && Initializers.isConstructorRedirect(node)) {
+      visitStaticSend(node);
+    } else if (Elements.isClosureSend(node, element)) {
+      if (element != null) {
+        collector.tryMakeLocalPlaceholder(element, node.selector);
+      }
     } else {
-      collector.tryMakeMemberPlaceholder(node.selector);
+      if (Elements.isUnresolved(element)) {
+        if (element == null) {
+          // Example: f() with 'f' unbound.
+          // This can only happen inside an instance method.
+          visitDynamicSend(node);
+        } else {
+          visitStaticSend(node);
+        }
+      } else if (element.isInstanceMember) {
+        // Example: f() with 'f' bound to instance method.
+        visitDynamicSend(node);
+      } else if (!element.isInstanceMember) {
+        // Example: A.f() or f() with 'f' bound to a static function.
+        // Also includes new A() or new A.named() which is treated like a
+        // static call to a factory.
+        visitStaticSend(node);
+      }
     }
   }
 
   visitDynamicSend(Send node) {
     final element = elements[node];
     if (element == null || !element.isErroneous) {
       collector.tryMakeMemberPlaceholder(node.selector);
     }
   }
 
-  visitClosureSend(Send node) {
-    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) {
       collector.tryMakeMemberPlaceholder(node.selector);
     } else if (element.isErroneous) {
       collector.makeUnresolvedPlaceholder(node);
       return;
     } else if (element.isPrefix) {
       // Node is prefix part in case of source 'lib.somesetter = 5;'
       collector.makeErasePrefixPlaceholder(node);
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Unqualified or prefixed top level or static.
       collector.makeElementPlaceholder(node.selector, element);
     } else if (!element.isTopLevel) {
       if (element.isInstanceMember) {
         collector.tryMakeMemberPlaceholder(node.selector);
       } else {
         // 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);
         }
       }
     }
   }
 
-  visitAssertSend(node) {
-    visitStaticSend(node);
-  }
-
   visitStaticSend(Send node) {
     Element element = elements[node];
     collector.mirrorRenamer.registerStaticSend(
         collector.currentElement, element, node);
 
     if (Elements.isUnresolved(element)
         || elements.isAssert(node)
         || element.isDeferredLoaderGetter) {
       return;
     }
@@ skipping 14 matching lines @@
       assert(elements[node.receiver].isPrefix);
       // Hack: putting null into map overrides receiver of original node.
       collector.makeErasePrefixPlaceholder(node.receiver);
     }
   }
 
   internalError(Spannable node, String reason) {
     collector.internalError(reason, node: node);
   }
 
-  visitTypePrefixSend(Send node) {
-    collector.makeElementPlaceholder(node, elements[node]);
-  }
-
-  visitTypeLiteralSend(Send node) {
-    DartType type = elements.getTypeLiteralType(node);
-    if (!type.isDynamic) {
-      if (type is TypeVariableType) {
-        collector.makeTypeVariablePlaceholder(node.selector, type);
-      } else {
-        collector.makeTypePlaceholder(node.selector, type);
-      }
-    }
+  visitNode(Node node) {
+    internalError(node, "Unhandled node");
   }
 }
 
 class PlaceholderCollector extends Visitor {
   final DiagnosticListener listener;
   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>();
@@ skipping 536 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }