Compute more SendStructures on ResolverVisitor.

pkg/compiler/lib/src/resolution/send_resolver.dart

 // Copyright (c) 2015, 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 dart2js.semantics_visitor;
 
 enum SendStructureKind {
   GET,
   SET,
   INVOKE,
@@ skipping 251 matching lines @@
       }
     } else if (!node.isPropertyAccess) {
       kind = SendStructureKind.INVOKE;
     } else {
       kind = SendStructureKind.GET;
     }
 
     if (node.isOperator) {
       String operatorText = node.selector.asOperator().source;
       if (node.arguments.isEmpty) {
-        unaryOperator = UnaryOperator.parse(operatorText);
-        if (unaryOperator != null) {
-          switch (unaryOperator.kind) {
-            case UnaryOperatorKind.NOT:
-              kind = SendStructureKind.NOT;
-              break;
-            default:
-              kind = SendStructureKind.UNARY;
-              break;
-          }
-        } else {
-          return const InvalidUnaryStructure();
-        }
+        return internalError(node, "Unexpected unary $operatorText.");
       } else {
         binaryOperator = BinaryOperator.parse(operatorText);
         if (binaryOperator != null) {
           switch (binaryOperator.kind) {
             case BinaryOperatorKind.EQ:
               kind = SendStructureKind.EQ;
-              break;
+              return internalError(node, "Unexpected binary $kind.");

[karlklose, 2015/05/29 11:12:14]

Move 'return internalError' after the switch?

[Johnni Winther, 2015/05/29 12:47:54]

We still need to index in compounds.

             case BinaryOperatorKind.NOT_EQ:
-              if (node.isSuperCall) {
-                // `super != foo` is a compile-time error.
-                return const InvalidBinaryStructure();
-              }
               kind = SendStructureKind.NOT_EQ;
-              break;
+              return internalError(node, "Unexpected binary $kind.");
             case BinaryOperatorKind.INDEX:
               if (node.isPrefix) {
                 kind = SendStructureKind.INDEX_PREFIX;
               } else if (node.isPostfix) {
                 kind = SendStructureKind.INDEX_POSTFIX;
               } else if (node.arguments.tail.isEmpty) {
                 // a[b]
                 kind = SendStructureKind.INDEX;
+                return internalError(node, "Unexpected binary $kind.");
               } else {
                 if (kind == SendStructureKind.COMPOUND) {
                   // a[b] += c
                   kind = SendStructureKind.COMPOUND_INDEX_SET;
                 } else {
                   // a[b] = c
                   kind = SendStructureKind.INDEX_SET;
                 }
               }
               break;
             default:
               kind = SendStructureKind.BINARY;
-              break;
+              return internalError(node, "Unexpected binary $kind.");
           }
         } else {
-          return const InvalidBinaryStructure();
+          return internalError(
+              node, "Unexpected invalid binary $operatorText.");
         }
       }
     }
     AccessSemantics semantics = computeAccessSemantics(
         node,
         isSet: kind == SendStructureKind.SET,
         isInvoke: kind == SendStructureKind.INVOKE,
         isCompound: kind == SendStructureKind.COMPOUND ||
                     kind == SendStructureKind.COMPOUND_INDEX_SET ||
                     kind == SendStructureKind.PREFIX ||
@@ skipping 605 matching lines @@
       return internalError(node, "Unexpected variable $element.");
     }
     if (element.isConst) {
       ConstantExpression constant = elements.getConstant(element.initializer);
       return new ConstantVariableStructure(kind, node, element, constant);
     } else {
       return new NonConstantVariableStructure(kind, node, element);
     }
   }
 }