Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/src/closure_environment.dart

 // Copyright (c) 2015, the Fletch 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.md file.
 
 library fletchc.closure_environment;
 
-import 'package:compiler/src/util/util.dart' show
-    SpannableAssertionFailure;
-
 import 'package:compiler/src/resolution/semantic_visitor.dart';
 
 import 'package:compiler/src/resolution/operators.dart' show
     AssignmentOperator,
     BinaryOperator,
     IncDecOperator,
     UnaryOperator;
 
 import 'package:compiler/src/elements/elements.dart';
-import 'package:compiler/src/resolution/resolution.dart';
+import 'package:compiler/src/resolution/tree_elements.dart';
+import 'package:compiler/src/resolution/send_resolver.dart';
 import 'package:compiler/src/tree/tree.dart';
-import 'package:compiler/src/universe/universe.dart';
-import 'package:compiler/src/util/util.dart' show Spannable;
+import 'package:compiler/src/universe/selector.dart';
+import 'package:compiler/src/universe/call_structure.dart';
+import 'package:compiler/src/diagnostics/spannable.dart' show
+    Spannable,
+    SpannableAssertionFailure;
 import 'package:compiler/src/dart_types.dart';
 
 enum CaptureMode {
   /**
    * If a local is marked [ByValue], the local is read in closures.
    */
   ByValue,
 
   /**
    * If a local is marked [ByReference], a write to the local can be observed
@@ skipping 28 matching lines @@
   final Map<FunctionElement, ClosureInfo> closures =
       <FunctionElement, ClosureInfo>{};
 
   bool shouldBeBoxed(element) => captured[element] == CaptureMode.ByReference;
 }
 
 class ClosureVisitor
     extends SemanticVisitor
     with TraversalSendMixin,
          SemanticSendResolvedMixin,
-         SendResolverMixin,
          BaseImplementationOfLocalsMixin,
          VariableBulkMixin,
          ParameterBulkMixin,
          FunctionBulkMixin,
          ConstructorBulkMixin,
          InitializerBulkMixin
     implements SemanticSendVisitor, SemanticDeclarationVisitor {
   final ClosureEnvironment closureEnvironment = new ClosureEnvironment();
 
   /**
@@ skipping 11 matching lines @@
   ClosureVisitor(this.element, TreeElements elements)
       : super(elements);
 
   SemanticSendVisitor get sendVisitor => this;
   SemanticDeclarationVisitor get declVisitor => this;
 
   ClosureEnvironment compute() {
     assert(element.memberContext == element);
     assert(currentElement == null);
     currentElement = element;
-    if (element.node != null) element.node.accept(this);
+    if (element.node != null) element.resolvedAst.node.accept(this);
     assert(currentElement == element);
     return closureEnvironment;
   }
 
   void visitNode(Node node) {
     node.visitChildren(this);
   }
 
   void visitVariableDefinitions(VariableDefinitions node) {
     for (Node definition in node.definitions) {
       VariableElement element = elements[definition];
       Expression initializer = element.initializer;
       if (initializer != null) initializer.accept(this);
     }
   }
 
   void visitFunctionExpression(FunctionExpression node) {
     ExecutableElement oldElement = currentElement;
-    currentElement = elements[node];
+    currentElement = elements.getFunctionDefinition(node);
     if (currentElement != element) {
       ClosureInfo info = new ClosureInfo();
       closureEnvironment.closures[currentElement] = info;
     }
     if (currentElement.isConstructor) {
       inInitializers = true;
       visitInitializers(node, null);
       inInitializers = false;
     }
     node.body.accept(this);
@@ skipping 87 matching lines @@
   void handleLocalInvoke(
       Send node,
       LocalElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     markUsed(element, CaptureMode.ByValue);
     arguments.accept(this);
   }
 
-  void visitThisPropertySet(Send node, Selector selector, Node rhs, _) {
+  void visitThisPropertySet(Send node, Name name, Node rhs, _) {
     markThisUsed();
-    super.visitThisPropertySet(node, selector, rhs, null);
+    super.visitThisPropertySet(node, name, rhs, null);
   }
 
   void visitLocalVariablePrefix(
       SendSet node,
       LocalVariableElement element,
       IncDecOperator operator,
       _) {
     markUsed(element, CaptureMode.ByReference);
   }
 
   void visitLocalVariablePostfix(
       SendSet node,
       LocalVariableElement element,
       IncDecOperator operator,
       _) {
     markUsed(element, CaptureMode.ByReference);
   }
 
   void visitThisPropertyInvoke(
       Send node,
       NodeList arguments,
       Selector selector,
       _) {
     markThisUsed();
     arguments.accept(this);
   }
 
   void visitThisPropertyGet(
       Send node,
-      Selector selector,
+      Name name,
       _) {
     markThisUsed();
   }
 
   void visitThisGet(Node node, _) {
     markThisUsed();
   }
 
   void visitIs(Send node, Node expression, DartType type, _) {
     // TODO(ajohnsen): Type is used ByValue.
     expression.accept(this);
   }
 
   void visitIsNot(Send node, Node expression, DartType type, _) {
     // TODO(ajohnsen): Type is used ByValue.
     expression.accept(this);
   }
 
   void visitAs(Send node, Node expression, DartType type, _) {
     // TODO(ajohnsen): Type is used ByValue.
     expression.accept(this);
   }
 
-  void visitAssert(Send node, Node expression, _) {
+  void visitAssert(Assert node) {
     // TODO(ajohnsen): Only visit in checked mode.
-    expression.accept(this);
+    node.condition.accept(this);
+    node.message?.accept(this);
   }
 
   void visitLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       _) {
     markUsed(variable, CaptureMode.ByReference);
     super.visitLocalVariableCompound(node, variable, operator, rhs, null);
@@ skipping 161 matching lines @@
       FunctionElement function,
       Node index,
       Node rhs,
       _) {
     markThisUsed();
     super.visitSuperIndexSet(node, function, index, rhs, null);
   }
 
   void visitThisPropertyCompound(
       Send node,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     markThisUsed();
     super.visitThisPropertyCompound(
-        node, operator, rhs, getterSelector, setterSelector, null);
+        node, name, operator, rhs, null);
   }
 
   void visitParameterCompound(
       Send node,
       ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       _) {
     markUsed(parameter, CaptureMode.ByReference);
     super.visitParameterCompound(node, parameter, operator, rhs, null);
@@ skipping 74 matching lines @@
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       _) {
     markUsed(parameter, CaptureMode.ByReference);
     super.visitParameterPrefix(node, parameter, operator, null);
   }
 
   void visitThisPropertyPrefix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     markThisUsed();
     super.visitThisPropertyPrefix(
-        node, operator, getterSelector, setterSelector, null);
+        node, name, operator, null);
   }
 
   void visitSuperFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       _) {
     markThisUsed();
     super.visitSuperFieldPrefix(node, field, operator, null);
   }
@@ skipping 62 matching lines @@
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       _) {
     markUsed(parameter, CaptureMode.ByReference);
     super.visitParameterPostfix(node, parameter, operator, null);
   }
 
   void visitThisPropertyPostfix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     markThisUsed();
     super.visitThisPropertyPostfix(
-        node, operator, getterSelector, setterSelector, null);
+        node, name, operator, null);
   }
 
   void visitSuperFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       _) {
     markThisUsed();
     super.visitSuperFieldPostfix(node, field, operator, null);
   }
@@ skipping 63 matching lines @@
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       _) {
     markThisUsed();
     super.visitSuperIndexPrefix(
         node, indexFunction, indexSetFunction, index, operator, null);
   }
 
+  @override
+  void visitTypeAnnotation(TypeAnnotation node) {
+  // This is to avoid the inherited implementation that visits children and
+  // throws when encountering anything unresolved.
+  }
+
   void handleImmutableLocalSet(
       SendSet node,
       LocalElement element,
       Node rhs,
       _) {
     apply(rhs);
   }
 
   void bulkHandleNode(Node node, String message, _) {
   }
 
   void applyInitializers(FunctionExpression initializers, _) {
   }
 
   void applyParameters(NodeList parameters, _) {
   }
 }