Deprecate ResolvedVisitor.visitOperatorSend.

pkg/compiler/lib/src/inferrer/inferrer_visitor.dart

 // Copyright (c) 2013, 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 inferrer_visitor;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../dart2jslib.dart' hide Selector, TypedSelector;
 import '../dart_types.dart';
 import '../elements/elements.dart';
+import '../resolution/operators.dart';
 import '../tree/tree.dart';
 import '../universe/universe.dart';
 import '../util/util.dart';
 import '../types/types.dart' show TypeMask;
 import '../types/constants.dart' show computeTypeMask;
 import 'dart:collection' show IterableMixin;
 
 /**
  * The interface [InferrerVisitor] will use when working on types.
  */
@@ skipping 954 matching lines @@
             narrow(receiverElement, objectType, node);
           }
           if (Elements.isLocal(argumentElement)) {
             narrow(argumentElement, objectType, node);
           }
         }
       }
     }
   }
 
-  T visitOperatorSend(Send node) {
-    Operator op = node.selector;
-    if ("[]" == op.source) {
-      return visitDynamicSend(node);
-    } else if ("&&" == op.source) {
-      conditionIsSimple = false;
-      bool oldAccumulateIsChecks = accumulateIsChecks;
-      List<Send> oldIsChecks = isChecks;
-      if (!accumulateIsChecks) {
-        accumulateIsChecks = true;
-        isChecks = <Send>[];
+  @override
+  T visitIndex(Send node, Node receiver, Node index, _) {
+    return visitDynamicSend(node);
+  }
+
+  @override
+  T visitLogicalAnd(Send node, Node left, Node right, _) {
+    conditionIsSimple = false;
+    bool oldAccumulateIsChecks = accumulateIsChecks;
+    List<Send> oldIsChecks = isChecks;
+    if (!accumulateIsChecks) {
+      accumulateIsChecks = true;
+      isChecks = <Send>[];
+    }
+    visit(left);
+    LocalsHandler<T> saved = locals;
+    locals = new LocalsHandler<T>.from(locals, node);
+    updateIsChecks(isChecks, usePositive: true);
+    LocalsHandler<T> narrowed;
+    if (oldAccumulateIsChecks) {
+      narrowed = new LocalsHandler<T>.topLevelCopyOf(locals);
+    } else {
+      accumulateIsChecks = false;
+      isChecks = oldIsChecks;
+    }
+    visit(right);
+    if (oldAccumulateIsChecks) {
+
+      bool invalidatedInRightHandSide (Send test) {
+        Element receiver = elements[test.receiver];
+        if (receiver is LocalElement) {
+          return narrowed.locals[receiver] != locals.locals[receiver];
+        }
+        return false;
       }
-      visit(node.receiver);
-      LocalsHandler<T> saved = locals;
-      locals = new LocalsHandler<T>.from(locals, node);
-      updateIsChecks(isChecks, usePositive: true);
-      LocalsHandler<T> narrowed;
-      if (oldAccumulateIsChecks) {
-        narrowed = new LocalsHandler<T>.topLevelCopyOf(locals);
-      } else {
-        accumulateIsChecks = false;
-        isChecks = oldIsChecks;
-      }
-      visit(node.arguments.head);
-      if (oldAccumulateIsChecks) {
 
-        bool invalidatedInRightHandSide (Send test) {
-          Element receiver = elements[test.receiver];
-          if (receiver is LocalElement) {
-            return narrowed.locals[receiver] != locals.locals[receiver];
-          }
-          return false;
-        }
+      isChecks.removeWhere(invalidatedInRightHandSide);
+    }
+    saved.mergeDiamondFlow(locals, null);
+    locals = saved;
+    return types.boolType;
+  }
 
-        isChecks.removeWhere(invalidatedInRightHandSide);
-      }
-      saved.mergeDiamondFlow(locals, null);
-      locals = saved;
-      return types.boolType;
-    } else if ("||" == op.source) {
-      conditionIsSimple = false;
-      List<Send> tests = <Send>[];
-      bool isSimple = handleCondition(node.receiver, tests);
-      LocalsHandler<T> saved = locals;
-      locals = new LocalsHandler<T>.from(locals, node);
-      if (isSimple) updateIsChecks(tests, usePositive: false);
-      bool oldAccumulateIsChecks = accumulateIsChecks;
-      accumulateIsChecks = false;
-      visit(node.arguments.head);
-      accumulateIsChecks = oldAccumulateIsChecks;
-      saved.mergeDiamondFlow(locals, null);
-      locals = saved;
-      return types.boolType;
-    } else if ("!" == op.source) {
-      bool oldAccumulateIsChecks = accumulateIsChecks;
-      accumulateIsChecks = false;
-      node.visitChildren(this);
-      accumulateIsChecks = oldAccumulateIsChecks;
-      return types.boolType;
-    } else if ("is" == op.source) {
-      potentiallyAddIsCheck(node);
-      node.visitChildren(this);
-      return types.boolType;
-    } else if ("as" == op.source) {
-      T receiverType = visit(node.receiver);
-      DartType type = elements.getType(node.arguments.head);
-      return types.narrowType(receiverType, type);
-    } else if (node.argumentsNode is Prefix) {
-      // Unary operator.
-      return visitDynamicSend(node);
-    } else if ('===' == op.source
-               || '!==' == op.source) {
-      node.visitChildren(this);
-      return types.boolType;
-    } else if ('!=' == op.source) {
-      visitDynamicSend(node);
-      return types.boolType;
-    } else {
-      // Binary operator.
-      return visitDynamicSend(node);
-    }
+  @override
+  T visitLogicalOr(Send node, Node left, Node right, _) {
+    conditionIsSimple = false;
+    List<Send> tests = <Send>[];
+    bool isSimple = handleCondition(left, tests);
+    LocalsHandler<T> saved = locals;
+    locals = new LocalsHandler<T>.from(locals, node);
+    if (isSimple) updateIsChecks(tests, usePositive: false);
+    bool oldAccumulateIsChecks = accumulateIsChecks;
+    accumulateIsChecks = false;
+    visit(right);
+    accumulateIsChecks = oldAccumulateIsChecks;
+    saved.mergeDiamondFlow(locals, null);
+    locals = saved;
+    return types.boolType;
+  }
+
+  @override
+  T visitNot(Send node, Node expression, _) {
+    bool oldAccumulateIsChecks = accumulateIsChecks;
+    accumulateIsChecks = false;
+    visit(expression);
+    accumulateIsChecks = oldAccumulateIsChecks;
+    return types.boolType;
+  }
+
+  @override
+  T visitIs(Send node, Node expression, DartType type, _) {
+    potentiallyAddIsCheck(node);
+    visit(expression);
+    return types.boolType;
+  }
+
+  @override
+  T visitIsNot(Send node, Node expression, DartType type, _) {
+    potentiallyAddIsCheck(node);
+    visit(expression);
+    return types.boolType;
+  }
+
+  @override
+  T visitAs(Send node, Node expression, DartType type, _) {
+    T receiverType = visit(expression);
+    return types.narrowType(receiverType, type);
+  }
+
+  @override
+  T visitUnary(Send node, UnaryOperator operator, Node expression, _) {
+    return visitDynamicSend(node);
+  }
+
+  @override
+  T visitNotEquals(Send node, Node left, Node right, _) {
+    visitDynamicSend(node);
+    return types.boolType;
+  }
+
+  @override
+  T visitEquals(Send node, Node left, Node right, _) {
+    return visitDynamicSend(node);
+  }
+
+  @override
+  T visitBinary(Send node, Node left, BinaryOperator operator, Node right, _) {
+    return visitDynamicSend(node);
   }
 
   // Because some nodes just visit their children, we may end up
   // visiting a type annotation, that may contain a send in case of a
   // prefixed type. Therefore we explicitly visit the type annotation
   // to avoid confusing the [ResolvedVisitor].
   visitTypeAnnotation(TypeAnnotation node) {}
 
   T visitConditional(Conditional node) {
     List<Send> tests = <Send>[];
@@ skipping 221 matching lines @@
 
   T visitContinueStatement(ContinueStatement node) {
     JumpTarget target = elements.getTargetOf(node);
     locals.seenBreakOrContinue = true;
     // Do a deep-copy of the locals, because the code following the
     // continue will change them.
     continuesFor[target].add(new LocalsHandler<T>.deepCopyOf(locals));
     return null;
   }
 
-  void internalError(Spannable node, String reason) {
+  internalError(Spannable node, String reason) {
     compiler.internalError(node, reason);
   }
 
   T visitSwitchStatement(SwitchStatement node) {
     visit(node.parenthesizedExpression);
 
     setupBreaksAndContinues(elements.getTargetDefinition(node));
     if (Elements.switchStatementHasContinue(node, elements)) {
       void forEachLabeledCase(void action(JumpTarget target)) {
         for (SwitchCase switchCase in node.cases) {
@@ skipping 58 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }