dartfmt pkg/compiler

pkg/compiler/lib/src/resolution/tree_elements.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.
 
 library dart2js.resolution.tree_elements;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/source_span.dart';
 import '../elements/elements.dart';
-import '../types/types.dart' show
-    TypeMask;
+import '../types/types.dart' show TypeMask;
 import '../tree/tree.dart';
 import '../util/util.dart';
-import '../universe/selector.dart' show
-    Selector;
+import '../universe/selector.dart' show Selector;
 
-import 'secret_tree_element.dart' show
-    getTreeElement,
-    setTreeElement;
+import 'secret_tree_element.dart' show getTreeElement, setTreeElement;
 import 'send_structure.dart';
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<SourceSpan> get superUses;
 
   void forEachConstantNode(f(Node n, ConstantExpression c));
 
-  Element operator[](Node node);
+  Element operator [](Node node);
   Map<Node, DartType> get typesCache;
 
   /// Returns the [SendStructure] that describes the semantics of [node].
   SendStructure getSendStructure(Send node);
 
   /// Returns the [NewStructure] that describes the semantics of [node].
   NewStructure getNewStructure(NewExpression node);
 
   // TODO(johnniwinther): Investigate whether [Node] could be a [Send].
   Selector getSelector(Node node);
@@ skipping 239 matching lines @@
 
   List<Node> getPotentialMutationsIn(Node node, VariableElement element) {
     if (_potentiallyMutatedIn == null) return const <Node>[];
     Map<VariableElement, List<Node>> mutationsIn = _potentiallyMutatedIn[node];
     if (mutationsIn == null) return const <Node>[];
     List<Node> mutations = mutationsIn[element];
     if (mutations == null) return const <Node>[];
     return mutations;
   }
 
-  void registerPotentialMutationIn(Node contextNode, VariableElement element,
-                                    Node mutationNode) {
+  void registerPotentialMutationIn(
+      Node contextNode, VariableElement element, Node mutationNode) {
     if (_potentiallyMutatedIn == null) {
       _potentiallyMutatedIn =
           new Maplet<Node, Map<VariableElement, List<Node>>>();
     }
     Map<VariableElement, List<Node>> mutationMap =
-        _potentiallyMutatedIn.putIfAbsent(contextNode,
-          () => new Maplet<VariableElement, List<Node>>());
+        _potentiallyMutatedIn.putIfAbsent(
+            contextNode, () => new Maplet<VariableElement, List<Node>>());
     mutationMap.putIfAbsent(element, () => <Node>[]).add(mutationNode);
   }
 
   List<Node> getPotentialMutationsInClosure(VariableElement element) {
     if (_potentiallyMutatedInClosure == null) return const <Node>[];
     List<Node> mutations = _potentiallyMutatedInClosure[element];
     if (mutations == null) return const <Node>[];
     return mutations;
   }
 
-  void registerPotentialMutationInClosure(VariableElement element,
-                                          Node mutationNode) {
+  void registerPotentialMutationInClosure(
+      VariableElement element, Node mutationNode) {
     if (_potentiallyMutatedInClosure == null) {
       _potentiallyMutatedInClosure = new Maplet<VariableElement, List<Node>>();
     }
-    _potentiallyMutatedInClosure.putIfAbsent(
-        element, () => <Node>[]).add(mutationNode);
+    _potentiallyMutatedInClosure
+        .putIfAbsent(element, () => <Node>[])
+        .add(mutationNode);
   }
 
   List<Node> getAccessesByClosureIn(Node node, VariableElement element) {
     if (_accessedByClosureIn == null) return const <Node>[];
     Map<VariableElement, List<Node>> accessesIn = _accessedByClosureIn[node];
     if (accessesIn == null) return const <Node>[];
     List<Node> accesses = accessesIn[element];
     if (accesses == null) return const <Node>[];
     return accesses;
   }
 
-  void setAccessedByClosureIn(Node contextNode, VariableElement element,
-                              Node accessNode) {
+  void setAccessedByClosureIn(
+      Node contextNode, VariableElement element, Node accessNode) {
     if (_accessedByClosureIn == null) {
       _accessedByClosureIn = new Map<Node, Map<VariableElement, List<Node>>>();
     }
     Map<VariableElement, List<Node>> accessMap =
-        _accessedByClosureIn.putIfAbsent(contextNode,
-          () => new Maplet<VariableElement, List<Node>>());
+        _accessedByClosureIn.putIfAbsent(
+            contextNode, () => new Maplet<VariableElement, List<Node>>());
     accessMap.putIfAbsent(element, () => <Node>[]).add(accessNode);
   }
 
   String toString() => 'TreeElementMapping($analyzedElement)';
 
   void forEachConstantNode(f(Node n, ConstantExpression c)) {
     if (_constants != null) {
       _constants.forEach(f);
     }
   }
@@ skipping 125 matching lines @@
   }
 
   void setCurrentTypeMask(ForIn node, TypeMask mask) {
     _setTypeMask(node.inToken, mask);
   }
 
   TypeMask getCurrentTypeMask(ForIn node) {
     return _getTypeMask(node.inToken);
   }
 }