dartfmt pkg/compiler

pkg/compiler/lib/src/info/send_info.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.
 
 /// Computes measurements about sends in a function.
 library compiler.src.info.send_info;
 
 import 'package:dart2js_info/src/measurements.dart';
-import 'package:dart2js_info/src/util.dart' show
-    recursiveDiagnosticString;
+import 'package:dart2js_info/src/util.dart' show recursiveDiagnosticString;
 
 import '../common.dart';
-import '../compiler.dart' show
-    Compiler;
+import '../compiler.dart' show Compiler;
 import '../dart_types.dart';
 import '../closure.dart';
 import '../elements/elements.dart';
-import '../elements/visitor.dart' show
-    ElementVisitor;
+import '../elements/visitor.dart' show ElementVisitor;
 import '../resolution/operators.dart';
 import '../resolution/semantic_visitor.dart';
 import '../resolution/tree_elements.dart';
 import '../constants/expressions.dart';
-import '../parser/partial_elements.dart' show
-    PartialElement;
+import '../parser/partial_elements.dart' show PartialElement;
 import '../tree/tree.dart';
-import '../universe/call_structure.dart' show
-    CallStructure;
-import '../universe/selector.dart' show
-    Selector;
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/selector.dart' show Selector;
 
 import 'analysis_result.dart';
 import 'naive_analysis_result.dart';
 import 'trusted_types_analysis_result.dart';
 
 /// Collects a set of [Measurements] about send expressions in the function [f].
 // TODO(sigmund): collect information on initializers too.
-Measurements collectSendMeasurements(FunctionElement f,
-                                     Compiler compiler) {
+Measurements collectSendMeasurements(FunctionElement f, Compiler compiler) {
   DiagnosticReporter reporter = compiler.reporter;
   return reporter.withCurrentElement(f, () {
     // TODO(sigmund): enable for platform too.
     if (f.library.isPlatformLibrary) return null;
     var name = _qualifiedName(f);
     if (!f.hasNode) {
       if (f is PartialElement) return const Measurements.unreachableFunction();
-      assert (f is ConstructorElement && f.isSynthesized);
+      assert(f is ConstructorElement && f.isSynthesized);
       // TODO(sigmund): measure synthethic forwarding sends, measure
       // initializers
       return new Measurements.reachableFunction();
     }
     if (!f.hasResolvedAst) {
       _debug('no resolved ast ${f.runtimeType}');
       return null;
     }
     var resolvedAst = f.resolvedAst;
     if (resolvedAst.node == null) {
       _debug('no node ${f.runtimeType}');
       return null;
     }
     var def = resolvedAst.elements.getFunctionDefinition(resolvedAst.node);
     if (def == null) {
-      assert (f is PartialElement);
+      assert(f is PartialElement);
       return const Measurements.unreachableFunction();
     }
 
-    var visitor = new _StatsTraversalVisitor(
-        compiler, resolvedAst.elements,
+    var visitor = new _StatsTraversalVisitor(compiler, resolvedAst.elements,
         reporter.spanFromSpannable(resolvedAst.node).uri);
     resolvedAst.node.accept(visitor);
     return visitor.measurements;
   });
 }
 
 _qualifiedName(FunctionElement f) {
   var cls = f.enclosingClass;
   return (cls != null) ? '${cls.name}.${f.name}' : f.name;
 }
 
 /// Visitor that categorizes data about an individual send.
 class _StatsVisitor<T> extends Visitor
     with SemanticSendResolvedMixin<dynamic, T>
     implements SemanticSendVisitor<dynamic, T> {
-
   // TODO(sigmund): consider passing in several AnalysisResults at once, so we
   // can compute the different metrics together.
   /// Information we know about the program from static analysis.
   final AnalysisResult info;
 
   /// Results from this function.
   final Measurements measurements;
 
   final DiagnosticReporter reporter;
   final TreeElements elements;
 
   SemanticSendVisitor<dynamic, T> get sendVisitor => this;
 
   _StatsVisitor(this.reporter, this.elements, this.info, Uri sourceUri)
       : measurements = new Measurements.reachableFunction(sourceUri);
 
   visitNode(Node node) => throw "unhandled ${node.runtimeType}: $node";
   apply(Node node, T arg) => throw "missing apply ${node.runtimeType}: $node";
   internalError(Node node, String arg) => throw "internal error on $node";
 
   visitSend(Send node) {
     _checkInvariant(node, 'before');
     var span = reporter.spanFromSpannable(node);
     measurements.record(Metric.send, span.begin, span.end);
     if (node is SendSet) {
       if ((node.assignmentOperator != null &&
-                node.assignmentOperator.source != '=') ||
-            node.isPrefix ||
-            node.isPostfix) {
+              node.assignmentOperator.source != '=') ||
+          node.isPrefix ||
+          node.isPostfix) {
         assert(!node.isIfNullAssignment);
         // We count get and set separately in case one of them is defined by the
         // other could be a nSM error.
         measurements.record(Metric.send, span.begin, span.end);
         measurements.record(Metric.send, span.begin, span.end);
       } else if (node.isIfNullAssignment) {
         measurements.record(Metric.send, span.begin, span.end);
       }
     }
     super.visitSend(node);
@@ skipping 93 matching lines @@
     var span = reporter.spanFromSpannable(node);
     measurements.record(Metric.polymorphicSend, span.begin, span.end);
     measurements.record(Metric.multiNsmCallSend, span.begin, span.end);
   }
 
   handleSuper(Node node) {
     var span = reporter.spanFromSpannable(node);
     measurements.record(Metric.monomorphicSend, span.begin, span.end);
     measurements.record(Metric.superSend, span.begin, span.end);
   }
+
   handleTypeVariable(Node node) {
     var span = reporter.spanFromSpannable(node);
     measurements.record(Metric.monomorphicSend, span.begin, span.end);
     measurements.record(Metric.typeVariableSend, span.begin, span.end);
   }
+
   handleStatic(Node node) {
     var span = reporter.spanFromSpannable(node);
     measurements.record(Metric.monomorphicSend, span.begin, span.end);
     measurements.record(Metric.staticSend, span.begin, span.end);
   }
 
   handleNoSend(Node node) {
     measurements.popLast(Metric.send);
   }
 
@@ skipping 39 matching lines @@
         }
       } else {
         handleDynamic(node);
       }
       return;
     }
 
     Boolish usesInterceptor = selectorInfo.usesInterceptor;
     if (hasSelector == Boolish.yes) {
       if (selectorInfo.isAccurate && selectorInfo.possibleTargets == 1) {
-        assert (usesInterceptor != Boolish.maybe);
+        assert(usesInterceptor != Boolish.maybe);
         if (usesInterceptor == Boolish.yes) {
           handleSingleInterceptor(node);
         } else {
           handleSingleInstance(node);
         }
       } else {
         if (usesInterceptor == Boolish.no) {
           handleVirtual(node);
         } else if (usesInterceptor == Boolish.yes) {
           handleMultiInterceptor(node);
@@ skipping 21 matching lines @@
   void handleInvoke(Node node) {
     handleDynamic(node);
   }
 
   void handleEquals(Node node) {
     handleDynamic(node);
   }
 
   // Constructors
 
-  void visitAbstractClassConstructorInvoke(NewExpression node,
-      ConstructorElement element, InterfaceType type, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitAbstractClassConstructorInvoke(
+      NewExpression node,
+      ConstructorElement element,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleConstructor(node);
   }
 
   void visitBoolFromEnvironmentConstructorInvoke(NewExpression node,
       BoolFromEnvironmentConstantExpression constant, T arg) {
     handleConstructor(node);
   }
 
   void visitConstConstructorInvoke(
       NewExpression node, ConstructedConstantExpression constant, T arg) {
     handleConstructor(node);
   }
 
-  void visitGenerativeConstructorInvoke(NewExpression node,
-      ConstructorElement constructor, InterfaceType type, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleConstructor(node);
   }
 
   void visitIntFromEnvironmentConstructorInvoke(NewExpression node,
       IntFromEnvironmentConstantExpression constant, T arg) {
     handleConstructor(node);
   }
 
-  void visitRedirectingFactoryConstructorInvoke(NewExpression node,
-      ConstructorElement constructor, InterfaceType type,
-      ConstructorElement effectiveTarget, InterfaceType effectiveTargetType,
-      NodeList arguments, CallStructure callStructure, T arg) {
+  void visitRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ConstructorElement effectiveTarget,
+      InterfaceType effectiveTargetType,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleConstructor(node);
   }
 
-  void visitRedirectingGenerativeConstructorInvoke(NewExpression node,
-      ConstructorElement constructor, InterfaceType type, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitRedirectingGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleConstructor(node);
   }
 
   void visitStringFromEnvironmentConstructorInvoke(NewExpression node,
       StringFromEnvironmentConstantExpression constant, T arg) {
     handleConstructor(node);
   }
 
   // Dynamic sends
 
-
   // TODO(sigmund): many many things to add:
   // -- support for operators, indexers, etc.
   // -- logic about nullables
   // -- int, JSArray
   // -- all interceptors
 
   void visitBinary(
       Send node, Node left, BinaryOperator operator, Node right, T arg) {
     handleOperator(node);
   }
 
   void visitCompoundIndexSet(SendSet node, Node receiver, Node index,
       AssignmentOperator operator, Node rhs, T arg) {
     handleIndex(node); // t1 = receiver[index]
     handleOperator(node); // t2 = t1 op rhs
     handleIndex(node); // receiver[index] = t2
   }
 
-  void visitDynamicPropertyCompound(Send node, Node receiver,
-      Name name, AssignmentOperator operator, Node rhs, T arg) {
+  void visitDynamicPropertyCompound(Send node, Node receiver, Name name,
+      AssignmentOperator operator, Node rhs, T arg) {
     handleDynamicProperty(node, receiver, new Selector.getter(name));
     handleOperator(node);
     handleDynamicProperty(node, receiver, new Selector.setter(name));
   }
 
-
-  void visitDynamicPropertyGet(
-      Send node, Node receiver, Name name, T arg) {
+  void visitDynamicPropertyGet(Send node, Node receiver, Name name, T arg) {
     handleDynamicProperty(node, receiver, new Selector.getter(name));
   }
 
   void visitDynamicPropertyInvoke(
       Send node, Node receiver, NodeList arguments, Selector selector, T arg) {
     handleDynamicProperty(node, receiver, selector);
   }
 
-  void visitDynamicPropertyPostfix(Send node, Node receiver,
-       Name name, IncDecOperator operator, T arg) {
+  void visitDynamicPropertyPostfix(
+      Send node, Node receiver, Name name, IncDecOperator operator, T arg) {
     handleDynamicProperty(node, receiver, new Selector.getter(name));
     handleOperator(node);
     handleDynamicProperty(node, receiver, new Selector.setter(name));
   }
 
-  void visitDynamicPropertyPrefix(Send node, Node receiver, Name name,
-      IncDecOperator operator, T arg) {
+  void visitDynamicPropertyPrefix(
+      Send node, Node receiver, Name name, IncDecOperator operator, T arg) {
     handleDynamicProperty(node, receiver, new Selector.getter(name));
     handleOperator(node);
     handleDynamicProperty(node, receiver, new Selector.setter(name));
   }
 
   void visitDynamicPropertySet(
       SendSet node, Node receiver, Name name, Node rhs, T arg) {
     handleDynamicProperty(node, receiver, new Selector.setter(name));
   }
 
@@ skipping 23 matching lines @@
   void visitIfNotNullDynamicPropertyGet(
       Send node, Node receiver, Name name, T arg) {
     handleDynamicProperty(node, receiver, new Selector.getter(name));
   }
 
   void visitIfNotNullDynamicPropertyInvoke(
       Send node, Node receiver, NodeList arguments, Selector selector, T arg) {
     handleDynamicProperty(node, receiver, selector);
   }
 
-  void visitIfNotNullDynamicPropertyPostfix(Send node, Node receiver, Name name,
-      IncDecOperator operator, T arg) {
+  void visitIfNotNullDynamicPropertyPostfix(
+      Send node, Node receiver, Name name, IncDecOperator operator, T arg) {
     handleDynamicProperty(node, receiver, new Selector.getter(name));
     handleOperator(node);
     handleDynamicProperty(node, receiver, new Selector.setter(name));
   }
 
-  void visitIfNotNullDynamicPropertyPrefix(Send node, Node receiver, Name name,
-      IncDecOperator operator, T arg) {
+  void visitIfNotNullDynamicPropertyPrefix(
+      Send node, Node receiver, Name name, IncDecOperator operator, T arg) {
     handleDynamicProperty(node, receiver, new Selector.getter(name));
     handleOperator(node);
     handleDynamicProperty(node, receiver, new Selector.setter(name));
   }
 
   void visitIfNotNullDynamicPropertySet(
       SendSet node, Node receiver, Name name, Node rhs, T arg) {
     handleDynamicProperty(node, receiver, new Selector.setter(name));
   }
 
@@ skipping 154 matching lines @@
     handleSuper(node);
   }
 
   void visitSuperFieldFieldPrefix(Send node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
-  void visitSuperFieldFieldSetIfNull(
-      Send node, FieldElement readField, FieldElement writtenField, Node rhs,
-      T arg) {
+  void visitSuperFieldFieldSetIfNull(Send node, FieldElement readField,
+      FieldElement writtenField, Node rhs, T arg) {
     handleSuper(node);
     handleNSMSuper(node, readField.enclosingClass);
   }
 
   void visitSuperFieldInvoke(Send node, FieldElement field, NodeList arguments,
       CallStructure callStructure, T arg) {
     handleInvoke(node);
   }
 
   void visitSuperFieldPostfix(
@@ skipping 24 matching lines @@
     handleSuper(node);
   }
 
   void visitSuperFieldSetterPrefix(Send node, FieldElement field,
       FunctionElement setter, IncDecOperator operator, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
-  void visitSuperFieldSetterSetIfNull(Send node, FieldElement field,
-      FunctionElement setter, Node rhs, T arg) {
+  void visitSuperFieldSetterSetIfNull(
+      Send node, FieldElement field, FunctionElement setter, Node rhs, T arg) {
     handleSuper(node);
     handleSuper(node);
   }
 
   void visitSuperGetterFieldCompound(Send node, FunctionElement getter,
       FieldElement field, AssignmentOperator operator, Node rhs, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
   void visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
       FieldElement field, IncDecOperator operator, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
   void visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
       FieldElement field, IncDecOperator operator, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
-  void visitSuperGetterFieldSetIfNull(Send node, FunctionElement getter,
-      FieldElement field, Node rhs, T arg) {
+  void visitSuperGetterFieldSetIfNull(
+      Send node, FunctionElement getter, FieldElement field, Node rhs, T arg) {
     handleSuper(node);
     handleSuper(node);
   }
 
   void visitSuperGetterInvoke(Send node, FunctionElement getter,
       NodeList arguments, CallStructure callStructure, T arg) {
     handleInvoke(node);
   }
 
   void visitSuperGetterSetterCompound(Send node, FunctionElement getter,
@@ skipping 16 matching lines @@
     handleOperator(node);
     handleSuper(node);
   }
 
   void visitSuperGetterSetterSetIfNull(Send node, FunctionElement getter,
       FunctionElement setter, Node rhs, T arg) {
     handleSuper(node);
     handleSuper(node);
   }
 
-  void visitSuperIndexPostfix(Send node, MethodElement indexFunction,
-      MethodElement indexSetFunction, Node index, IncDecOperator operator,
+  void visitSuperIndexPostfix(
+      Send node,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
       T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
-  void visitSuperIndexPrefix(Send node, MethodElement indexFunction,
-      MethodElement indexSetFunction, Node index, IncDecOperator operator,
+  void visitSuperIndexPrefix(
+      Send node,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
       T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
   void visitSuperMethodSetterCompound(Send node, FunctionElement method,
       FunctionElement setter, AssignmentOperator operator, Node rhs, T arg) {
     handleSuper(node);
     handleNSMSuper(node, method.enclosingClass);
@@ skipping 13 matching lines @@
     handleNSMSuper(node, method.enclosingClass);
     handleSuper(node);
   }
 
   void visitSuperMethodSetterSetIfNull(Send node, FunctionElement method,
       FunctionElement setter, Node rhs, T arg) {
     handleSuper(node);
     handleSuper(node);
   }
 
-  void visitThisPropertyCompound(Send node, Name name,
-      AssignmentOperator operator, Node rhs, T arg) {
+  void visitThisPropertyCompound(
+      Send node, Name name, AssignmentOperator operator, Node rhs, T arg) {
     handleThisProperty(node, new Selector.getter(name));
     handleOperator(node);
     handleThisProperty(node, new Selector.setter(name));
   }
 
   void visitThisPropertyInvoke(
       Send node, NodeList arguments, Selector selector, T arg) {
     handleThisProperty(node, selector);
   }
 
-  void visitThisPropertyPostfix(Send node, Name name, IncDecOperator operator,
-      T arg) {
+  void visitThisPropertyPostfix(
+      Send node, Name name, IncDecOperator operator, T arg) {
     handleThisProperty(node, new Selector.getter(name));
     handleOperator(node);
     handleThisProperty(node, new Selector.setter(name));
   }
 
-  void visitThisPropertyPrefix(Send node, Name name, IncDecOperator operator,
-      T arg) {
+  void visitThisPropertyPrefix(
+      Send node, Name name, IncDecOperator operator, T arg) {
     handleThisProperty(node, new Selector.getter(name));
     handleOperator(node);
     handleThisProperty(node, new Selector.setter(name));
   }
 
   void visitTopLevelFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, T arg) {
     handleStatic(node);
     handleOperator(node);
     handleStatic(node);
@@ skipping 152 matching lines @@
     handleSuper(node);
   }
 
   void visitSuperUnary(
       Send node, UnaryOperator operator, FunctionElement function, T arg) {
     handleSuper(node);
   }
 
   // Statically known "no such method" sends
 
-  void visitConstructorIncompatibleInvoke(NewExpression node,
-      ConstructorElement constructor, InterfaceType type, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitConstructorIncompatibleInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleNSMError(node);
   }
 
   void visitFinalLocalVariableCompound(Send node, LocalVariableElement variable,
       AssignmentOperator operator, Node rhs, T arg) {
     handleLocal(node);
     handleOperator(node);
     handleNSMError(node);
   }
 
@@ skipping 79 matching lines @@
       SendSet node, FieldElement field, Node rhs, T arg) {
     handleNSMError(node);
   }
 
   void visitFinalStaticFieldSetIfNull(
       SendSet node, FieldElement field, Node rhs, T arg) {
     handleStatic(node);
     handleNSMError(node);
   }
 
-  void visitFinalSuperFieldSetIfNull(Send node, FieldElement field,
-      Node rhs, T arg) {
+  void visitFinalSuperFieldSetIfNull(
+      Send node, FieldElement field, Node rhs, T arg) {
     handleSuper(node);
     handleNSMSuper(node, field.enclosingClass);
   }
 
   void visitFinalSuperFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleNSMSuper(node, field.enclosingClass);
   }
@@ skipping 54 matching lines @@
     handleStatic(node);
     handleStatic(node);
   }
 
   void visitTopLevelMethodSetterSetIfNull(Send node, FunctionElement method,
       FunctionElement setter, Node rhs, T arg) {
     handleStatic(node);
     handleStatic(node);
   }
 
-  void visitTopLevelMethodSetIfNull(Send node, FunctionElement method,
-      Node rhs, T arg) {
+  void visitTopLevelMethodSetIfNull(
+      Send node, FunctionElement method, Node rhs, T arg) {
     handleStatic(node);
     handleNSMError(node);
   }
 
-  void visitLocalFunctionIncompatibleInvoke(Send node,
-      LocalFunctionElement function, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitLocalFunctionIncompatibleInvoke(
+      Send node,
+      LocalFunctionElement function,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleNSMError(node);
   }
 
   void visitLocalFunctionCompound(Send node, LocalFunctionElement function,
       AssignmentOperator operator, Node rhs, T arg) {
     handleLocal(node);
     handleNSMError(node);
     handleNoSend(node);
   }
 
@@ skipping 123 matching lines @@
 
   void visitSuperSetterGet(Send node, FunctionElement setter, T arg) {
     handleNSMSuper(node, setter.enclosingClass);
   }
 
   void visitSuperSetterInvoke(Send node, FunctionElement setter,
       NodeList arguments, CallStructure callStructure, T arg) {
     handleNSMSuper(node, setter.enclosingClass);
   }
 
-  void visitTopLevelFunctionIncompatibleInvoke(Send node,
-      MethodElement function, NodeList arguments, CallStructure callStructure,
+  void visitTopLevelFunctionIncompatibleInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
       T arg) {
     handleNSMError(node);
   }
 
   void visitTopLevelFunctionSet(
       Send node, MethodElement function, Node rhs, T arg) {
     handleNSMError(node);
   }
 
   void visitTopLevelGetterSet(
@@ skipping 45 matching lines @@
 
   void visitTopLevelSetterGet(Send node, FunctionElement setter, T arg) {
     handleNSMError(node);
   }
 
   void visitTopLevelSetterInvoke(Send node, FunctionElement setter,
       NodeList arguments, CallStructure callStructure, T arg) {
     handleNSMError(node);
   }
 
-  void visitTypeVariableTypeLiteralCompound(Send node,
-      TypeVariableElement element, AssignmentOperator operator, Node rhs,
+  void visitTypeVariableTypeLiteralCompound(
+      Send node,
+      TypeVariableElement element,
+      AssignmentOperator operator,
+      Node rhs,
       T arg) {
     handleTypeVariable(node);
     handleNSMError(node); // operator on a method closure yields nSM
     handleNoSend(node); // setter is not invoked, don't count it.
   }
 
   void visitTypeVariableTypeLiteralGet(
       Send node, TypeVariableElement element, T arg) {
     handleTypeVariable(node);
   }
 
-  void visitTypeVariableTypeLiteralInvoke(Send node,
-      TypeVariableElement element, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitTypeVariableTypeLiteralInvoke(
+      Send node,
+      TypeVariableElement element,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleNSMError(node);
   }
 
   void visitTypeVariableTypeLiteralPostfix(
       Send node, TypeVariableElement element, IncDecOperator operator, T arg) {
     handleTypeVariable(node);
     handleNSMError(node);
     handleNoSend(node);
   }
 
@@ skipping 50 matching lines @@
       SendSet node, ConstantExpression constant, Node rhs, T arg) {
     handleNSMError(node);
   }
 
   void visitTypedefTypeLiteralSetIfNull(
       SendSet node, ConstantExpression constant, Node rhs, T arg) {
     handleStatic(node);
     handleNSMError(node);
   }
 
-  void visitUnresolvedClassConstructorInvoke(NewExpression node,
-      Element element, DartType type, NodeList arguments, Selector selector,
+  void visitUnresolvedClassConstructorInvoke(
+      NewExpression node,
+      Element element,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
       T arg) {
     handleNSMError(node);
   }
 
   void visitUnresolvedCompound(Send node, Element element,
       AssignmentOperator operator, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
@@ skipping 19 matching lines @@
     handleNoSend(node);
   }
 
   void visitUnresolvedPrefix(
       Send node, Element element, IncDecOperator operator, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void visitUnresolvedRedirectingFactoryConstructorInvoke(NewExpression node,
-      ConstructorElement constructor, InterfaceType type, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitUnresolvedRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleNSMError(node);
   }
 
   void visitUnresolvedSet(Send node, Element element, Node rhs, T arg) {
     handleNSMError(node);
   }
 
   void visitUnresolvedSetIfNull(Send node, Element element, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
@@ skipping 13 matching lines @@
     handleNoSend(node);
   }
 
   void visitUnresolvedStaticGetterPrefix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void visitUnresolvedStaticGetterSetIfNull(Send node, Element element,
-      MethodElement setter, Node rhs, T arg) {
+  void visitUnresolvedStaticGetterSetIfNull(
+      Send node, Element element, MethodElement setter, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
   }
 
   void visitUnresolvedStaticSetterCompound(Send node, MethodElement getter,
       Element element, AssignmentOperator operator, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
   void visitUnresolvedStaticSetterPostfix(Send node, MethodElement getter,
       Element element, IncDecOperator operator, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
   void visitUnresolvedStaticSetterPrefix(Send node, MethodElement getter,
       Element element, IncDecOperator operator, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void visitUnresolvedStaticSetterSetIfNull(Send node, MethodElement getter,
-      Element element, Node rhs, T arg) {
+  void visitUnresolvedStaticSetterSetIfNull(
+      Send node, MethodElement getter, Element element, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
   }
 
   void visitUnresolvedSuperBinary(Send node, Element element,
       BinaryOperator operator, Node argument, T arg) {
     handleNSMSuper(node, element.enclosingClass);
   }
 
   void visitUnresolvedSuperCompound(Send node, Element element,
@@ skipping 26 matching lines @@
     handleNoSend(node);
   }
 
   void visitUnresolvedSuperGetterCompound(Send node, Element element,
       MethodElement setter, AssignmentOperator operator, Node rhs, T arg) {
     handleNSMSuper(node, element.enclosingClass);
     handleOperator(node);
     handleSuper(node);
   }
 
-  void visitUnresolvedSuperGetterCompoundIndexSet(Send node, Element element,
-      MethodElement setter, Node index, AssignmentOperator operator, Node rhs,
+  void visitUnresolvedSuperGetterCompoundIndexSet(
+      Send node,
+      Element element,
+      MethodElement setter,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       T arg) {
     handleNSMSuper(node, element.enclosingClass);
     handleOperator(node);
     handleSuper(node);
   }
 
   void visitUnresolvedSuperGetterIndexPostfix(Send node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, T arg) {
     handleNSMSuper(node, element.enclosingClass);
     handleOperator(node);
@@ skipping 14 matching lines @@
     handleSuper(node);
   }
 
   void visitUnresolvedSuperGetterPrefix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, T arg) {
     handleNSMSuper(node, element.enclosingClass);
     handleOperator(node);
     handleSuper(node);
   }
 
-  void visitUnresolvedSuperGetterSetIfNull(Send node, Element element,
-      MethodElement setter, Node rhs, T arg) {
+  void visitUnresolvedSuperGetterSetIfNull(
+      Send node, Element element, MethodElement setter, Node rhs, T arg) {
     handleNSMSuper(node, element.enclosingClass);
     handleSuper(node);
   }
 
   void visitUnresolvedSuperIndex(
       Send node, Element element, Node index, T arg) {
     handleNSMSuper(node, element.enclosingClass);
   }
 
   void visitUnresolvedSuperIndexPostfix(
@@ skipping 34 matching lines @@
     handleNSMSuper(node, element.enclosingClass);
   }
 
   void visitUnresolvedSuperSetterCompound(Send node, MethodElement getter,
       Element element, AssignmentOperator operator, Node rhs, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleNSMSuper(node, element.enclosingClass);
   }
 
-  void visitUnresolvedSuperSetterCompoundIndexSet(Send node,
-      MethodElement getter, Element element, Node index,
-      AssignmentOperator operator, Node rhs, T arg) {
+  void visitUnresolvedSuperSetterCompoundIndexSet(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
+      T arg) {
     handleSuper(node);
     handleOperator(node);
     handleNSMSuper(node, element.enclosingClass);
   }
 
-  void visitUnresolvedSuperSetterIndexPostfix(Send node,
-      MethodElement indexFunction, Element element, Node index,
-      IncDecOperator operator, T arg) {
+  void visitUnresolvedSuperSetterIndexPostfix(
+      Send node,
+      MethodElement indexFunction,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      T arg) {
     handleSuper(node);
     handleOperator(node);
     handleNSMSuper(node, element.enclosingClass);
   }
 
-  void visitUnresolvedSuperSetterIndexPrefix(Send node,
-      MethodElement indexFunction, Element element, Node index,
-      IncDecOperator operator, T arg) {
+  void visitUnresolvedSuperSetterIndexPrefix(
+      Send node,
+      MethodElement indexFunction,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      T arg) {
     handleSuper(node);
     handleOperator(node);
     handleNSMSuper(node, element.enclosingClass);
   }
 
   void visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
       Element element, IncDecOperator operator, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleNSMSuper(node, element.enclosingClass);
   }
 
   void visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
       Element element, IncDecOperator operator, T arg) {
     handleSuper(node);
     handleOperator(node);
     handleNSMSuper(node, element.enclosingClass);
   }
 
-  void visitUnresolvedSuperSetterSetIfNull(Send node, MethodElement getter,
-      Element element, Node rhs, T arg) {
+  void visitUnresolvedSuperSetterSetIfNull(
+      Send node, MethodElement getter, Element element, Node rhs, T arg) {
     handleSuper(node);
     handleNSMSuper(node, element.enclosingClass);
   }
 
   void visitUnresolvedSuperUnary(
       Send node, UnaryOperator operator, Element element, T arg) {
     handleNSMSuper(node, element.enclosingClass);
   }
 
   void visitUnresolvedTopLevelGetterCompound(Send node, Element element,
@@ skipping 10 matching lines @@
     handleNoSend(node);
   }
 
   void visitUnresolvedTopLevelGetterPrefix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void visitUnresolvedTopLevelGetterSetIfNull(Send node, Element element,
-      MethodElement setter, Node rhs, T arg) {
+  void visitUnresolvedTopLevelGetterSetIfNull(
+      Send node, Element element, MethodElement setter, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
   }
 
   void visitUnresolvedTopLevelSetterCompound(Send node, MethodElement getter,
       Element element, AssignmentOperator operator, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
   void visitUnresolvedTopLevelSetterPostfix(Send node, MethodElement getter,
       Element element, IncDecOperator operator, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
   void visitUnresolvedTopLevelSetterPrefix(Send node, MethodElement getter,
       Element element, IncDecOperator operator, T arg) {
     handleNSMError(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void visitUnresolvedTopLevelSetterSetIfNull(Send node, MethodElement getter,
-      Element element, Node rhs, T arg) {
+  void visitUnresolvedTopLevelSetterSetIfNull(
+      Send node, MethodElement getter, Element element, Node rhs, T arg) {
     handleNSMError(node);
     handleNoSend(node);
   }
 
   // Static
 
   void visitConstantGet(Send node, ConstantExpression constant, T arg) {
     handleStatic(node);
   }
 
   void visitConstantInvoke(Send node, ConstantExpression constant,
       NodeList arguments, CallStructure callStreucture, T arg) {
     handleStatic(node);
   }
 
-  void visitFactoryConstructorInvoke(NewExpression node,
-      ConstructorElement constructor, InterfaceType type, NodeList arguments,
-      CallStructure callStructure, T arg) {
+  void visitFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      T arg) {
     handleStatic(node);
   }
 
   void visitStaticFieldGet(Send node, FieldElement field, T arg) {
     handleStatic(node);
   }
 
   void visitStaticFieldSet(SendSet node, FieldElement field, Node rhs, T arg) {
     handleStatic(node);
   }
@@ skipping 20 matching lines @@
   void visitStaticGetterSet(
       SendSet node, FunctionElement getter, Node rhs, T arg) {
     handleStatic(node);
   }
 
   void visitStaticSetterSet(
       SendSet node, FunctionElement setter, Node rhs, T arg) {
     handleStatic(node);
   }
 
-  void visitStaticGetterSetterSetIfNull(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      Node rhs,
-      T arg) {
+  void visitStaticGetterSetterSetIfNull(Send node, FunctionElement getter,
+      FunctionElement setter, Node rhs, T arg) {
     handleStatic(node);
     handleStatic(node);
   }
 
   void visitStaticMethodSetterSetIfNull(
-      Send node,
-      MethodElement method,
-      MethodElement setter,
-      Node rhs,
-      T arg) {
+      Send node, MethodElement method, MethodElement setter, Node rhs, T arg) {
     handleStatic(node);
     handleStatic(node);
   }
 
   void visitStaticMethodSetIfNull(
-      Send node,
-      FunctionElement method,
-      Node rhs,
-      T arg) {
+      Send node, FunctionElement method, Node rhs, T arg) {
     handleStatic(node);
     handleNSMError(node);
   }
 
   void visitTopLevelFieldGet(Send node, FieldElement field, T arg) {
     handleStatic(node);
   }
 
   void visitTopLevelFieldSet(
       SendSet node, FieldElement field, Node rhs, T arg) {
@@ skipping 19 matching lines @@
     handleStatic(node);
   }
 
   void visitTopLevelSetterSet(
       SendSet node, FunctionElement setter, Node rhs, T arg) {
     handleStatic(node);
   }
 
   // Virtual
 
-  void visitSuperCompoundIndexSet(SendSet node, MethodElement getter,
-      MethodElement setter, Node index, AssignmentOperator operator, Node rhs,
+  void visitSuperCompoundIndexSet(
+      SendSet node,
+      MethodElement getter,
+      MethodElement setter,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       T arg) {
     handleSuper(node);
     handleOperator(node);
     handleSuper(node);
   }
 
   void visitThisGet(Identifier node, T arg) {
     handleLocal(node); // TODO(sigmund): should we add a metric for "this"?
   }
 
@@ skipping 26 matching lines @@
   void errorUndefinedBinaryExpression(
       Send node, Node left, Operator operator, Node right, T arg) {
     handleNoSend(node);
   }
 
   void errorUndefinedUnaryExpression(
       Send node, Operator operator, Node expression, T arg) {
     handleNoSend(node);
   }
 
-  void errorInvalidGet(
-      Send node,
-      ErroneousElement error,
-      T arg) {
+  void errorInvalidGet(Send node, ErroneousElement error, T arg) {
     handleNoSend(node);
   }
 
-  void errorInvalidInvoke(
-      Send node,
-      ErroneousElement error,
-      NodeList arguments,
-      Selector selector,
-      T arg) {
+  void errorInvalidInvoke(Send node, ErroneousElement error, NodeList arguments,
+      Selector selector, T arg) {
     handleNoSend(node);
   }
 
-  void errorInvalidSet(
-      Send node,
-      ErroneousElement error,
-      Node rhs,
-      T arg) {
+  void errorInvalidSet(Send node, ErroneousElement error, Node rhs, T arg) {
     handleNoSend(node);
   }
 
   void errorInvalidSetIfNull(
       Send node, ErroneousElement error, Node rhs, T arg) {
     handleNoSend(node);
     handleNoSend(node);
   }
 
-
   void errorInvalidPrefix(
-      Send node,
-      ErroneousElement error,
-      IncDecOperator operator,
-      T arg) {
+      Send node, ErroneousElement error, IncDecOperator operator, T arg) {
     handleNoSend(node);
   }
 
   void errorInvalidPostfix(
-      Send node,
-      ErroneousElement error,
-      IncDecOperator operator,
-      T arg) {
+      Send node, ErroneousElement error, IncDecOperator operator, T arg) {
     handleNoSend(node);
   }
 
-  void errorInvalidCompound(
-      Send node,
-      ErroneousElement error,
-      AssignmentOperator operator,
-      Node rhs,
-      T arg) {
+  void errorInvalidCompound(Send node, ErroneousElement error,
+      AssignmentOperator operator, Node rhs, T arg) {
     handleNoSend(node);
   }
 
   void errorInvalidUnary(
-      Send node,
-      UnaryOperator operator,
-      ErroneousElement error,
-      T arg) {
+      Send node, UnaryOperator operator, ErroneousElement error, T arg) {
     handleNoSend(node);
   }
 
   void errorInvalidEquals(
-      Send node,
-      ErroneousElement error,
-      Node right,
-      T arg) {
+      Send node, ErroneousElement error, Node right, T arg) {
     handleNoSend(node);
   }
 
   void errorInvalidNotEquals(
-      Send node,
-      ErroneousElement error,
-      Node right,
-      T arg) {
+      Send node, ErroneousElement error, Node right, T arg) {
     handleNoSend(node);
   }
 
-  void errorInvalidBinary(
-      Send node,
-      ErroneousElement error,
-      BinaryOperator operator,
-      Node right,
-      T arg) {
+  void errorInvalidBinary(Send node, ErroneousElement error,
+      BinaryOperator operator, Node right, T arg) {
     handleNoSend(node);
   }
 
-  void errorInvalidIndex(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      T arg) {
+  void errorInvalidIndex(Send node, ErroneousElement error, Node index, T arg) {
     handleNoSend(node);
   }
 
   void errorInvalidIndexSet(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      Node rhs,
-      T arg) {
+      Send node, ErroneousElement error, Node index, Node rhs, T arg) {
     handleNoSend(node);
   }
 
-  void errorInvalidCompoundIndexSet(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
-      T arg) {
+  void errorInvalidCompoundIndexSet(Send node, ErroneousElement error,
+      Node index, AssignmentOperator operator, Node rhs, T arg) {
     handleNoSend(node);
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void errorInvalidIndexPrefix(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      IncDecOperator operator,
-      T arg) {
+  void errorInvalidIndexPrefix(Send node, ErroneousElement error, Node index,
+      IncDecOperator operator, T arg) {
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void errorInvalidIndexPostfix(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      IncDecOperator operator,
-      T arg) {
+  void errorInvalidIndexPostfix(Send node, ErroneousElement error, Node index,
+      IncDecOperator operator, T arg) {
     handleNoSend(node);
     handleNoSend(node);
   }
 
-  void previsitDeferredAccess(
-      Send node,
-      PrefixElement prefix,
-      T arg) {
-  }
-
+  void previsitDeferredAccess(Send node, PrefixElement prefix, T arg) {}
 
   void visitAs(Send node, Node expression, DartType type, T arg) {
     handleNoSend(node);
   }
 
   void visitClassTypeLiteralCompound(Send node, ConstantExpression constant,
       AssignmentOperator operator, Node rhs, T arg) {
     handleStatic(node);
     handleNSMError(node);
     handleNoSend(node);
@@ skipping 69 matching lines @@
     handleNSMError(node);
   }
 
   void visitDynamicTypeLiteralSetIfNull(
       SendSet node, ConstantExpression constant, Node rhs, T arg) {
     handleStatic(node);
     handleNSMError(node);
   }
 
   @override
-  errorInvalidIndexSetIfNull(SendSet node, ErroneousElement error, Node index,
-      Node rhs, T arg) {
+  errorInvalidIndexSetIfNull(
+      SendSet node, ErroneousElement error, Node index, Node rhs, T arg) {
     handleNoSend(node);
   }
 
   @override
-  visitIndexSetIfNull(SendSet node, Node receiver, Node index, Node rhs,
-      T arg) {
+  visitIndexSetIfNull(
+      SendSet node, Node receiver, Node index, Node rhs, T arg) {
     handleIndex(node); // t1 = receiver[index]
     handleIndex(node); // receiver[index] = t2
   }
 
   @override
   visitSuperIndexSetIfNull(SendSet node, MethodElement getter,
       MethodElement setter, Node index, Node rhs, T arg) {
     handleSuper(node); // t1 = super[index]
     handleSuper(node); // super[index] = t2
   }
 
   @override
   visitUnresolvedSuperGetterIndexSetIfNull(Send node, Element element,
       MethodElement setter, Node index, Node rhs, T arg) {
     handleNSMSuper(node, element.enclosingClass);
     handleNSMSuper(node, element.enclosingClass);
   }
 
   @override
-  visitUnresolvedSuperIndexSetIfNull(Send node, Element element, Node index,
-      Node rhs, T arg) {
+  visitUnresolvedSuperIndexSetIfNull(
+      Send node, Element element, Node index, Node rhs, T arg) {
     handleNSMSuper(node, element.enclosingClass);
     handleNSMSuper(node, element.enclosingClass);
   }
 
   @override
   visitUnresolvedSuperSetterIndexSetIfNull(Send node, MethodElement getter,
       Element element, Node index, Node rhs, T arg) {
     handleSuper(node); // t1 = super[index]
     handleNSMSuper(node, element.enclosingClass);
   }
@@ skipping 21 matching lines @@
   void visitNot(Send node, Node expression, T arg) {
     handleNoSend(node);
   }
 
   String last;
   _checkInvariant(node, String msg) {
     msg = '$msg ${recursiveDiagnosticString(measurements, Metric.send)}';
     if (!measurements.checkInvariant(Metric.send) ||
         !measurements.checkInvariant(Metric.monomorphicSend) ||
         !measurements.checkInvariant(Metric.polymorphicSend)) {
-      reporter.reportErrorMessage(node,
-          MessageKind.GENERIC, {'text': 'bad\n-- $msg\nlast:\n-- $last\n'});
+      reporter.reportErrorMessage(node, MessageKind.GENERIC,
+          {'text': 'bad\n-- $msg\nlast:\n-- $last\n'});
       last = msg;
     } else {
       last = msg;
     }
   }
 }
 
 /// Visitor that collects statistics for a single function.
 class _StatsTraversalVisitor<T> extends TraversalVisitor<dynamic, T>
     implements SemanticSendVisitor<dynamic, T> {
   final DiagnosticReporter reporter;
   final _StatsVisitor statsVisitor;
   Measurements get measurements => statsVisitor.measurements;
   _StatsTraversalVisitor(
       Compiler compiler, TreeElements elements, Uri sourceUri)
       : reporter = compiler.reporter,
-        statsVisitor = new _StatsVisitor(compiler.reporter, elements,
-            // TODO(sigmund): accept a list of analyses, so we can compare them
-            // together.
-            true
-            ? new TrustTypesAnalysisResult(elements, compiler.world)
-            : new NaiveAnalysisResult(),
+        statsVisitor = new _StatsVisitor(
+            compiler.reporter,
+            elements,
+                // TODO(sigmund): accept a list of analyses, so we can compare them
+                // together.
+                true
+                ? new TrustTypesAnalysisResult(elements, compiler.world)
+                : new NaiveAnalysisResult(),
             sourceUri),
         super(elements);
 
   void visitSend(Send node) {
     try {
       node.accept(statsVisitor);
     } catch (e, t) {
-      reporter.reportErrorMessage(
-          node, MessageKind.GENERIC, {'text': '$e\n$t'});
+      reporter
+          .reportErrorMessage(node, MessageKind.GENERIC, {'text': '$e\n$t'});
     }
     super.visitSend(node);
   }
 
   void visitNewExpression(NewExpression node) {
     try {
       node.accept(statsVisitor);
     } catch (e, t) {
-      reporter.reportErrorMessage(
-          node, MessageKind.GENERIC, {'text': '$e\n$t'});
+      reporter
+          .reportErrorMessage(node, MessageKind.GENERIC, {'text': '$e\n$t'});
     }
     super.visitNewExpression(node);
   }
 }
 
 /// Helper to visit elements recursively
 // TODO(sigmund): maybe generalize and move to elements/visitor.dart?
 abstract class RecursiveElementVisitor<R, A> extends ElementVisitor<R, A> {
-
   @override
   R visitWarnOnUseElement(WarnOnUseElement e, A arg) =>
       e.wrappedElement.accept(this, arg);
 
   R visitScopeContainerElement(ScopeContainerElement e, A arg) {
     e.forEachLocalMember((l) => l.accept(this, arg));
     return null;
   }
 
   @override
@@ skipping 60 matching lines @@
   @override
   R visitClosureFieldElement(ClosureFieldElement e, A arg) {
     return visitVariableElement(e, arg);
   }
 }
 
 // TODO(sigmund): get rid of debug messages.
 _debug(String message) {
   print('debug: $message');
 }