Implement ResolvedVisitor using SemanticSendVisitor.

pkg/compiler/lib/src/ssa/builder.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 ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 959 matching lines @@
     for (JumpTarget target in targetIndexMap.keys) {
       builder.jumpTargets.remove(target);
     }
     super.close();
   }
 }
 
 /**
  * This class builds SSA nodes for functions represented in AST.
  */
-class SsaBuilder extends ResolvedVisitor {
+class SsaBuilder extends NewResolvedVisitor {
   final Compiler compiler;
   final JavaScriptBackend backend;
   final ConstantSystem constantSystem;
   final CodegenWorkItem work;
   final RuntimeTypes rti;
   final bool generateSourceMap;
   bool inLazyInitializerExpression = false;
 
   /* This field is used by the native handler. */
   final NativeEmitter nativeEmitter;
@@ skipping 2132 matching lines @@
         isAnd: ("&&" == op.source));
   }
 
   void visitLogicalNot(ast.Send node) {
     assert(node.argumentsNode is ast.Prefix);
     visit(node.receiver);
     HNot not = new HNot(popBoolified(), backend.boolType);
     pushWithPosition(not, node);
   }
 
-  void visitUnary(ast.Send node, ast.Operator op) {
+  void visitUnarySend(ast.Send node, ast.Operator op) {
     assert(node.argumentsNode is ast.Prefix);
     visit(node.receiver);
     assert(!identical(op.token.kind, PLUS_TOKEN));
     HInstruction operand = pop();
 
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       UnaryOperation operation = constantSystem.lookupUnary(op.source);
       HConstant constant = operand;
       ConstantValue folded = operation.fold(constant.constant);
       if (folded != null) {
         stack.add(graph.addConstant(folded, compiler));
         return;
       }
     }
 
     pushInvokeDynamic(node, elements.getSelector(node), [operand]);
   }
 
-  void visitBinary(HInstruction left,
-                   ast.Operator op,
-                   HInstruction right,
-                   Selector selector,
-                   ast.Send send) {
+  void visitBinarySend(HInstruction left,
+                       ast.Operator op,
+                       HInstruction right,
+                       Selector selector,
+                       ast.Send send) {
     switch (op.source) {
       case "===":
         pushWithPosition(
             new HIdentity(left, right, null, backend.boolType), op);
         return;
       case "!==":
         HIdentity eq = new HIdentity(left, right, null, backend.boolType);
         add(eq);
         pushWithPosition(new HNot(eq, backend.boolType), op);
         return;
@@ skipping 247 matching lines @@
   visitOperatorSend(ast.Send node) {
     ast.Operator op = node.selector;
     if ("[]" == op.source) {
       visitDynamicSend(node);
     } else if ("&&" == op.source ||
                "||" == op.source) {
       visitLogicalAndOr(node, op);
     } else if ("!" == op.source) {
       visitLogicalNot(node);
     } else if (node.argumentsNode is ast.Prefix) {
-      visitUnary(node, op);
+      visitUnarySend(node, op);
     } else if ("is" == op.source) {
       visitIsSend(node);
     } else if ("as" == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
       DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
       if (type.isMalformed) {
         ErroneousElement element = type.element;
         generateTypeError(node, element.message);
       } else {
         HInstruction converted = buildTypeConversion(
             expression,
             localsHandler.substInContext(type),
             HTypeConversion.CAST_TYPE_CHECK);
         if (converted != expression) add(converted);
         stack.add(converted);
       }
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
       var left = pop();
-      visitBinary(left, op, right, elements.getSelector(node), node);
+      visitBinarySend(left, op, right, elements.getSelector(node), node);
     }
   }
 
   void visitIsSend(ast.Send node) {
     visit(node.receiver);
     HInstruction expression = pop();
     bool isNot = node.isIsNotCheck;
     DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
     HInstruction instruction = buildIsNode(node, type, expression);
     if (isNot) {
@@ skipping 1068 matching lines @@
       DartType instance = type.asInstanceOf(supertype.element);
       compiler.types.checkTypeVariableBounds(instance,
           addTypeVariableBoundCheck);
       if (definitelyFails) {
         return true;
       }
     }
     return false;
   }
 
-  visitAssert(node) {
+  visitAssertSend(node) {
     if (!compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull(compiler));
       return;
     }
     // TODO(johnniwinther): Don't handle assert like a regular static call.
     // It breaks the selector name check since the assert helper method cannot
     // be called `assert` and therefore does not match the selector like a
     // regular method.
     visitStaticSend(node);
   }
@@ skipping 79 matching lines @@
       type = localsHandler.substInContext(type);
       HInstruction value = analyzeTypeArgument(type);
       pushInvokeStatic(node,
                        backend.getRuntimeTypeToString(),
                        [value],
                        backend.stringType);
       pushInvokeStatic(node,
                        backend.getCreateRuntimeType(),
                        [pop()]);
     } else {
-      internalError('unexpected type kind ${type.kind}', node: node);
+      internalError(node, 'unexpected type kind ${type.kind}');
     }
     if (node.isCall) {
       // This send is of the form 'e(...)', where e is resolved to a type
       // reference. We create a regular closure call on the result of the type
       // reference instead of creating a NoSuchMethodError to avoid pulling it
       // in if it is not used (e.g., in a try/catch).
       HInstruction target = pop();
       Selector selector = elements.getSelector(node);
       List<HInstruction> inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       Selector closureSelector = new Selector.callClosureFrom(selector);
       push(new HInvokeClosure(closureSelector, inputs, backend.dynamicType));
     }
   }
 
   visitGetterSend(ast.Send node) {
     generateIsDeferredLoadedCheckIfNeeded(node);
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
-  internalError(String reason, {ast.Node node}) {
+  internalError(Spannable node, String reason) {
     compiler.internalError(node, reason);
   }
 
   void generateError(ast.Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(message);
     pushInvokeStatic(node, helper, [errorMessage]);
   }
 
   void generateRuntimeError(ast.Node node, String message) {
     generateError(node, message, backend.getThrowRuntimeError());
@@ skipping 244 matching lines @@
                                  HInstruction receiver,
                                  Link<ast.Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
       rhs = graph.addConstantInt(1, compiler);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
-    visitBinary(receiver, node.assignmentOperator, rhs,
-                elements.getOperatorSelectorInComplexSendSet(node), node);
+    visitBinarySend(receiver, node.assignmentOperator, rhs,
+                    elements.getOperatorSelectorInComplexSendSet(node), node);
   }
 
   visitSendSet(ast.SendSet node) {
     generateIsDeferredLoadedCheckIfNeeded(node);
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType) {
       ast.Identifier selector = node.selector;
       generateThrowNoSuchMethod(node, selector.source,
                                 argumentNodes: node.arguments);
       return;
@@ skipping 2008 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }