Start to compute SendStructure in resolution.

pkg/compiler/lib/src/resolution/members.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 resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
   /// Iterables of the dependencies that this [TreeElement] records of
   /// [analyzedElement].
   Iterable<Element> get allElements;
   void forEachConstantNode(f(Node n, ConstantExpression c));
 
   /// A set of additional dependencies.  See [registerDependency] below.
   Iterable<Element> get otherDependencies;
 
   Element operator[](Node node);
 
+  SendStructure getSendStructure(Send send);
+
   // TODO(johnniwinther): Investigate whether [Node] could be a [Send].
   Selector getSelector(Node node);
   Selector getGetterSelectorInComplexSendSet(SendSet node);
   Selector getOperatorSelectorInComplexSendSet(SendSet node);
   DartType getType(Node node);
   void setSelector(Node node, Selector selector);
   void setGetterSelectorInComplexSendSet(SendSet node, Selector selector);
   void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector);
 
   /// Returns the for-in loop variable for [node].
@@ skipping 62 matching lines @@
   Map<Node, DartType> _types;
   Setlet<Node> _superUses;
   Setlet<Element> _otherDependencies;
   Map<Node, ConstantExpression> _constants;
   Map<VariableElement, List<Node>> _potentiallyMutated;
   Map<Node, Map<VariableElement, List<Node>>> _potentiallyMutatedIn;
   Map<VariableElement, List<Node>> _potentiallyMutatedInClosure;
   Map<Node, Map<VariableElement, List<Node>>> _accessedByClosureIn;
   Setlet<Element> _elements;
   Setlet<Send> _asserts;
+  Maplet<Send, SendStructure> _sendStructureMap;
 
   /// Map from nodes to the targets they define.
   Map<Node, JumpTarget> _definedTargets;
 
   /// Map from goto statements to their targets.
   Map<GotoStatement, JumpTarget> _usedTargets;
 
   /// Map from labels to their label definition.
   Map<Label, LabelDefinition> _definedLabels;
 
@@ skipping 22 matching lines @@
 
     if (_elements == null) {
       _elements = new Setlet<Element>();
     }
     _elements.add(element);
     setTreeElement(node, element);
   }
 
   operator [](Node node) => getTreeElement(node);
 
+  SendStructure getSendStructure(Send send) {
+    if (_sendStructureMap == null) return null;
+    return _sendStructureMap[send];
+  }
+
+  void setSendStructure(Send send, SendStructure sendStructure) {
+    if (_sendStructureMap == null) {
+      _sendStructureMap = new Maplet<Send, SendStructure>();
+    }
+    _sendStructureMap[send] = sendStructure;
+  }
+
   void setType(Node node, DartType type) {
     if (_types == null) {
       _types = new Maplet<Node, DartType>();
     }
     _types[node] = type;
   }
 
   DartType getType(Node node) => _types != null ? _types[node] : null;
 
   Iterable<Node> get superUses {
@@ skipping 2417 matching lines @@
   }
 
   ResolutionResult resolveSend(Send node) {
     Selector selector = resolveSelector(node, null);
     if (node.isSuperCall) registry.registerSuperUse(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
       if (selector.isAssert) {
+        SendStructure sendStructure = const AssertStructure();
         if (selector.argumentCount != 1) {
           error(node.selector,
                 MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
                 {'argumentCount': selector.argumentCount});
+          sendStructure = const InvalidAssertStructure();
         } else if (selector.namedArgumentCount != 0) {
           error(node.selector,
                 MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
                 {'argumentCount': selector.namedArgumentCount});
+          sendStructure = const InvalidAssertStructure();
         }
         registry.registerAssert(node);
+        registry.registerSendStructure(node, sendStructure);
         return const AssertResult();
       }
 
       return node.selector.accept(this);
     }
 
     var oldCategory = allowedCategory;
     allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
     ResolutionResult resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
@@ skipping 290 matching lines @@
           for (Node scope in promotionScope) {
             registry.setAccessedByClosureIn(scope, target, node);
           }
         }
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source;
-      if (identical(operatorString, 'is')) {
+      SendStructure sendStructure;
+      if (operatorString == 'is') {
         // TODO(johnniwinther): Use seen type tests to avoid registration of
         // mutation/access to unpromoted variables.
         DartType type =
             resolveTypeAnnotation(node.typeAnnotationFromIsCheckOrCast);
         if (type != null) {
+          sendStructure = node.isIsNotCheck
+              ? new IsNotStructure(type) : new IsStructure(type);
           registry.registerIsCheck(type);
         }
         resolvedArguments = true;
       } else if (identical(operatorString, 'as')) {
         DartType type = resolveTypeAnnotation(node.arguments.head);
         if (type != null) {
+          sendStructure = new AsStructure(type);
           registry.registerAsCheck(type);
         }
         resolvedArguments = true;
       } else if (identical(operatorString, '&&')) {
         doInPromotionScope(node.arguments.head,
             () => resolveArguments(node.argumentsNode));
+        sendStructure = const LogicalAndStructure();
         resolvedArguments = true;
+      } else if (operatorString == '||') {
+        sendStructure = const LogicalOrStructure();
+      }
+      if (sendStructure != null) {
+        registry.registerSendStructure(node, sendStructure);
       }
     }
 
     if (!resolvedArguments) {
       resolveArguments(node.argumentsNode);
     }
 
     // If the selector is null, it means that we will not be generating
     // code for this as a send.
     Selector selector = registry.getSelector(node);
@@ skipping 2235 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }