dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/cps_ir_integrity.dart

 library dart2js.cps_ir_integrity;
 
 import 'cps_ir_nodes.dart';
 import 'cps_ir_nodes_sexpr.dart';
 import '../tracer.dart' as tracer;
 
 /// Dump S-expressions on error if the tracer is enabled.
 ///
 /// Technically this has nothing to do with the tracer, but if you want one
 /// enabled, you typically want the other as well, so we use the same flag.
 const bool ENABLE_DUMP = tracer.TRACE_FILTER_PATTERN != null;
 
 enum ScopeType { InScope, InDefinition, NotInScope }
 
 /// Performs integrity checks on the CPS IR.
 ///
 /// To be run for debugging purposes, not for use in production.
 ///
 /// The following integrity checks are performed:
 ///
 /// - References are in scope of their definitions.
 /// - Recursive Continuations and InvokeContinuations are marked as recursive.
 /// - InvokeContinuations have the same arity as their target.
 /// - Reference chains are valid doubly-linked lists.
 /// - Reference chains contain exactly the references that are in the IR.
 /// - Each definition object occurs only once in the IR (no redeclaring).
 /// - Each reference object occurs only once in the IR (no sharing).
 ///
 class CheckCpsIntegrity extends TrampolineRecursiveVisitor {
-
   FunctionDefinition topLevelNode;
   final Map<Definition, ScopeType> inScope = <Definition, ScopeType>{};
   final List<Definition> definitions = [];
   String previousPass;
 
   void handleDeclaration(Definition def) {
     definitions.add(def);
     // Check the reference chain for cycles broken links.
     Reference anchor = null;
     int i = 0;
     for (Reference ref = def.firstRef; ref != null; ref = ref.next) {
       if (ref.definition != def) {
-        error('Reference to ${ref.definition} found in '
-              'reference chain for $def', def);
+        error(
+            'Reference to ${ref.definition} found in '
+            'reference chain for $def',
+            def);
       }
       if (ref == anchor) {
         error('Cyclic reference chain for $def', def);
       }
-      if (i & ++i == 0) { // Move the anchor every 2^Nth step.
+      if (i & ++i == 0) {
+        // Move the anchor every 2^Nth step.
         anchor = ref;
       }
     }
   }
 
   void enterScope(Iterable<Definition> definitions) {
     for (Definition def in definitions) {
       inScope[def] = ScopeType.InScope;
     }
     pushAction(() {
@@ skipping 158 matching lines @@
         Decorator decorator = (n, String s) => n == node ? '**$s**' : s;
         sexpr = new SExpressionStringifier(decorator).visit(topLevelNode);
         sexpr = 'SExpr dump (offending node marked with **):\n\n$sexpr';
       } catch (e) {
         sexpr = '(Exception thrown by SExpressionStringifier: $e)';
       }
     } else {
       sexpr = '(Set DUMP_IR flag to enable SExpr dump)';
     }
     throw 'CPS integrity violation\n'
-          'After \'$previousPass\' on ${topLevelNode.element}\n'
-          '$message\n\n'
-          '$sexpr\n';
+        'After \'$previousPass\' on ${topLevelNode.element}\n'
+        '$message\n\n'
+        '$sexpr\n';
   }
 }
 
 /// Traverses the CPS term and checks that node.parent is correctly set
 /// for each visited node.
 class ParentChecker extends DeepRecursiveVisitor {
   static void checkParents(Node node, CheckCpsIntegrity main) {
     ParentChecker visitor = new ParentChecker._make(main);
     visitor._worklist.add(node);
     visitor.trampoline();
@@ skipping 12 matching lines @@
     }
   }
 
   error(String message, node) => main.error(message, node);
 
   @override
   visit(Node node) {
     _worklist.add(node);
     if (node.parent != _parent) {
       error('Parent pointer on $node is ${node.parent} but should be $_parent',
-            node);
+          node);
     }
   }
 
   @override
   processReference(Reference node) {
     if (node.parent != _parent) {
       error('Parent pointer on $node is ${node.parent} but should be $_parent',
-            node);
+          node);
     }
   }
 }