dartfmt pkg/compiler

pkg/compiler/lib/src/resolution/semantic_visitor.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.semantics_visitor;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../tree/tree.dart';
 import '../elements/elements.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 'operators.dart';
 import 'send_resolver.dart';
 import 'send_structure.dart';
 import 'tree_elements.dart';
 
 part 'semantic_visitor_mixins.dart';
 
 /// Mixin that couples a [SendResolverMixin] to a [SemanticSendVisitor] in a
 /// [Visitor].
@@ skipping 45 matching lines @@
     } else {
       return structure.dispatch(sendVisitor, node, arg);
     }
   }
 }
 
 /// Mixin that couples a [DeclarationResolverMixin] to a
 /// [SemanticDeclarationVisitor] in a [Visitor].
 abstract class SemanticDeclarationResolvedMixin<R, A>
     implements Visitor<R>, DeclarationResolverMixin {
-
   SemanticDeclarationVisitor<R, A> get declVisitor;
 
   @override
   R visitFunctionExpression(FunctionExpression node) {
     // TODO(johnniwinther): Support argument.
     A arg = null;
 
     DeclStructure structure = computeFunctionStructure(node);
     if (structure == null) {
       return internalError(node, 'No structure for $node');
@@ skipping 15 matching lines @@
     for (ParameterStructure structure in structures) {
       structure.dispatch(declVisitor, arg);
     }
   }
 
   @override
   R visitVariableDefinitions(VariableDefinitions definitions) {
     // TODO(johnniwinther): Support argument.
     A arg = null;
 
-    computeVariableStructures(
-        definitions,
+    computeVariableStructures(definitions,
         (Node node, VariableStructure structure) {
       if (structure == null) {
         return internalError(node, 'No structure for $node');
       } else {
         return structure.dispatch(declVisitor, node, arg);
       }
     });
     return null;
   }
 }
 
 abstract class SemanticVisitor<R, A> extends Visitor<R>
-    with SemanticSendResolvedMixin<R, A>,
-         SemanticDeclarationResolvedMixin<R, A>,
-         DeclarationResolverMixin {
+    with
+        SemanticSendResolvedMixin<R, A>,
+        SemanticDeclarationResolvedMixin<R, A>,
+        DeclarationResolverMixin {
   TreeElements elements;
 
   SemanticVisitor(this.elements);
 }
 
 // TODO(johnniwinther): Add visits for [visitLocalConstantGet],
 // [visitLocalConstantInvoke], [visitStaticConstantGet], etc.
 abstract class SemanticSendVisitor<R, A> {
   R apply(Node node, A arg);
 
   /// Read of the [parameter].
   ///
   /// For instance:
   ///
   ///     m(parameter) => parameter;
   ///
-  R visitParameterGet(
-      Send node,
-      ParameterElement parameter,
-      A arg);
+  R visitParameterGet(Send node, ParameterElement parameter, A arg);
 
   /// Assignment of [rhs] to the [parameter].
   ///
   /// For instance:
   ///
   ///     m(parameter) {
   ///       parameter = rhs;
   ///     }
   ///
   R visitParameterSet(
-      SendSet node,
-      ParameterElement parameter,
-      Node rhs,
-      A arg);
+      SendSet node, ParameterElement parameter, Node rhs, A arg);
 
   /// Assignment of [rhs] to the final [parameter].
   ///
   /// For instance:
   ///
   ///     m(final parameter) {
   ///       parameter = rhs;
   ///     }
   ///
   R visitFinalParameterSet(
-      SendSet node,
-      ParameterElement parameter,
-      Node rhs,
-      A arg);
+      SendSet node, ParameterElement parameter, Node rhs, A arg);
 
   /// Invocation of the [parameter] with [arguments].
   ///
   /// For instance:
   ///
   ///     m(parameter) {
   ///       parameter(null, 42);
   ///     }
   ///
-  R visitParameterInvoke(
-      Send node,
-      ParameterElement parameter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitParameterInvoke(Send node, ParameterElement parameter,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Read of the local [variable].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       var variable;
   ///       return variable;
   ///     }
   ///
-  R visitLocalVariableGet(
-      Send node,
-      LocalVariableElement variable,
-      A arg);
+  R visitLocalVariableGet(Send node, LocalVariableElement variable, A arg);
 
   /// Assignment of [rhs] to the local [variable].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       var variable;
   ///       variable = rhs;
   ///     }
   ///
   R visitLocalVariableSet(
-      SendSet node,
-      LocalVariableElement variable,
-      Node rhs,
-      A arg);
+      SendSet node, LocalVariableElement variable, Node rhs, A arg);
 
   /// Assignment of [rhs] to the final local [variable].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       final variable = null;
   ///       variable = rhs;
   ///     }
   ///
   R visitFinalLocalVariableSet(
-      SendSet node,
-      LocalVariableElement variable,
-      Node rhs,
-      A arg);
+      SendSet node, LocalVariableElement variable, Node rhs, A arg);
 
   /// Invocation of the local variable [variable] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       var variable;
   ///       variable(null, 42);
   ///     }
   ///
-  R visitLocalVariableInvoke(
-      Send node,
-      LocalVariableElement variable,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitLocalVariableInvoke(Send node, LocalVariableElement variable,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Closurization of the local [function].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       o(a, b) {}
   ///       return o;
   ///     }
   ///
-  R visitLocalFunctionGet(
-      Send node,
-      LocalFunctionElement function,
-      A arg);
+  R visitLocalFunctionGet(Send node, LocalFunctionElement function, A arg);
 
   /// Assignment of [rhs] to the local [function].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       o(a, b) {}
   ///       o = rhs;
   ///     }
   ///
   R visitLocalFunctionSet(
-      SendSet node,
-      LocalFunctionElement function,
-      Node rhs,
-      A arg);
+      SendSet node, LocalFunctionElement function, Node rhs, A arg);
 
   /// Invocation of the local [function] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       o(a, b) {}
   ///       return o(null, 42);
   ///     }
   ///
-  R visitLocalFunctionInvoke(
-      Send node,
-      LocalFunctionElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitLocalFunctionInvoke(Send node, LocalFunctionElement function,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of the local [function] with incompatible [arguments].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       o(a) {}
   ///       return o(null, 42);
   ///     }
   ///
   R visitLocalFunctionIncompatibleInvoke(
       Send node,
       LocalFunctionElement function,
       NodeList arguments,
       CallStructure callStructure,
       A arg);
 
   /// Getter call on [receiver] of the property defined by [selector].
   ///
   /// For instance:
   ///
   ///     m(receiver) => receiver.foo;
   ///
-  R visitDynamicPropertyGet(
-      Send node,
-      Node receiver,
-      Name name,
-      A arg);
+  R visitDynamicPropertyGet(Send node, Node receiver, Name name, A arg);
 
   /// Conditional (if not null) getter call on [receiver] of the property
   /// defined by [selector].
   ///
   /// For instance:
   ///
   ///     m(receiver) => receiver?.foo;
   ///
   R visitIfNotNullDynamicPropertyGet(
-      Send node,
-      Node receiver,
-      Name name,
-      A arg);
+      Send node, Node receiver, Name name, A arg);
 
   /// Setter call on [receiver] with argument [rhs] of the property defined by
   /// [selector].
   ///
   /// For instance:
   ///
   ///     m(receiver) {
   ///       receiver.foo = rhs;
   ///     }
   ///
   R visitDynamicPropertySet(
-      SendSet node,
-      Node receiver,
-      Name name,
-      Node rhs,
-      A arg);
+      SendSet node, Node receiver, Name name, Node rhs, A arg);
 
   /// Conditional (if not null) setter call on [receiver] with argument [rhs] of
   /// the property defined by [selector].
   ///
   /// For instance:
   ///
   ///     m(receiver) {
   ///       receiver?.foo = rhs;
   ///     }
   ///
   R visitIfNotNullDynamicPropertySet(
-      SendSet node,
-      Node receiver,
-      Name name,
-      Node rhs,
-      A arg);
+      SendSet node, Node receiver, Name name, Node rhs, A arg);
 
   /// Invocation of the property defined by [selector] on [receiver] with
   /// [arguments].
   ///
   /// For instance:
   ///
   ///     m(receiver) {
   ///       receiver.foo(null, 42);
   ///     }
   ///
   R visitDynamicPropertyInvoke(
-      Send node,
-      Node receiver,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+      Send node, Node receiver, NodeList arguments, Selector selector, A arg);
 
   /// Conditinal invocation of the property defined by [selector] on [receiver]
   /// with [arguments], if [receiver] is not null.
   ///
   /// For instance:
   ///
   ///     m(receiver) {
   ///       receiver?.foo(null, 42);
   ///     }
   ///
   R visitIfNotNullDynamicPropertyInvoke(
-      Send node,
-      Node receiver,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+      Send node, Node receiver, NodeList arguments, Selector selector, A arg);
 
   /// Getter call on `this` of the property defined by [selector].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m() => this.foo;
   ///     }
   ///
   /// or
   ///
   ///     class C {
   ///       m() => foo;
   ///     }
   ///
-  R visitThisPropertyGet(
-      Send node,
-      Name name,
-      A arg);
+  R visitThisPropertyGet(Send node, Name name, A arg);
 
   /// Setter call on `this` with argument [rhs] of the property defined by
   /// [selector].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m() { this.foo = rhs; }
   ///     }
   ///
   /// or
   ///
   ///     class C {
   ///       m() { foo = rhs; }
   ///     }
   ///
-  R visitThisPropertySet(
-      SendSet node,
-      Name name,
-      Node rhs,
-      A arg);
+  R visitThisPropertySet(SendSet node, Name name, Node rhs, A arg);
 
   /// Invocation of the property defined by [selector] on `this` with
   /// [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m() { this.foo(null, 42); }
   ///     }
   ///
   /// or
   ///
   ///     class C {
   ///       m() { foo(null, 42); }
   ///     }
   ///
   ///
   R visitThisPropertyInvoke(
-      Send node,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+      Send node, NodeList arguments, Selector selector, A arg);
 
   /// Read of `this`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m() => this;
   ///     }
   ///
-  R visitThisGet(
-      Identifier node,
-      A arg);
+  R visitThisGet(Identifier node, A arg);
 
   /// Invocation of `this` with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m() => this(null, 42);
   ///     }
   ///
   R visitThisInvoke(
-      Send node,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
-
+      Send node, NodeList arguments, CallStructure callStructure, A arg);
 
   /// Read of the super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var foo;
   ///     }
   ///     class C extends B {
   ///        m() => super.foo;
   ///     }
   ///
-  R visitSuperFieldGet(
-      Send node,
-      FieldElement field,
-      A arg);
+  R visitSuperFieldGet(Send node, FieldElement field, A arg);
 
   /// Assignment of [rhs] to the super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var foo;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitSuperFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitSuperFieldSet(SendSet node, FieldElement field, Node rhs, A arg);
 
   /// Assignment of [rhs] to the final static [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       final foo = null;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitFinalSuperFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitFinalSuperFieldSet(SendSet node, FieldElement field, Node rhs, A arg);
 
   /// Invocation of the super [field] with [arguments].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var foo;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42); }
   ///     }
   ///
-  R visitSuperFieldInvoke(
-      Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitSuperFieldInvoke(Send node, FieldElement field, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Closurization of the super [method].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() => super.foo;
   ///     }
   ///
-  R visitSuperMethodGet(
-      Send node,
-      MethodElement method,
-      A arg);
+  R visitSuperMethodGet(Send node, MethodElement method, A arg);
 
   /// Invocation of the super [method] with [arguments].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42); }
   ///     }
   ///
-  R visitSuperMethodInvoke(
-      Send node,
-      MethodElement method,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitSuperMethodInvoke(Send node, MethodElement method, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Invocation of the super [method] with incompatible [arguments].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null); } // One argument missing.
   ///     }
   ///
-  R visitSuperMethodIncompatibleInvoke(
-      Send node,
-      MethodElement method,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitSuperMethodIncompatibleInvoke(Send node, MethodElement method,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the super [method].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitSuperMethodSet(
-      Send node,
-      MethodElement method,
-      Node rhs,
-      A arg);
+  R visitSuperMethodSet(Send node, MethodElement method, Node rhs, A arg);
 
   /// Getter call to the super [getter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get foo => null;
   ///     }
   ///     class C extends B {
   ///        m() => super.foo;
   ///     }
   ///
-  R visitSuperGetterGet(
-      Send node,
-      FunctionElement getter,
-      A arg);
+  R visitSuperGetterGet(Send node, FunctionElement getter, A arg);
 
   /// Getter call the super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set foo(_) {}
   ///     }
   ///     class C extends B {
   ///        m() => super.foo;
   ///     }
   ///
-  R visitSuperSetterGet(
-      Send node,
-      FunctionElement setter,
-      A arg);
+  R visitSuperSetterGet(Send node, FunctionElement setter, A arg);
 
   /// Setter call to the super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set foo(_) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitSuperSetterSet(
-      SendSet node,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+  R visitSuperSetterSet(SendSet node, FunctionElement setter, Node rhs, A arg);
 
   /// Assignment of [rhs] to the super [getter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get foo => null;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitSuperGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
-      A arg);
+  R visitSuperGetterSet(SendSet node, FunctionElement getter, Node rhs, A arg);
 
   /// Invocation of the super [getter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get foo => null;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42; }
   ///     }
   ///
-  R visitSuperGetterInvoke(
-      Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitSuperGetterInvoke(Send node, FunctionElement getter,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of the super [setter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set foo(_) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42; }
   ///     }
   ///
-  R visitSuperSetterInvoke(
-      Send node,
-      FunctionElement setter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitSuperSetterInvoke(Send node, FunctionElement setter,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of a [expression] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() => (a, b){}(null, 42);
   ///
-  R visitExpressionInvoke(
-      Send node,
-      Node expression,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitExpressionInvoke(Send node, Node expression, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Read of the static [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static var foo;
   ///     }
   ///     m() => C.foo;
   ///
-  R visitStaticFieldGet(
-      Send node,
-      FieldElement field,
-      A arg);
+  R visitStaticFieldGet(Send node, FieldElement field, A arg);
 
   /// Assignment of [rhs] to the static [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static var foo;
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitStaticFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitStaticFieldSet(SendSet node, FieldElement field, Node rhs, A arg);
 
   /// Assignment of [rhs] to the final static [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static final foo;
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitFinalStaticFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitFinalStaticFieldSet(SendSet node, FieldElement field, Node rhs, A arg);
 
   /// Invocation of the static [field] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static var foo;
   ///     }
   ///     m() { C.foo(null, 42); }
   ///
-  R visitStaticFieldInvoke(
-      Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitStaticFieldInvoke(Send node, FieldElement field, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Closurization of the static [function].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() => C.foo;
   ///
-  R visitStaticFunctionGet(
-      Send node,
-      MethodElement function,
-      A arg);
+  R visitStaticFunctionGet(Send node, MethodElement function, A arg);
 
   /// Invocation of the static [function] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() { C.foo(null, 42); }
   ///
-  R visitStaticFunctionInvoke(
-      Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitStaticFunctionInvoke(Send node, MethodElement function,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of the static [function] with incompatible [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() { C.foo(null); }
   ///
-  R visitStaticFunctionIncompatibleInvoke(
-      Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitStaticFunctionIncompatibleInvoke(Send node, MethodElement function,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the static [function].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitStaticFunctionSet(
-      Send node,
-      MethodElement function,
-      Node rhs,
-      A arg);
+  R visitStaticFunctionSet(Send node, MethodElement function, Node rhs, A arg);
 
   /// Getter call to the static [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get foo => null;
   ///     }
   ///     m() => C.foo;
   ///
-  R visitStaticGetterGet(
-      Send node,
-      FunctionElement getter,
-      A arg);
+  R visitStaticGetterGet(Send node, FunctionElement getter, A arg);
 
   /// Getter call the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set foo(_) {}
   ///     }
   ///     m() => C.foo;
   ///
-  R visitStaticSetterGet(
-      Send node,
-      FunctionElement setter,
-      A arg);
+  R visitStaticSetterGet(Send node, FunctionElement setter, A arg);
 
   /// Setter call to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set foo(_) {}
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitStaticSetterSet(
-      SendSet node,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+  R visitStaticSetterSet(SendSet node, FunctionElement setter, Node rhs, A arg);
 
   /// Assignment of [rhs] to the static [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get foo => null;
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitStaticGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
-      A arg);
+  R visitStaticGetterSet(SendSet node, FunctionElement getter, Node rhs, A arg);
 
   /// Invocation of the static [getter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get foo => null;
   ///     }
   ///     m() { C.foo(null, 42; }
   ///
-  R visitStaticGetterInvoke(
-      Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitStaticGetterInvoke(Send node, FunctionElement getter,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of the static [setter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set foo(_) {}
   ///     }
   ///     m() { C.foo(null, 42; }
   ///
-  R visitStaticSetterInvoke(
-      Send node,
-      FunctionElement setter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitStaticSetterInvoke(Send node, FunctionElement setter,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Read of the top level [field].
   ///
   /// For instance:
   ///
   ///     var foo;
   ///     m() => foo;
   ///
-  R visitTopLevelFieldGet(
-      Send node,
-      FieldElement field,
-      A arg);
+  R visitTopLevelFieldGet(Send node, FieldElement field, A arg);
 
   /// Assignment of [rhs] to the top level [field].
   ///
   /// For instance:
   ///
   ///     var foo;
   ///     m() { foo = rhs; }
   ///
-  R visitTopLevelFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitTopLevelFieldSet(SendSet node, FieldElement field, Node rhs, A arg);
 
   /// Assignment of [rhs] to the final top level [field].
   ///
   /// For instance:
   ///
   ///     final foo = null;
   ///     m() { foo = rhs; }
   ///
   R visitFinalTopLevelFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+      SendSet node, FieldElement field, Node rhs, A arg);
 
   /// Invocation of the top level [field] with [arguments].
   ///
   /// For instance:
   ///
   ///     var foo;
   ///     m() { foo(null, 42); }
   ///
-  R visitTopLevelFieldInvoke(
-      Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitTopLevelFieldInvoke(Send node, FieldElement field, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Closurization of the top level [function].
   ///
   /// For instance:
   ///
   ///     foo(a, b) {};
   ///     m() => foo;
   ///
-  R visitTopLevelFunctionGet(
-      Send node,
-      MethodElement function,
-      A arg);
+  R visitTopLevelFunctionGet(Send node, MethodElement function, A arg);
 
   /// Invocation of the top level [function] with [arguments].
   ///
   /// For instance:
   ///
   ///     foo(a, b) {};
   ///     m() { foo(null, 42); }
   ///
-  R visitTopLevelFunctionInvoke(
-      Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitTopLevelFunctionInvoke(Send node, MethodElement function,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of the top level [function] with incompatible [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() { C.foo(null); }
   ///
-  R visitTopLevelFunctionIncompatibleInvoke(
-      Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitTopLevelFunctionIncompatibleInvoke(Send node, MethodElement function,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the top level [function].
   ///
   /// For instance:
   ///
   ///     foo(a, b) {};
   ///     m() { foo = rhs; }
   ///
   R visitTopLevelFunctionSet(
-      Send node,
-      MethodElement function,
-      Node rhs,
-      A arg);
+      Send node, MethodElement function, Node rhs, A arg);
 
   /// Getter call to the top level [getter].
   ///
   /// For instance:
   ///
   ///     get foo => null;
   ///     m() => foo;
   ///
-  R visitTopLevelGetterGet(
-      Send node,
-      FunctionElement getter,
-      A arg);
+  R visitTopLevelGetterGet(Send node, FunctionElement getter, A arg);
 
   /// Getter call the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m() => foo;
   ///
-  R visitTopLevelSetterGet(
-      Send node,
-      FunctionElement setter,
-      A arg);
+  R visitTopLevelSetterGet(Send node, FunctionElement setter, A arg);
 
   /// Setter call to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m() { foo = rhs; }
   ///
   R visitTopLevelSetterSet(
-      SendSet node,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+      SendSet node, FunctionElement setter, Node rhs, A arg);
 
   /// Assignment of [rhs] to the top level [getter].
   ///
   /// For instance:
   ///
   ///     get foo => null;
   ///     m() { foo = rhs; }
   ///
   R visitTopLevelGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
-      A arg);
+      SendSet node, FunctionElement getter, Node rhs, A arg);
 
   /// Invocation of the top level [getter] with [arguments].
   ///
   /// For instance:
   ///
   ///     get foo => null;
   ///     m() { foo(null, 42); }
   ///
-  R visitTopLevelGetterInvoke(
-      Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitTopLevelGetterInvoke(Send node, FunctionElement getter,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of the top level [setter] with [arguments].
   ///
   /// For instance:
   ///
   ///     set foo(_) {};
   ///     m() { foo(null, 42); }
   ///
-  R visitTopLevelSetterInvoke(
-      Send node,
-      FunctionElement setter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitTopLevelSetterInvoke(Send node, FunctionElement setter,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Read of the type literal for class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => C;
   ///
-  R visitClassTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
-      A arg);
+  R visitClassTypeLiteralGet(Send node, ConstantExpression constant, A arg);
 
   /// Invocation of the type literal for class [element] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => C(null, 42);
   ///
-  R visitClassTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitClassTypeLiteralInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the type literal for class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() { C = rhs; }
   ///
   R visitClassTypeLiteralSet(
-      SendSet node,
-      ConstantExpression constant,
-      Node rhs,
-      A arg);
+      SendSet node, ConstantExpression constant, Node rhs, A arg);
 
   /// Read of the type literal for typedef [element].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() => F;
   ///
-  R visitTypedefTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
-      A arg);
+  R visitTypedefTypeLiteralGet(Send node, ConstantExpression constant, A arg);
 
   /// Invocation of the type literal for typedef [element] with [arguments].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() => F(null, 42);
   ///
-  R visitTypedefTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitTypedefTypeLiteralInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the type literal for typedef [element].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() { F = rhs; }
   ///
   R visitTypedefTypeLiteralSet(
-      SendSet node,
-      ConstantExpression constant,
-      Node rhs,
-      A arg);
+      SendSet node, ConstantExpression constant, Node rhs, A arg);
 
   /// Read of the type literal for type variable [element].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m() => T;
   ///     }
   ///
   R visitTypeVariableTypeLiteralGet(
-      Send node,
-      TypeVariableElement element,
-      A arg);
+      Send node, TypeVariableElement element, A arg);
 
   /// Invocation of the type literal for type variable [element] with
   /// [arguments].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m() { T(null, 42); }
   ///     }
   ///
-  R visitTypeVariableTypeLiteralInvoke(
-      Send node,
-      TypeVariableElement element,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitTypeVariableTypeLiteralInvoke(Send node, TypeVariableElement element,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the type literal for type variable [element].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m() { T = rhs; }
   ///     }
   ///
   R visitTypeVariableTypeLiteralSet(
-      SendSet node,
-      TypeVariableElement element,
-      Node rhs,
-      A arg);
+      SendSet node, TypeVariableElement element, Node rhs, A arg);
 
   /// Read of the type literal for `dynamic`.
   ///
   /// For instance:
   ///
   ///     m() => dynamic;
   ///
-  R visitDynamicTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
-      A arg);
+  R visitDynamicTypeLiteralGet(Send node, ConstantExpression constant, A arg);
 
   /// Invocation of the type literal for `dynamic` with [arguments].
   ///
   /// For instance:
   ///
   ///     m() { dynamic(null, 42); }
   ///
-  R visitDynamicTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitDynamicTypeLiteralInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the type literal for `dynamic`.
   ///
   /// For instance:
   ///
   ///     m() { dynamic = rhs; }
   ///
   R visitDynamicTypeLiteralSet(
-      SendSet node,
-      ConstantExpression constant,
-      Node rhs,
-      A arg);
+      SendSet node, ConstantExpression constant, Node rhs, A arg);
 
   /// Binary expression `left operator right` where [operator] is a user
   /// definable operator. Binary expressions using operator `==` are handled
   /// by [visitEquals] and index operations `a[b]` are handled by [visitIndex].
   ///
   /// For instance:
   ///
   ///     add(a, b) => a + b;
   ///     sub(a, b) => a - b;
   ///     mul(a, b) => a * b;
   ///
   R visitBinary(
-      Send node,
-      Node left,
-      BinaryOperator operator,
-      Node right,
-      A arg);
+      Send node, Node left, BinaryOperator operator, Node right, A arg);
 
   /// Binary expression `super operator argument` where [operator] is a user
   /// definable operator implemented on a superclass by [function]. Binary
   /// expressions using operator `==` are handled by [visitSuperEquals].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator +(_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super + a;
   ///     }
   ///
-  R visitSuperBinary(
-      Send node,
-      FunctionElement function,
-      BinaryOperator operator,
-      Node argument,
-      A arg);
+  R visitSuperBinary(Send node, FunctionElement function,
+      BinaryOperator operator, Node argument, A arg);
 
   /// Binary operation on the unresolved super [element].
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super + 42;
   ///     }
   ///
-  R visitUnresolvedSuperBinary(
-      Send node,
-      Element element,
-      BinaryOperator operator,
-      Node argument,
-      A arg);
+  R visitUnresolvedSuperBinary(Send node, Element element,
+      BinaryOperator operator, Node argument, A arg);
 
   /// Index expression `receiver[index]`.
   ///
   /// For instance:
   ///
   ///     lookup(a, b) => a[b];
   ///
-  R visitIndex(
-      Send node,
-      Node receiver,
-      Node index,
-      A arg);
+  R visitIndex(Send node, Node receiver, Node index, A arg);
 
   /// Prefix operation on an index expression `operator receiver[index]` where
   /// the operation is defined by [operator].
   ///
   /// For instance:
   ///
   ///     lookup(a, b) => --a[b];
   ///
   R visitIndexPrefix(
-      Send node,
-      Node receiver,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+      Send node, Node receiver, Node index, IncDecOperator operator, A arg);
 
   /// Postfix operation on an index expression `receiver[index] operator` where
   /// the operation is defined by [operator].
   ///
   /// For instance:
   ///
   ///     lookup(a, b) => a[b]++;
   ///
   R visitIndexPostfix(
-      Send node,
-      Node receiver,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+      Send node, Node receiver, Node index, IncDecOperator operator, A arg);
 
   /// Index expression `super[index]` where 'operator []' is implemented on a
   /// superclass by [function].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super[a];
   ///     }
   ///
-  R visitSuperIndex(
-      Send node,
-      FunctionElement function,
-      Node index,
-      A arg);
+  R visitSuperIndex(Send node, FunctionElement function, Node index, A arg);
 
   /// Index expression `super[index]` where 'operator []' is unresolved.
   ///
   /// For instance:
   ///
   ///     class B {}
   ///     class C extends B {
   ///       m(a) => super[a];
   ///     }
   ///
-  R visitUnresolvedSuperIndex(
-      Send node,
-      Element element,
-      Node index,
-      A arg);
+  R visitUnresolvedSuperIndex(Send node, Element element, Node index, A arg);
 
   /// Prefix operation on an index expression `operator super[index]` where
   /// 'operator []' is implemented on a superclass by [indexFunction] and
   /// 'operator []=' is implemented on by [indexSetFunction] and the operation
   /// is defined by [operator].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => null;
@@ skipping 40 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator []=(a, b) {}
   ///     }
   ///     class C extends B {
   ///       m(a) => --super[a];
   ///     }
   ///
-  R visitUnresolvedSuperGetterIndexPrefix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedSuperGetterIndexPrefix(Send node, Element element,
+      MethodElement setter, Node index, IncDecOperator operator, A arg);
 
   /// Postfix operation on an index expression `super[index] operator` where
   /// 'operator []' is unresolved, 'operator []=' is defined by [setter], and
   /// the operation is defined by [operator].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator []=(a, b) {}
   ///     }
   ///     class C extends B {
   ///       m(a) => super[a]++;
   ///     }
   ///
-  R visitUnresolvedSuperGetterIndexPostfix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedSuperGetterIndexPostfix(Send node, Element element,
+      MethodElement setter, Node index, IncDecOperator operator, A arg);
 
   /// Prefix operation on an index expression `operator super[index]` where
   /// 'operator []' is implemented on a superclass by [indexFunction] and
   /// 'operator []=' is unresolved and the operation is defined by [operator].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => 42;
   ///     }
@@ skipping 37 matching lines @@
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => 42;
   ///     }
   ///     class C extends B {
   ///       m(a) => super[a]++;
   ///     }
   ///
   R visitUnresolvedSuperIndexPrefix(
-      Send node,
-      Element element,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+      Send node, Element element, Node index, IncDecOperator operator, A arg);
 
   /// Postfix operation on an index expression `super[index] operator` where
   /// both 'operator []' and 'operator []=' are unresolved and the operation is
   /// defined by [operator].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => 42;
   ///     }
   ///     class C extends B {
   ///       m(a) => super[a]++;
   ///     }
   ///
   R visitUnresolvedSuperIndexPostfix(
-      Send node,
-      Element element,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+      Send node, Element element, Node index, IncDecOperator operator, A arg);
 
   /// Binary expression `left == right`.
   ///
   /// For instance:
   ///
   ///     neq(a, b) => a != b;
   ///
-  R visitNotEquals(
-      Send node,
-      Node left,
-      Node right,
-      A arg);
+  R visitNotEquals(Send node, Node left, Node right, A arg);
 
   /// Binary expression `super != argument` where `==` is implemented on a
   /// superclass by [function].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator +(_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super + a;
   ///     }
   ///
   R visitSuperNotEquals(
-      Send node,
-      FunctionElement function,
-      Node argument,
-      A arg);
+      Send node, FunctionElement function, Node argument, A arg);
 
   /// Binary expression `left == right`.
   ///
   /// For instance:
   ///
   ///     eq(a, b) => a == b;
   ///
-  R visitEquals(
-      Send node,
-      Node left,
-      Node right,
-      A arg);
+  R visitEquals(Send node, Node left, Node right, A arg);
 
   /// Binary expression `super == argument` where `==` is implemented on a
   /// superclass by [function].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator ==(_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super == a;
   ///     }
   ///
-  R visitSuperEquals(
-      Send node,
-      FunctionElement function,
-      Node argument,
-      A arg);
+  R visitSuperEquals(Send node, FunctionElement function, Node argument, A arg);
 
   /// Unary expression `operator expression` where [operator] is a user
   /// definable operator.
   ///
   /// For instance:
   ///
   ///     neg(a, b) => -a;
   ///     comp(a, b) => ~a;
   ///
-  R visitUnary(
-      Send node,
-      UnaryOperator operator,
-      Node expression,
-      A arg);
+  R visitUnary(Send node, UnaryOperator operator, Node expression, A arg);
 
   /// Unary expression `operator super` where [operator] is a user definable
   /// operator implemented on a superclass by [function].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator -() => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => -super;
   ///     }
   ///
   R visitSuperUnary(
-      Send node,
-      UnaryOperator operator,
-      FunctionElement function,
-      A arg);
+      Send node, UnaryOperator operator, FunctionElement function, A arg);
 
   /// Unary operation on the unresolved super [element].
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => -super;
   ///     }
   ///
   R visitUnresolvedSuperUnary(
-      Send node,
-      UnaryOperator operator,
-      Element element,
-      A arg);
+      Send node, UnaryOperator operator, Element element, A arg);
 
   /// Unary expression `!expression`.
   ///
   /// For instance:
   ///
   ///     not(a) => !a;
   ///
-  R visitNot(
-      Send node,
-      Node expression,
-      A arg);
+  R visitNot(Send node, Node expression, A arg);
 
   /// Index set expression `receiver[index] = rhs`.
   ///
   /// For instance:
   ///
   ///     m(receiver, index, rhs) => receiver[index] = rhs;
   ///
-  R visitIndexSet(
-      SendSet node,
-      Node receiver,
-      Node index,
-      Node rhs,
-      A arg);
+  R visitIndexSet(SendSet node, Node receiver, Node index, Node rhs, A arg);
 
   /// Index set expression `super[index] = rhs` where `operator []=` is defined
   /// on a superclass by [function].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator []=(a, b) {}
   ///     }
   ///     class C extends B {
   ///       m(a, b) => super[a] = b;
   ///     }
   ///
   R visitSuperIndexSet(
-      SendSet node,
-      FunctionElement function,
-      Node index,
-      Node rhs,
-      A arg);
+      SendSet node, FunctionElement function, Node index, Node rhs, A arg);
 
   /// Index set expression `super[index] = rhs` where `operator []=` is
   /// undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super[1] = 42;
   ///     }
   ///
   R visitUnresolvedSuperIndexSet(
-      Send node,
-      Element element,
-      Node index,
-      Node rhs,
-      A arg);
+      Send node, Element element, Node index, Node rhs, A arg);
 
   /// If-null, ??, expression with operands [left] and [right].
   ///
   /// For instance:
   ///
   ///     m() => left ?? right;
   ///
-  R visitIfNull(
-      Send node,
-      Node left,
-      Node right,
-      A arg);
+  R visitIfNull(Send node, Node left, Node right, A arg);
 
   /// Logical and, &&, expression with operands [left] and [right].
   ///
   /// For instance:
   ///
   ///     m() => left && right;
   ///
-  R visitLogicalAnd(
-      Send node,
-      Node left,
-      Node right,
-      A arg);
+  R visitLogicalAnd(Send node, Node left, Node right, A arg);
 
   /// Logical or, ||, expression with operands [left] and [right].
   ///
   /// For instance:
   ///
   ///     m() => left || right;
   ///
-  R visitLogicalOr(
-      Send node,
-      Node left,
-      Node right,
-      A arg);
+  R visitLogicalOr(Send node, Node left, Node right, A arg);
 
   /// Is test of [expression] against [type].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => expression is C;
   ///
-  R visitIs(
-      Send node,
-      Node expression,
-      DartType type,
-      A arg);
+  R visitIs(Send node, Node expression, DartType type, A arg);
 
   /// Is not test of [expression] against [type].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => expression is! C;
   ///
-  R visitIsNot(
-      Send node,
-      Node expression,
-      DartType type,
-      A arg);
+  R visitIsNot(Send node, Node expression, DartType type, A arg);
 
   /// As cast of [expression] to [type].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => expression as C;
   ///
-  R visitAs(
-      Send node,
-      Node expression,
-      DartType type,
-      A arg);
+  R visitAs(Send node, Node expression, DartType type, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] of the property on
   /// [receiver] whose getter and setter are defined by [getterSelector] and
   /// [setterSelector], respectively.
   ///
   /// For instance:
   ///
   ///     m(receiver, rhs) => receiver.foo += rhs;
   ///
-  R visitDynamicPropertyCompound(
-      Send node,
-      Node receiver,
-      Name name,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitDynamicPropertyCompound(Send node, Node receiver, Name name,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] of the property on
   /// a possibly null [receiver] whose getter and setter are defined by
   /// [getterSelector] and [setterSelector], respectively.
   ///
   /// For instance:
   ///
   ///     m(receiver, rhs) => receiver?.foo += rhs;
   ///
-  R visitIfNotNullDynamicPropertyCompound(
-      Send node,
-      Node receiver,
-      Name name,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitIfNotNullDynamicPropertyCompound(Send node, Node receiver, Name name,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] of the property on
   /// `this` whose getter and setter are defined by [getterSelector] and
   /// [setterSelector], respectively.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m(rhs) => this.foo += rhs;
   ///     }
   ///
   /// or
   ///
   ///     class C {
   ///       m(rhs) => foo += rhs;
   ///     }
   ///
   R visitThisPropertyCompound(
-      Send node,
-      Name name,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+      Send node, Name name, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a [parameter].
   ///
   /// For instance:
   ///
   ///     m(parameter, rhs) => parameter += rhs;
   ///
-  R visitParameterCompound(
-      Send node,
-      ParameterElement parameter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitParameterCompound(Send node, ParameterElement parameter,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final
   /// [parameter].
   ///
   /// For instance:
   ///
   ///     m(final parameter, rhs) => parameter += rhs;
   ///
-  R visitFinalParameterCompound(
-      Send node,
-      ParameterElement parameter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitFinalParameterCompound(Send node, ParameterElement parameter,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a local
   /// [variable].
   ///
   /// For instance:
   ///
   ///     m(rhs) {
   ///       var variable;
   ///       variable += rhs;
   ///     }
   ///
-  R visitLocalVariableCompound(
-      Send node,
-      LocalVariableElement variable,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitLocalVariableCompound(Send node, LocalVariableElement variable,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final local
   /// [variable].
   ///
   /// For instance:
   ///
   ///     m(rhs) {
   ///       final variable = 0;
   ///       variable += rhs;
   ///     }
   ///
-  R visitFinalLocalVariableCompound(
-      Send node,
-      LocalVariableElement variable,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitFinalLocalVariableCompound(Send node, LocalVariableElement variable,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a local
   /// [function].
   ///
   /// For instance:
   ///
   ///     m(rhs) {
   ///       function() {}
   ///       function += rhs;
   ///     }
   ///
-  R visitLocalFunctionCompound(
-      Send node,
-      LocalFunctionElement function,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitLocalFunctionCompound(Send node, LocalFunctionElement function,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a static
   /// [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static var field;
   ///       m(rhs) => field += rhs;
   ///     }
   ///
-  R visitStaticFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitStaticFieldCompound(Send node, FieldElement field,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final static
   /// [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static final field = 0;
   ///       m(rhs) => field += rhs;
   ///     }
   ///
-  R visitFinalStaticFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitFinalStaticFieldCompound(Send node, FieldElement field,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// static [getter] and writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m(rhs) => o += rhs;
   ///     }
   ///
-  R visitStaticGetterSetterCompound(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitStaticGetterSetterCompound(Send node, FunctionElement getter,
+      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// static [method], that is, closurizing [method], and writing to a static
   /// [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m(rhs) => o += rhs;
   ///     }
   ///
-  R visitStaticMethodSetterCompound(
-      Send node,
-      MethodElement method,
-      MethodElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitStaticMethodSetterCompound(Send node, MethodElement method,
+      MethodElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a top level
   /// [field].
   ///
   /// For instance:
   ///
   ///     var field;
   ///     m(rhs) => field += rhs;
   ///
-  R visitTopLevelFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitTopLevelFieldCompound(Send node, FieldElement field,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final top
   /// level [field].
   ///
   /// For instance:
   ///
   ///     final field = 0;
   ///     m(rhs) => field += rhs;
   ///
-  R visitFinalTopLevelFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitFinalTopLevelFieldCompound(Send node, FieldElement field,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// top level [getter] and writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m(rhs) => o += rhs;
   ///
-  R visitTopLevelGetterSetterCompound(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitTopLevelGetterSetterCompound(Send node, FunctionElement getter,
+      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// top level [method], that is, closurizing [method], and writing to a top
   /// level [setter].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m(rhs) => o += rhs;
   ///
-  R visitTopLevelMethodSetterCompound(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitTopLevelMethodSetterCompound(Send node, FunctionElement method,
+      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// top level [method], that is, closurizing [method], and writing to an
   /// unresolved setter.
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     m(rhs) => o += rhs;
   ///
-  R visitTopLevelMethodCompound(
-      Send node,
-      FunctionElement method,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitTopLevelMethodCompound(Send node, FunctionElement method,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a super
   /// [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var field;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field += rhs;
   ///     }
   ///
-  R visitSuperFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitSuperFieldCompound(Send node, FieldElement field,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final super
   /// [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       final field = 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field += rhs;
   ///     }
   ///
-  R visitFinalSuperFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitFinalSuperFieldCompound(Send node, FieldElement field,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the [name] property on
   /// [receiver]. That is, [rhs] is only evaluated and assigned, if the value
   /// of [name] on [receiver] is `null`.
   ///
   /// For instance:
   ///
   ///     m(receiver, rhs) => receiver.foo ??= rhs;
   ///
   R visitDynamicPropertySetIfNull(
-      Send node,
-      Node receiver,
-      Name name,
-      Node rhs,
-      A arg);
+      Send node, Node receiver, Name name, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the [name] property on
   /// [receiver] if not null. That is, [rhs] is only evaluated and assigned,
   /// if the value of [receiver] is _not_ `null` and the value of [name] on
   /// [receiver] is `null`.
   ///
   /// For instance:
   ///
   ///     m(receiver, rhs) => receiver?.foo ??= rhs;
   ///
   R visitIfNotNullDynamicPropertySetIfNull(
-      Send node,
-      Node receiver,
-      Name name,
-      Node rhs,
-      A arg);
+      Send node, Node receiver, Name name, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the [name] property on `this`.
   /// That is, [rhs] is only evaluated and assigned, if the value of [name] on
   /// `this` is `null`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m(rhs) => this.foo ??= rhs;
   ///     }
   ///
   /// or
   ///
   ///     class C {
   ///       m(rhs) => foo ??= rhs;
   ///     }
   ///
-  R visitThisPropertySetIfNull(
-      Send node,
-      Name name,
-      Node rhs,
-      A arg);
+  R visitThisPropertySetIfNull(Send node, Name name, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [parameter]. That is, [rhs] is
   /// only evaluated and assigned, if the value of the [parameter] is `null`.
   ///
   /// For instance:
   ///
   ///     m(parameter, rhs) => parameter ??= rhs;
   ///
   R visitParameterSetIfNull(
-      Send node,
-      ParameterElement parameter,
-      Node rhs,
-      A arg);
+      Send node, ParameterElement parameter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the final [parameter]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [parameter] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     m(final parameter, rhs) => parameter ??= rhs;
   ///
   R visitFinalParameterSetIfNull(
-      Send node,
-      ParameterElement parameter,
-      Node rhs,
-      A arg);
+      Send node, ParameterElement parameter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the local [variable]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [variable] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     m(rhs) {
   ///       var variable;
   ///       variable ??= rhs;
   ///     }
   ///
   R visitLocalVariableSetIfNull(
-      Send node,
-      LocalVariableElement variable,
-      Node rhs,
-      A arg);
+      Send node, LocalVariableElement variable, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the final local [variable]. That
   /// is, [rhs] is only evaluated and assigned, if the value of the [variable]
   /// is `null`.
   ///
   /// For instance:
   ///
   ///     m(rhs) {
   ///       final variable = 0;
   ///       variable ??= rhs;
   ///     }
   ///
   R visitFinalLocalVariableSetIfNull(
-      Send node,
-      LocalVariableElement variable,
-      Node rhs,
-      A arg);
+      Send node, LocalVariableElement variable, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the local [function]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [function] is
   /// `null`. The behavior is thus equivalent to a closurization of [function].
   ///
   /// For instance:
   ///
   ///     m(rhs) {
   ///       function() {}
   ///       function ??= rhs;
   ///     }
   ///
   R visitLocalFunctionSetIfNull(
-      Send node,
-      LocalFunctionElement function,
-      Node rhs,
-      A arg);
+      Send node, LocalFunctionElement function, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static [field]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [field] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static var field;
   ///       m(rhs) => field ??= rhs;
   ///     }
   ///
-  R visitStaticFieldSetIfNull(
-      Send node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitStaticFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the final static [field]. That
   /// is, [rhs] is only evaluated and assigned, if the value of the [field] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static final field = 0;
   ///       m(rhs) => field ??= rhs;
   ///     }
   ///
   R visitFinalStaticFieldSetIfNull(
-      Send node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+      Send node, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static property defined by
   /// [getter] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [getter] is `null`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m(rhs) => o ??= rhs;
   ///     }
   ///
-  R visitStaticGetterSetterSetIfNull(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+  R visitStaticGetterSetterSetIfNull(Send node, FunctionElement getter,
+      FunctionElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static property defined by
   /// [method] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [method] is `null`. The behavior is thus
   /// equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m(rhs) => o ??= rhs;
   ///     }
   ///
   R visitStaticMethodSetterSetIfNull(
-      Send node,
-      MethodElement method,
-      MethodElement setter,
-      Node rhs,
-      A arg);
+      Send node, MethodElement method, MethodElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static [method]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [method] is
   /// `null`. The behavior is thus equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     m(rhs) => o ??= rhs;
   ///
   R visitStaticMethodSetIfNull(
-      Send node,
-      FunctionElement method,
-      Node rhs,
-      A arg);
+      Send node, FunctionElement method, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level [field]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [field] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     var field;
   ///     m(rhs) => field ??= rhs;
   ///
-  R visitTopLevelFieldSetIfNull(
-      Send node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitTopLevelFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the final top level [field].
   /// That is, [rhs] is only evaluated and assigned, if the value of the [field]
   /// is `null`.
   ///
   /// For instance:
   ///
   ///     final field = 0;
   ///     m(rhs) => field ??= rhs;
   ///
   R visitFinalTopLevelFieldSetIfNull(
-      Send node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+      Send node, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [getter] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [getter] is `null`.
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m(rhs) => o ??= rhs;
   ///
-  R visitTopLevelGetterSetterSetIfNull(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+  R visitTopLevelGetterSetterSetIfNull(Send node, FunctionElement getter,
+      FunctionElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [method] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [method] is `null`. The behavior is thus
   /// equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m(rhs) => o ??= rhs;
   ///
-  R visitTopLevelMethodSetterSetIfNull(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+  R visitTopLevelMethodSetterSetIfNull(Send node, FunctionElement method,
+      FunctionElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level [method]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [method] is
   /// `null`. The behavior is thus equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     m(rhs) => o ??= rhs;
   ///
   R visitTopLevelMethodSetIfNull(
-      Send node,
-      FunctionElement method,
-      Node rhs,
-      A arg);
+      Send node, FunctionElement method, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super [field]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [field] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var field;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field ??= rhs;
   ///     }
   ///
-  R visitSuperFieldSetIfNull(
-      Send node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+  R visitSuperFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the final super [field]. That
   /// is, [rhs] is only evaluated and assigned, if the value of the [field] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       final field = 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field ??= rhs;
   ///     }
   ///
   R visitFinalSuperFieldSetIfNull(
-      Send node,
-      FieldElement field,
-      Node rhs,
-      A arg);
+      Send node, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super property defined
   /// by [readField] and [writtenField]. That is, [rhs] is only evaluated and
   /// assigned to the [writtenField], if the value of the [readField] is `null`.
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       final field;
   ///     }
   ///     class C extends B {
   ///       m() => super.field ??= rhs;
   ///     }
   ///
-  R visitSuperFieldFieldSetIfNull(
-      Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      Node rhs,
-      A arg);
+  R visitSuperFieldFieldSetIfNull(Send node, FieldElement readField,
+      FieldElement writtenField, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super property defined
   /// by [getter] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [getter] is `null`.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 0;
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
-  R visitSuperGetterSetterSetIfNull(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+  R visitSuperGetterSetterSetIfNull(Send node, FunctionElement getter,
+      FunctionElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super property defined
   /// by [method] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [method] is `null`. The behavior is thus
   /// equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
-  R visitSuperMethodSetterSetIfNull(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+  R visitSuperMethodSetterSetIfNull(Send node, FunctionElement method,
+      FunctionElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super [method].
   /// That is, [rhs] is only evaluated and assigned, if the value of
   /// the [method] is `null`. The behavior is thus equivalent to a closurization
   /// of [method].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitSuperMethodSetIfNull(
-      Send node,
-      FunctionElement method,
-      Node rhs,
-      A arg);
+      Send node, FunctionElement method, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super property defined
   /// by [setter] with no corresponding getter. That is, [rhs] is only evaluated
   /// and assigned to the [setter], if the value of the unresolved getter is
   /// `null`. The behavior is thus equivalent to a no such method error.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitUnresolvedSuperGetterSetIfNull(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node rhs,
-      A arg);
+      Send node, Element element, MethodElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super property defined
   /// by [getter] with no corresponding setter. That is, [rhs] is only evaluated
   /// and assigned to the unresolved setter, if the value of the [getter] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitUnresolvedSuperSetterSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node rhs,
-      A arg);
+      Send node, MethodElement getter, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [field] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [field] is `null`.
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitSuperFieldSetterSetIfNull(
-      Send node,
-      FieldElement field,
-      FunctionElement setter,
-      Node rhs,
-      A arg);
+      Send node, FieldElement field, FunctionElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [getter] and [field]. That is, [rhs] is only evaluated and assigned to
   /// the [field], if the value of the [getter] is `null`.
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       get o => 0;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitSuperGetterFieldSetIfNull(
-      Send node,
-      FunctionElement getter,
-      FieldElement field,
-      Node rhs,
-      A arg);
+      Send node, FunctionElement getter, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to an unresolved super property.
   /// That is, [rhs] is only evaluated and assigned, if the value of the
   /// unresolved property is `null`. The behavior is thus equivalent to a no
   /// such method error.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.unresolved ??= rhs;
   ///     }
   ///
-  R visitUnresolvedSuperSetIfNull(
-      Send node,
-      Element element,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSuperSetIfNull(Send node, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static property defined
   /// by [setter] with no corresponding getter. That is, [rhs] is only evaluated
   /// and assigned to the [setter], if the value of the unresolved
   /// getter is `null`. The behavior is thus equivalent to a no such method
   /// error.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => C.foo ??= 42;
   ///
   R visitUnresolvedStaticGetterSetIfNull(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node rhs,
-      A arg);
+      Send node, Element element, MethodElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [setter] with no corresponding getter. That is, [rhs] is only evaluated
   /// and assigned to the [setter], if the value of the unresolved getter is
   /// `null`. The behavior is thus equivalent to a no such method error.
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => foo ??= 42;
   ///
   R visitUnresolvedTopLevelGetterSetIfNull(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node rhs,
-      A arg);
+      Send node, Element element, MethodElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static property defined
   /// by [getter] with no corresponding setter. That is, [rhs] is only evaluated
   /// and assigned to the unresolved setter, if the value of the [getter] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => C.foo ??= 42;
   ///
   R visitUnresolvedStaticSetterSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node rhs,
-      A arg);
+      Send node, MethodElement getter, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [getter] with no corresponding setter. That is, [rhs] is only evaluated
   /// and assigned to the unresolved setter, if the value of the [getter] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => foo ??= 42;
   ///
   R visitUnresolvedTopLevelSetterSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node rhs,
-      A arg);
+      Send node, MethodElement getter, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to an unresolved property.
   /// That is, [rhs] is only evaluated and assigned, if the value of the
   /// unresolved property is `null`. The behavior is thus equivalent to a no
   /// such method error.
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => unresolved ??= 42;
   ///     m2() => C.unresolved ??= 42;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R visitUnresolvedSetIfNull(
-      Send node,
-      Element element,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSetIfNull(Send node, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m() => p ??= 42;
   ///
-  R errorInvalidSetIfNull(
-      Send node,
-      ErroneousElement error,
-      Node rhs,
-      A arg);
+  R errorInvalidSetIfNull(Send node, ErroneousElement error, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the class type literal
   /// [contant]. That is, [rhs] is only evaluated and assigned, if the value
   /// is of the [constant] is `null`. The behavior is thus equivalent to a type
   /// literal access.
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m(rhs) => C ??= rhs;
   ///
   R visitClassTypeLiteralSetIfNull(
-      Send node,
-      ConstantExpression constant,
-      Node rhs,
-      A arg);
+      Send node, ConstantExpression constant, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the typedef type literal
   /// [constant]. That is, [rhs] is only evaluated and assigned, if the value
   /// is of the [constant] is `null`. The behavior is thus equivalent to a type
   /// literal access.
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m(rhs) => F ??= rhs;
   ///
   R visitTypedefTypeLiteralSetIfNull(
-      Send node,
-      ConstantExpression constant,
-      Node rhs,
-      A arg);
+      Send node, ConstantExpression constant, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the type literal for the type
   /// variable [element]. That is, [rhs] is only evaluated and assigned, if
   /// the value is of the [element] is `null`. The behavior is thus equivalent to
   /// a type literal access.
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m(rhs) => T ??= rhs;
   ///     }
   ///
   R visitTypeVariableTypeLiteralSetIfNull(
-      Send node,
-      TypeVariableElement element,
-      Node rhs,
-      A arg);
+      Send node, TypeVariableElement element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the dynamic type literal
   /// [constant]. That is, [rhs] is only evaluated and assigned, if the value
   /// is of the [constant] is `null`. The behavior is thus equivalent to a type
   /// literal access.
   ///
   /// For instance:
   ///
   ///     m(rhs) => dynamic ??= rhs;
   ///
   R visitDynamicTypeLiteralSetIfNull(
-      Send node,
-      ConstantExpression constant,
-      Node rhs,
-      A arg);
+      Send node, ConstantExpression constant, Node rhs, A arg);
 
   /// Prefix expression with [operator] on a final super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       final field = 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => ++super.field;
   ///     }
   ///
   R visitFinalSuperFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on an unresolved super property.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m(rhs) => ++super.unresolved;
   ///     }
   ///
   R visitUnresolvedSuperPrefix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+      Send node, Element element, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on an unresolved super property.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.unresolved++;
   ///     }
   ///
   R visitUnresolvedSuperPostfix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+      Send node, Element element, IncDecOperator operator, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on an unresolved
   /// super property.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.unresolved += rhs;
   ///     }
   ///
   R visitUnresolvedSuperCompound(
-      Send node,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+      Send node, Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Postfix expression with [operator] on a final super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       final field = 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field++;
   ///     }
   ///
   R visitFinalSuperFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from the
   /// super field [readField] and writing to the different super field
   /// [writtenField].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       final field;
   ///     }
   ///     class C extends B {
   ///       m() => super.field += rhs;
   ///     }
   ///
-  R visitSuperFieldFieldCompound(
-      Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitSuperFieldFieldCompound(Send node, FieldElement readField,
+      FieldElement writtenField, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [getter] and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 0;
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitSuperGetterSetterCompound(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitSuperGetterSetterCompound(Send node, FunctionElement getter,
+      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [method], that is, closurizing [method], and writing to a super
   /// [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitSuperMethodSetterCompound(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitSuperMethodSetterCompound(Send node, FunctionElement method,
+      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading the
   /// closurized super [method] and trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitSuperMethodCompound(
-      Send node,
-      FunctionElement method,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitSuperMethodCompound(Send node, FunctionElement method,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from the
   /// non-existing super getter and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitUnresolvedSuperGetterCompound(
-      Send node,
-      Element element,
-      MethodElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSuperGetterCompound(Send node, Element element,
+      MethodElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [getter] and writing to the non-existing super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitUnresolvedSuperSetterCompound(
-      Send node,
-      MethodElement getter,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSuperSetterCompound(Send node, MethodElement getter,
+      Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [field] and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitSuperFieldSetterCompound(
-      Send node,
-      FieldElement field,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitSuperFieldSetterCompound(Send node, FieldElement field,
+      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [getter] and writing to a super [field].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       get o => 0;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitSuperGetterFieldCompound(
-      Send node,
-      FunctionElement getter,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitSuperGetterFieldCompound(Send node, FunctionElement getter,
+      FieldElement field, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m(rhs) => C += rhs;
   ///
-  R visitClassTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitClassTypeLiteralCompound(Send node, ConstantExpression constant,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for typedef [element].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m(rhs) => F += rhs;
   ///
-  R visitTypedefTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitTypedefTypeLiteralCompound(Send node, ConstantExpression constant,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for type variable [element].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m(rhs) => T += rhs;
   ///     }
   ///
-  R visitTypeVariableTypeLiteralCompound(
-      Send node,
-      TypeVariableElement element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitTypeVariableTypeLiteralCompound(Send node, TypeVariableElement element,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on the type
   /// literal for `dynamic`.
   ///
   /// For instance:
   ///
   ///     m(rhs) => dynamic += rhs;
   ///
-  R visitDynamicTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitDynamicTypeLiteralCompound(Send node, ConstantExpression constant,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound index assignment of [rhs] with [operator] to [index] on the
   /// index operators of [receiver].
   ///
   /// For instance:
   ///
   ///     m(receiver, index, rhs) => receiver[index] += rhs;
   ///
-  R visitCompoundIndexSet(
-      SendSet node,
-      Node receiver,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitCompoundIndexSet(SendSet node, Node receiver, Node index,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound index assignment of [rhs] with [operator] to [index] on the index
   /// operators of a super class defined by [getter] and [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](index) {}
   ///       operator [](index, value) {}
   ///     }
@@ skipping 57 matching lines @@
   /// class where the index getter and setter are undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super[1] += 42;
   ///     }
   ///
-  R visitUnresolvedSuperCompoundIndexSet(
-      Send node,
-      Element element,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSuperCompoundIndexSet(Send node, Element element, Node index,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on the index operators
   /// of [receiver].
   ///
   /// For instance:
   ///
   ///     m(receiver, index, rhs) => receiver[index] ??= rhs;
   ///
   R visitIndexSetIfNull(
-      SendSet node,
-      Node receiver,
-      Node index,
-      Node rhs,
-      A arg);
+      SendSet node, Node receiver, Node index, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on the index operators
   /// of a super class defined by [getter] and [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](index) {}
   ///       operator [](index, value) {}
   ///     }
   ///     class C extends B {
   ///       m(index, rhs) => super[index] ??= rhs;
   ///     }
   ///
-  R visitSuperIndexSetIfNull(
-      SendSet node,
-      MethodElement getter,
-      MethodElement setter,
-      Node index,
-      Node rhs,
-      A arg);
+  R visitSuperIndexSetIfNull(SendSet node, MethodElement getter,
+      MethodElement setter, Node index, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on a super class where
   /// the index getter is undefined and the index setter is defined by [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](index, value) {}
   ///     }
   ///     class C extends B {
   ///       m() => super[1] ??= 42;
   ///     }
   ///
-  R visitUnresolvedSuperGetterIndexSetIfNull(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node index,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSuperGetterIndexSetIfNull(Send node, Element element,
+      MethodElement setter, Node index, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on a super class where
   /// the index getter is defined by [getter] but the index setter is undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](index) => 42;
   ///     }
   ///     class C extends B {
   ///       m() => super[1] ??= 42;
   ///     }
   ///
-  R visitUnresolvedSuperSetterIndexSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node index,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSuperSetterIndexSetIfNull(Send node, MethodElement getter,
+      Element element, Node index, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on a super class where
   /// the index getter and setter are undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super[1] ??= 42;
   ///     }
   ///
   R visitUnresolvedSuperIndexSetIfNull(
-      Send node,
-      Element element,
-      Node index,
-      Node rhs,
-      A arg);
+      Send node, Element element, Node index, Node rhs, A arg);
 
   /// Prefix expression with [operator] of the property on [receiver] whose
   /// getter and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
   ///
   ///     m(receiver) => ++receiver.foo;
   ///
   R visitDynamicPropertyPrefix(
-      Send node,
-      Node receiver,
-      Name name,
-      IncDecOperator operator,
-      A arg);
+      Send node, Node receiver, Name name, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] of the property on a possibly null
   /// [receiver] whose getter and setter are defined by [getterSelector] and
   /// [setterSelector], respectively.
   ///
   /// For instance:
   ///
   ///     m(receiver) => ++receiver?.foo;
   ///
   R visitIfNotNullDynamicPropertyPrefix(
-      Send node,
-      Node receiver,
-      Name name,
-      IncDecOperator operator,
-      A arg);
+      Send node, Node receiver, Name name, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a [parameter].
   ///
   /// For instance:
   ///
   ///     m(parameter) => ++parameter;
   ///
   R visitParameterPrefix(
-      Send node,
-      ParameterElement parameter,
-      IncDecOperator operator,
-      A arg);
+      Send node, ParameterElement parameter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a final [parameter].
   ///
   /// For instance:
   ///
   ///     m(final parameter) => ++parameter;
   ///
   R visitFinalParameterPrefix(
-      Send node,
-      ParameterElement parameter,
-      IncDecOperator operator,
-      A arg);
+      Send node, ParameterElement parameter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a local [variable].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       var variable;
   ///       ++variable;
   ///     }
   ///
   R visitLocalVariablePrefix(
-      Send node,
-      LocalVariableElement variable,
-      IncDecOperator operator,
-      A arg);
+      Send node, LocalVariableElement variable, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a final local [variable].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       final variable;
   ///       ++variable;
   ///     }
   ///
   R visitFinalLocalVariablePrefix(
-      Send node,
-      LocalVariableElement variable,
-      IncDecOperator operator,
-      A arg);
+      Send node, LocalVariableElement variable, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a local [function].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       function() {}
   ///       ++function;
   ///     }
   ///
   R visitLocalFunctionPrefix(
-      Send node,
-      LocalFunctionElement function,
-      IncDecOperator operator,
-      A arg);
-
+      Send node, LocalFunctionElement function, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] of the property on `this` whose getter
   /// and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m() => ++foo;
   ///     }
   ///
   /// or
   ///
   ///     class C {
   ///       m() => ++this.foo;
   ///     }
   ///
   R visitThisPropertyPrefix(
-      Send node,
-      Name name,
-      IncDecOperator operator,
-      A arg);
+      Send node, Name name, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a static [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static var field;
   ///       m() => ++field;
   ///     }
   ///
   R visitStaticFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a final static [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static final field = 42;
   ///       m() => ++field;
   ///     }
   ///
   R visitFinalStaticFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a static [getter] and
   /// writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m() => ++o;
   ///     }
   ///
-  R visitStaticGetterSetterPrefix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
-
+  R visitStaticGetterSetterPrefix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a static [method], that is,
   /// closurizing [method], and writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m() => ++o;
   ///     }
   ///
-  R visitStaticMethodSetterPrefix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitStaticMethodSetterPrefix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a top level [field].
   ///
   /// For instance:
   ///
   ///     var field;
   ///     m() => ++field;
   ///
   R visitTopLevelFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a final top level [field].
   ///
   /// For instance:
   ///
   ///     final field;
   ///     m() => ++field;
   ///
   R visitFinalTopLevelFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a top level [getter] and
   /// writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m() => ++o;
   ///
-  R visitTopLevelGetterSetterPrefix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitTopLevelGetterSetterPrefix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a top level [method], that
   /// is, closurizing [method], and writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m() => ++o;
   ///
-  R visitTopLevelMethodSetterPrefix(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitTopLevelMethodSetterPrefix(Send node, FunctionElement method,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var field;
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
   R visitSuperFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from the super field [readField]
   /// and writing to the different super field [writtenField].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       final field;
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperFieldFieldPrefix(
-      Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperFieldFieldPrefix(Send node, FieldElement readField,
+      FieldElement writtenField, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [field] and writing
   /// to a super [setter].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperFieldSetterPrefix(
-      Send node,
-      FieldElement field,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
-
+  R visitSuperFieldSetterPrefix(Send node, FieldElement field,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get field => 0;
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperGetterSetterPrefix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperGetterSetterPrefix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to a super [field].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       get field => 0;
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperGetterFieldPrefix(
-      Send node,
-      FunctionElement getter,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
+      FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
-  R visitSuperMethodSetterPrefix(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperMethodSetterPrefix(Send node, FunctionElement method,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to an unresolved super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
   R visitSuperMethodPrefix(
-      Send node,
-      FunctionElement method,
-      IncDecOperator operator,
-      A arg);
+      Send node, FunctionElement method, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from an unresolved super getter
   /// and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperGetterPrefix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedSuperGetterPrefix(Send node, Element element,
+      MethodElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to an unresolved super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperSetterPrefix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
+      Element element, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a type literal for a class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => ++C;
   ///
   R visitClassTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg);
+      Send node, ConstantExpression constant, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() => ++F;
   ///
   R visitTypedefTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg);
+      Send node, ConstantExpression constant, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m() => ++T;
   ///     }
   ///
   R visitTypeVariableTypeLiteralPrefix(
-      Send node,
-      TypeVariableElement element,
-      IncDecOperator operator,
-      A arg);
+      Send node, TypeVariableElement element, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///
   ///     m() => ++dynamic;
   ///
   R visitDynamicTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg);
+      Send node, ConstantExpression constant, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] of the property on [receiver] whose
   /// getter and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
   ///
   ///     m(receiver) => receiver.foo++;
   ///
   R visitDynamicPropertyPostfix(
-      Send node,
-      Node receiver,
-      Name name,
-      IncDecOperator operator,
-      A arg);
+      Send node, Node receiver, Name name, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] of the property on a possibly null
   /// [receiver] whose getter and setter are defined by [getterSelector] and
   /// [setterSelector], respectively.
   ///
   /// For instance:
   ///
   ///     m(receiver) => receiver?.foo++;
   ///
   R visitIfNotNullDynamicPropertyPostfix(
-      Send node,
-      Node receiver,
-      Name name,
-      IncDecOperator operator,
-      A arg);
+      Send node, Node receiver, Name name, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a [parameter].
   ///
   /// For instance:
   ///
   ///     m(parameter) => parameter++;
   ///
   R visitParameterPostfix(
-      Send node,
-      ParameterElement parameter,
-      IncDecOperator operator,
-      A arg);
+      Send node, ParameterElement parameter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a final [parameter].
   ///
   /// For instance:
   ///
   ///     m(final parameter) => parameter++;
   ///
   R visitFinalParameterPostfix(
-      Send node,
-      ParameterElement parameter,
-      IncDecOperator operator,
-      A arg);
+      Send node, ParameterElement parameter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a local [variable].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       var variable;
   ///       variable++;
   ///     }
   ///
   R visitLocalVariablePostfix(
-      Send node,
-      LocalVariableElement variable,
-      IncDecOperator operator,
-      A arg);
+      Send node, LocalVariableElement variable, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a final local [variable].
   ///
   /// For instance:
   ///
   ///     m() {
   ///       final variable;
   ///       variable++;
   ///     }
   ///
   R visitFinalLocalVariablePostfix(
-      Send node,
-      LocalVariableElement variable,
-      IncDecOperator operator,
-      A arg);
+      Send node, LocalVariableElement variable, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a local [function].
   ///
   /// For instance:
   ///
   ///     m() {
   ///     function() {}
   ///      function++;
   ///     }
   ///
   R visitLocalFunctionPostfix(
-      Send node,
-      LocalFunctionElement function,
-      IncDecOperator operator,
-      A arg);
-
+      Send node, LocalFunctionElement function, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] of the property on `this` whose getter
   /// and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m() => foo++;
   ///     }
   ///
   /// or
   ///
   ///     class C {
   ///       m() => this.foo++;
   ///     }
   ///
   R visitThisPropertyPostfix(
-      Send node,
-      Name name,
-      IncDecOperator operator,
-      A arg);
+      Send node, Name name, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a static [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static var field;
   ///       m() => field++;
   ///     }
   ///
   R visitStaticFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a final static [field].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static final field;
   ///       m() => field++;
   ///     }
   ///
   R visitFinalStaticFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a static [getter] and
   /// writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m() => o++;
   ///     }
   ///
-  R visitStaticGetterSetterPostfix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
-
+  R visitStaticGetterSetterPostfix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a static [method], that
   /// is, closurizing [method], and writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m() => o++;
   ///     }
   ///
-  R visitStaticMethodSetterPostfix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitStaticMethodSetterPostfix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a top level [field].
   ///
   /// For instance:
   ///
   ///     var field;
   ///     m() => field++;
   ///
   R visitTopLevelFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a final top level [field].
   ///
   /// For instance:
   ///
   ///     final field = 42;
   ///     m() => field++;
   ///
   R visitFinalTopLevelFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a top level [getter] and
   /// writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m() => o++;
   ///
-  R visitTopLevelGetterSetterPostfix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitTopLevelGetterSetterPostfix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a top level [method], that
   /// is, closurizing [method], and writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m() => o++;
   ///
-  R visitTopLevelMethodSetterPostfix(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitTopLevelMethodSetterPostfix(Send node, FunctionElement method,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var field;
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
   R visitSuperFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+      Send node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from the super field
   /// [readField] and writing to the different super field [writtenField].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       final field;
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperFieldFieldPostfix(
-      Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperFieldFieldPostfix(Send node, FieldElement readField,
+      FieldElement writtenField, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [field] and
   /// writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperFieldSetterPostfix(
-      Send node,
-      FieldElement field,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
-
+  R visitSuperFieldSetterPostfix(Send node, FieldElement field,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [getter] and
   /// writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get field => 0;
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperGetterSetterPostfix(
-      Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperGetterSetterPostfix(Send node, FunctionElement getter,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [getter] and
   /// writing to a super [field].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       get field => 0;
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperGetterFieldPostfix(
-      Send node,
-      FunctionElement getter,
-      FieldElement field,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
+      FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
-  R visitSuperMethodSetterPostfix(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitSuperMethodSetterPostfix(Send node, FunctionElement method,
+      FunctionElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to an unresolved super.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
   R visitSuperMethodPostfix(
-      Send node,
-      FunctionElement method,
-      IncDecOperator operator,
-      A arg);
+      Send node, FunctionElement method, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from an unresolved super getter
   /// and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperGetterPostfix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedSuperGetterPostfix(Send node, Element element,
+      MethodElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to an unresolved super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperSetterPostfix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
+      Element element, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a type literal for a class
   /// [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => C++;
   ///
   R visitClassTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg);
+      Send node, ConstantExpression constant, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() => F++;
   ///
   R visitTypedefTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg);
+      Send node, ConstantExpression constant, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m() => T++;
   ///     }
   ///
   R visitTypeVariableTypeLiteralPostfix(
-      Send node,
-      TypeVariableElement element,
-      IncDecOperator operator,
-      A arg);
+      Send node, TypeVariableElement element, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///
   ///     m() => dynamic++;
   ///
   R visitDynamicTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg);
+      Send node, ConstantExpression constant, IncDecOperator operator, A arg);
 
   /// Read of the [constant].
   ///
   /// For instance:
   ///
   ///     const c = c;
   ///     m() => c;
   ///
-  R visitConstantGet(
-      Send node,
-      ConstantExpression constant,
-      A arg);
+  R visitConstantGet(Send node, ConstantExpression constant, A arg);
 
   /// Invocation of the [constant] with [arguments].
   ///
   /// For instance:
   ///
   ///     const c = null;
   ///     m() => c(null, 42);
   ///
-  R visitConstantInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitConstantInvoke(Send node, ConstantExpression constant,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// Read of the unresolved [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => unresolved;
   ///     m2() => prefix.unresolved;
   ///     m3() => Unresolved.foo;
   ///     m4() => unresolved.foo;
   ///     m5() => unresolved.Foo.bar;
   ///     m6() => C.unresolved;
   ///     m7() => prefix.C.unresolved;
   ///     m8() => prefix?.unresolved;
   ///     m9() => Unresolved?.foo;
   ///     m10() => unresolved?.foo;
   ///     m11() => unresolved?.Foo?.bar;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R visitUnresolvedGet(
-      Send node,
-      Element element,
-      A arg);
+  R visitUnresolvedGet(Send node, Element element, A arg);
 
   /// Read of the unresolved super [element].
   ///
   /// For instance:
   ///
   ///     class B {}
   ///     class C {
   ///       m() => super.foo;
   ///     }
   ///
-  R visitUnresolvedSuperGet(
-      Send node,
-      Element element,
-      A arg);
+  R visitUnresolvedSuperGet(Send node, Element element, A arg);
 
   /// Assignment of [rhs] to the unresolved [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => unresolved = 42;
   ///     m2() => prefix.unresolved = 42;
   ///     m3() => Unresolved.foo = 42;
   ///     m4() => unresolved.foo = 42;
   ///     m5() => unresolved.Foo.bar = 42;
   ///     m6() => C.unresolved = 42;
   ///     m7() => prefix.C.unresolved = 42;
   ///     m8() => prefix?.unresolved = 42;
   ///     m9() => Unresolved?.foo = 42;
   ///     m10() => unresolved?.foo = 42;
   ///     m11() => unresolved?.Foo?.bar = 42;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R visitUnresolvedSet(
-      Send node,
-      Element element,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSet(Send node, Element element, Node rhs, A arg);
 
   ///  Assignment of [rhs] to the unresolved super [element].
   ///
   /// For instance:
   ///
   ///     class B {}
   ///     class C {
   ///       m() => super.foo = 42;
   ///     }
   ///
-  R visitUnresolvedSuperSet(
-      Send node,
-      Element element,
-      Node rhs,
-      A arg);
+  R visitUnresolvedSuperSet(Send node, Element element, Node rhs, A arg);
 
   /// Invocation of the unresolved [element] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => unresolved(null, 42);
   ///     m2() => prefix.unresolved(null, 42);
   ///     m3() => Unresolved.foo(null, 42);
   ///     m4() => unresolved.foo(null, 42);
   ///     m5() => unresolved.Foo.bar(null, 42);
   ///     m6() => C.unresolved(null, 42);
   ///     m7() => prefix.C.unresolved(null, 42);
   ///     m8() => prefix?.unresolved(null, 42);
   ///     m9() => Unresolved?.foo(null, 42);
   ///     m10() => unresolved?.foo(null, 42);
   ///     m11() => unresolved?.Foo?.bar(null, 42);
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
   R visitUnresolvedInvoke(
-      Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+      Send node, Element element, NodeList arguments, Selector selector, A arg);
 
   /// Invocation of the unresolved super [element] with [arguments].
   ///
   /// For instance:
   ///
   ///     class B {}
   ///     class C extends B {
   ///       m() => super.foo();
   ///     }
   ///
   R visitUnresolvedSuperInvoke(
-      Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+      Send node, Element element, NodeList arguments, Selector selector, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading from the
   /// non-existing static getter and writing to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => C.foo += 42;
   ///
-  R visitUnresolvedStaticGetterCompound(
-      Send node,
-      Element element,
-      MethodElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitUnresolvedStaticGetterCompound(Send node, Element element,
+      MethodElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading from the
   /// non-existing top level getter and writing to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => foo += 42;
   ///
-  R visitUnresolvedTopLevelGetterCompound(
-      Send node,
-      Element element,
-      MethodElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitUnresolvedTopLevelGetterCompound(Send node, Element element,
+      MethodElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading from the static
   /// [getter] and writing to the non-existing static setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => C.foo += 42;
   ///
-  R visitUnresolvedStaticSetterCompound(
-      Send node,
-      MethodElement getter,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitUnresolvedStaticSetterCompound(Send node, MethodElement getter,
+      Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading from the top level
   /// [getter] and writing to the non-existing top level setter.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => foo += 42;
   ///
-  R visitUnresolvedTopLevelSetterCompound(
-      Send node,
-      MethodElement getter,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitUnresolvedTopLevelSetterCompound(Send node, MethodElement getter,
+      Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading the closurized static
   /// [method] and trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
   ///     m1() => C.foo += 42;
   ///
-  R visitStaticMethodCompound(
-      Send node,
-      MethodElement method,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R visitStaticMethodCompound(Send node, MethodElement method,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] where both getter and setter are unresolved.
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => unresolved += 42;
   ///     m2() => prefix.unresolved += 42;
   ///     m3() => Unresolved.foo += 42;
   ///     m4() => unresolved.foo += 42;
   ///     m5() => unresolved.Foo.bar += 42;
   ///     m6() => C.unresolved += 42;
   ///     m7() => prefix.C.unresolved += 42;
   ///     m8() => prefix?.unresolved += 42;
   ///     m9() => Unresolved?.foo += 42;
   ///     m10() => unresolved?.foo += 42;
   ///     m11() => unresolved?.Foo?.bar += 42;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
   R visitUnresolvedCompound(
-      Send node,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+      Send node, Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Prefix operation of [operator] reading from the non-existing static getter
   /// and writing to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => ++C.foo;
   ///
-  R visitUnresolvedStaticGetterPrefix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedStaticGetterPrefix(Send node, Element element,
+      MethodElement setter, IncDecOperator operator, A arg);
 
   /// Prefix operation of [operator] reading from the non-existing top level
   /// getter and writing to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => ++foo;
   ///
-  R visitUnresolvedTopLevelGetterPrefix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedTopLevelGetterPrefix(Send node, Element element,
+      MethodElement setter, IncDecOperator operator, A arg);
 
   /// Prefix operation of [operator] reading from the static [getter] and
   /// writing to the non-existing static setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => ++C.foo;
   ///
-  R visitUnresolvedStaticSetterPrefix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedStaticSetterPrefix(Send node, MethodElement getter,
+      Element element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the top level [getter] and
   /// writing to the non-existing top level setter.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => ++foo;
   ///
-  R visitUnresolvedTopLevelSetterPrefix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedTopLevelSetterPrefix(Send node, MethodElement getter,
+      Element element, IncDecOperator operator, A arg);
 
   /// Prefix operation of [operator] reading the closurized static [method] and
   /// trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
   ///     m1() => ++C.foo;
   ///
   R visitStaticMethodPrefix(
-      Send node,
-      MethodElement method,
-      IncDecOperator operator,
-      A arg);
+      Send node, MethodElement method, IncDecOperator operator, A arg);
 
   /// Prefix operation of [operator] reading the closurized top level [method]
   /// and trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
   ///     m1() => ++C.foo;
   ///
   R visitTopLevelMethodPrefix(
-      Send node,
-      MethodElement method,
-      IncDecOperator operator,
-      A arg);
+      Send node, MethodElement method, IncDecOperator operator, A arg);
 
   /// Prefix operation where both getter and setter are unresolved.
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => ++unresolved;
   ///     m2() => ++prefix.unresolved;
   ///     m3() => ++Unresolved.foo;
   ///     m4() => ++unresolved.foo;
   ///     m5() => ++unresolved.Foo.bar;
   ///     m6() => ++C.unresolved;
   ///     m7() => ++prefix.C.unresolved;
   ///     m8() => ++prefix?.unresolved;
   ///     m9() => ++Unresolved?.foo;
   ///     m10() => ++unresolved?.foo;
   ///     m11() => ++unresolved?.Foo?.bar;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
   R visitUnresolvedPrefix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+      Send node, Element element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the non-existing static
   /// getter and writing to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => C.foo++;
   ///
-  R visitUnresolvedStaticGetterPostfix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedStaticGetterPostfix(Send node, Element element,
+      MethodElement setter, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the non-existing top level
   /// getter and writing to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => foo++;
   ///
-  R visitUnresolvedTopLevelGetterPostfix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedTopLevelGetterPostfix(Send node, Element element,
+      MethodElement setter, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the static [getter] and
   /// writing to the non-existing static setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => C.foo++;
   ///
-  R visitUnresolvedStaticSetterPostfix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedStaticSetterPostfix(Send node, MethodElement getter,
+      Element element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the top level [getter] and
   /// writing to the non-existing top level setter.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => foo++;
   ///
-  R visitUnresolvedTopLevelSetterPostfix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+  R visitUnresolvedTopLevelSetterPostfix(Send node, MethodElement getter,
+      Element element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading the closurized static [method] and
   /// trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
   ///     m1() => C.foo++;
   ///
   R visitStaticMethodPostfix(
-      Send node,
-      MethodElement method,
-      IncDecOperator operator,
-      A arg);
+      Send node, MethodElement method, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading the closurized top level [method]
   /// and trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
   ///     m1() => C.foo++;
   ///
   R visitTopLevelMethodPostfix(
-      Send node,
-      MethodElement method,
-      IncDecOperator operator,
-      A arg);
+      Send node, MethodElement method, IncDecOperator operator, A arg);
 
   /// Postfix operation where both getter and setter are unresolved.
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => unresolved++;
   ///     m2() => prefix.unresolved++;
   ///     m3() => Unresolved.foo++;
   ///     m4() => unresolved.foo++;
   ///     m5() => unresolved.Foo.bar++;
   ///     m6() => C.unresolved++;
   ///     m7() => prefix.C.unresolved++;
   ///     m8() => prefix?.unresolved++;
   ///     m9() => Unresolved?.foo++;
   ///     m10() => unresolved?.foo++;
   ///     m11() => unresolved?.Foo?.bar++;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
   R visitUnresolvedPostfix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      A arg);
+      Send node, Element element, IncDecOperator operator, A arg);
 
   /// Invocation of an undefined unary [operator] on [expression].
   R errorUndefinedUnaryExpression(
-      Send node,
-      Operator operator,
-      Node expression,
-      A arg);
+      Send node, Operator operator, Node expression, A arg);
 
   /// Invocation of an undefined unary [operator] with operands
   /// [left] and [right].
   R errorUndefinedBinaryExpression(
-      Send node,
-      Node left,
-      Operator operator,
-      Node right,
-      A arg);
+      Send node, Node left, Operator operator, Node right, A arg);
 
   /// Const invocation of a [constant] constructor.
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       const C(a, b);
   ///     }
   ///     m() => const C<int>(true, 42);
   ///
   R visitConstConstructorInvoke(
-      NewExpression node,
-      ConstructedConstantExpression constant,
-      A arg);
+      NewExpression node, ConstructedConstantExpression constant, A arg);
 
   /// Const invocation of the `bool.fromEnvironment` constructor.
   ///
   /// For instance:
   ///
   ///     m() => const bool.fromEnvironment('foo', defaultValue: false);
   ///
-  R visitBoolFromEnvironmentConstructorInvoke(
-      NewExpression node,
-      BoolFromEnvironmentConstantExpression constant,
-      A arg);
+  R visitBoolFromEnvironmentConstructorInvoke(NewExpression node,
+      BoolFromEnvironmentConstantExpression constant, A arg);
 
   /// Const invocation of the `int.fromEnvironment` constructor.
   ///
   /// For instance:
   ///
   ///     m() => const int.fromEnvironment('foo', defaultValue: 42);
   ///
   R visitIntFromEnvironmentConstructorInvoke(
-      NewExpression node,
-      IntFromEnvironmentConstantExpression constant,
-      A arg);
+      NewExpression node, IntFromEnvironmentConstantExpression constant, A arg);
 
   /// Const invocation of the `String.fromEnvironment` constructor.
   ///
   /// For instance:
   ///
   ///     m() => const String.fromEnvironment('foo', defaultValue: 'bar');
   ///
-  R visitStringFromEnvironmentConstructorInvoke(
-      NewExpression node,
-      StringFromEnvironmentConstantExpression constant,
-      A arg);
+  R visitStringFromEnvironmentConstructorInvoke(NewExpression node,
+      StringFromEnvironmentConstantExpression constant, A arg);
 
   /// Invocation of a generative [constructor] on [type] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       C(a, b);
   ///     }
   ///     m() => new C<int>(true, 42);
   ///
@@ skipping 80 matching lines @@
   ///
   ///     class C<T> {
   ///       C();
   ///     }
   ///     m() => new C<int>.unresolved(true, 42);
   ///
   /// where [type] is `C<int>`.
   ///
   // TODO(johnniwinther): Change [type] to [InterfaceType] when is it not
   // `dynamic`.
-  R visitUnresolvedConstructorInvoke(
-      NewExpression node,
-      Element constructor,
-      DartType type,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+  R visitUnresolvedConstructorInvoke(NewExpression node, Element constructor,
+      DartType type, NodeList arguments, Selector selector, A arg);
 
   /// Invocation of a constructor on an unresolved [type] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() => new Unresolved(true, 42);
   ///
   /// where [type] is the malformed type `Unresolved`.
   ///
   // TODO(johnniwinther): Change [type] to [MalformedType] when is it not
   // `dynamic`.
-  R visitUnresolvedClassConstructorInvoke(
-      NewExpression node,
-      Element element,
-      DartType type,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+  R visitUnresolvedClassConstructorInvoke(NewExpression node, Element element,
+      DartType type, NodeList arguments, Selector selector, A arg);
 
   /// Constant invocation of a non-constant constructor.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       C(a, b);
   ///     }
   ///     m() => const C(true, 42);
   ///
-  R errorNonConstantConstructorInvoke(
-      NewExpression node,
-      Element element,
-      DartType type,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R errorNonConstantConstructorInvoke(NewExpression node, Element element,
+      DartType type, NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of a constructor on an abstract [type] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() => new Unresolved(true, 42);
   ///
   /// where [type] is the malformed type `Unresolved`.
   ///
   R visitAbstractClassConstructorInvoke(
@@ skipping 43 matching lines @@
       A arg);
 
   /// Read access of an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m() => p;
   ///
-  R errorInvalidGet(
-      Send node,
-      ErroneousElement error,
-      A arg);
-
+  R errorInvalidGet(Send node, ErroneousElement error, A arg);
 
   /// Invocation of an invalid expression with [arguments].
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m() => p(null, 42);
   ///
-  R errorInvalidInvoke(
-      Send node,
-      ErroneousElement error,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+  R errorInvalidInvoke(Send node, ErroneousElement error, NodeList arguments,
+      Selector selector, A arg);
 
   /// Assignment of [rhs] to an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m() { p = 42; }
   ///
-  R errorInvalidSet(
-      Send node,
-      ErroneousElement error,
-      Node rhs,
-      A arg);
+  R errorInvalidSet(Send node, ErroneousElement error, Node rhs, A arg);
 
   /// Prefix operation on an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m() => ++p;
   ///
   R errorInvalidPrefix(
-      Send node,
-      ErroneousElement error,
-      IncDecOperator operator,
-      A arg);
+      Send node, ErroneousElement error, IncDecOperator operator, A arg);
 
   /// Postfix operation on an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m() => p--;
   ///
   R errorInvalidPostfix(
-      Send node,
-      ErroneousElement error,
-      IncDecOperator operator,
-      A arg);
+      Send node, ErroneousElement error, IncDecOperator operator, A arg);
 
   /// Compound assignment of [operator] with [rhs] on an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m() => p += 42;
   ///
-  R errorInvalidCompound(
-      Send node,
-      ErroneousElement error,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R errorInvalidCompound(Send node, ErroneousElement error,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on the index operators
   /// of an invalid expression.
   ///
   /// For instance:
   ///
   ///     import 'foo.dart' as p;
   ///
   ///     m(index, rhs) => p[index] ??= rhs;
   ///
   R errorInvalidIndexSetIfNull(
-      SendSet node,
-      ErroneousElement error,
-      Node index,
-      Node rhs,
-      A arg);
+      SendSet node, ErroneousElement error, Node index, Node rhs, A arg);
 
   /// Unary operation with [operator] on an invalid expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => ~super;
   ///     }
   ///
   R errorInvalidUnary(
-      Send node,
-      UnaryOperator operator,
-      ErroneousElement error,
-      A arg);
+      Send node, UnaryOperator operator, ErroneousElement error, A arg);
 
   /// Equals operation on an invalid left expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => super == null;
   ///     }
   ///
-  R errorInvalidEquals(
-      Send node,
-      ErroneousElement error,
-      Node right,
-      A arg);
+  R errorInvalidEquals(Send node, ErroneousElement error, Node right, A arg);
 
   /// Not equals operation on an invalid left expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => super != null;
   ///     }
   ///
-  R errorInvalidNotEquals(
-      Send node,
-      ErroneousElement error,
-      Node right,
-      A arg);
+  R errorInvalidNotEquals(Send node, ErroneousElement error, Node right, A arg);
 
   /// Binary operation with [operator] on an invalid left expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => super + 0;
   ///     }
   ///
-  R errorInvalidBinary(
-      Send node,
-      ErroneousElement error,
-      BinaryOperator operator,
-      Node right,
-      A arg);
+  R errorInvalidBinary(Send node, ErroneousElement error,
+      BinaryOperator operator, Node right, A arg);
 
   /// Index operation on an invalid expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => super[0];
   ///     }
   ///
-  R errorInvalidIndex(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      A arg);
+  R errorInvalidIndex(Send node, ErroneousElement error, Node index, A arg);
 
   /// Index set operation on an invalid expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => super[0] = 42;
   ///     }
   ///
   R errorInvalidIndexSet(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      Node rhs,
-      A arg);
+      Send node, ErroneousElement error, Node index, Node rhs, A arg);
 
   /// Compound index set operation on an invalid expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => super[0] += 42;
   ///     }
   ///
-  R errorInvalidCompoundIndexSet(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
+  R errorInvalidCompoundIndexSet(Send node, ErroneousElement error, Node index,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Prefix index operation on an invalid expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => --super[0];
   ///     }
   ///
-  R errorInvalidIndexPrefix(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+  R errorInvalidIndexPrefix(Send node, ErroneousElement error, Node index,
+      IncDecOperator operator, A arg);
 
   /// Postfix index operation on an invalid expression.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m() => super[0]++;
   ///     }
   ///
-  R errorInvalidIndexPostfix(
-      Send node,
-      ErroneousElement error,
-      Node index,
-      IncDecOperator operator,
-      A arg);
+  R errorInvalidIndexPostfix(Send node, ErroneousElement error, Node index,
+      IncDecOperator operator, A arg);
 
   /// Access of library through a deferred [prefix].
   ///
   /// For instance:
   ///
   ///     import 'lib.dart' deferred as prefix;
   ///
   ///     m() => prefix.foo;
   ///
   /// This visit method is special in that it is called as a pre-step to calling
   /// the visit method for the actual access. Therefore this method cannot
   /// return a result to its caller.
-  void previsitDeferredAccess(
-      Send node,
-      PrefixElement prefix,
-      A arg);
+  void previsitDeferredAccess(Send node, PrefixElement prefix, A arg);
 }
 
 abstract class SemanticDeclarationVisitor<R, A> {
   R apply(Node node, A arg);
 
   /// Apply this visitor to the [parameters].
   applyParameters(NodeList parameters, A arg);
 
   /// Apply this visitor to the initializers of [constructor].
   applyInitializers(FunctionExpression constructor, A arg);
 
   /// A declaration of a top level [getter].
   ///
   /// For instance:
   ///
   ///     get m => 42;
   ///
   R visitTopLevelGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
-      A arg);
+      FunctionExpression node, MethodElement getter, Node body, A arg);
 
   /// A declaration of a top level [setter].
   ///
   /// For instance:
   ///
   ///     set m(a) {}
   ///
-  R visitTopLevelSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitTopLevelSetterDeclaration(FunctionExpression node,
+      MethodElement setter, NodeList parameters, Node body, A arg);
 
   /// A declaration of a top level [function].
   ///
   /// For instance:
   ///
   ///     m(a) {}
   ///
-  R visitTopLevelFunctionDeclaration(
-      FunctionExpression node,
-      MethodElement function,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitTopLevelFunctionDeclaration(FunctionExpression node,
+      MethodElement function, NodeList parameters, Node body, A arg);
 
   /// A declaration of a static [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get m => 42;
   ///     }
   ///
   R visitStaticGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
-      A arg);
+      FunctionExpression node, MethodElement getter, Node body, A arg);
 
   /// A declaration of a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set m(a) {}
   ///     }
   ///
-  R visitStaticSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitStaticSetterDeclaration(FunctionExpression node, MethodElement setter,
+      NodeList parameters, Node body, A arg);
 
   /// A declaration of a static [function].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m(a) {}
   ///     }
   ///
-  R visitStaticFunctionDeclaration(
-      FunctionExpression node,
-      MethodElement function,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitStaticFunctionDeclaration(FunctionExpression node,
+      MethodElement function, NodeList parameters, Node body, A arg);
 
   /// A declaration of an abstract instance [getter].
   ///
   /// For instance:
   ///
   ///     abstract class C {
   ///       get m;
   ///     }
   ///
   R visitAbstractGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      A arg);
+      FunctionExpression node, MethodElement getter, A arg);
 
   /// A declaration of an abstract instance [setter].
   ///
   /// For instance:
   ///
   ///     abstract class C {
   ///       set m(a);
   ///     }
   ///
-  R visitAbstractSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      A arg);
+  R visitAbstractSetterDeclaration(FunctionExpression node,
+      MethodElement setter, NodeList parameters, A arg);
 
   /// A declaration of an abstract instance [method].
   ///
   /// For instance:
   ///
   ///     abstract class C {
   ///       m(a);
   ///     }
   ///
-  R visitAbstractMethodDeclaration(
-      FunctionExpression node,
-      MethodElement method,
-      NodeList parameters,
-      A arg);
+  R visitAbstractMethodDeclaration(FunctionExpression node,
+      MethodElement method, NodeList parameters, A arg);
 
   /// A declaration of an instance [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get m => 42;
   ///     }
   ///
   R visitInstanceGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
-      A arg);
+      FunctionExpression node, MethodElement getter, Node body, A arg);
 
   /// A declaration of an instance [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set m(a) {}
   ///     }
   ///
-  R visitInstanceSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitInstanceSetterDeclaration(FunctionExpression node,
+      MethodElement setter, NodeList parameters, Node body, A arg);
 
   /// A declaration of an instance [method].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m(a) {}
   ///     }
   ///
-  R visitInstanceMethodDeclaration(
-      FunctionExpression node,
-      MethodElement method,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitInstanceMethodDeclaration(FunctionExpression node,
+      MethodElement method, NodeList parameters, Node body, A arg);
 
   /// A declaration of a local [function].
   ///
   /// For instance `local` in:
   ///
   ///     m() {
   ///       local(a) {}
   ///     }
   ///
-  R visitLocalFunctionDeclaration(
-      FunctionExpression node,
-      LocalFunctionElement function,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitLocalFunctionDeclaration(FunctionExpression node,
+      LocalFunctionElement function, NodeList parameters, Node body, A arg);
 
   /// A declaration of a [closure].
   ///
   /// For instance `(a) {}` in:
   ///
   ///     m() {
   ///       var closure = (a) {};
   ///     }
   ///
-  R visitClosureDeclaration(
-      FunctionExpression node,
-      LocalFunctionElement closure,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitClosureDeclaration(FunctionExpression node,
+      LocalFunctionElement closure, NodeList parameters, Node body, A arg);
 
   /// A declaration of the [index]th [parameter] in a constructor, setter,
   /// method or function.
   ///
   /// For instance `a` in:
   ///
   ///     m(a) {}
   ///
-  R visitParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      int index,
-      A arg);
+  R visitParameterDeclaration(VariableDefinitions node, Node definition,
+      ParameterElement parameter, int index, A arg);
 
   /// A declaration of the [index]th optional [parameter] in a constructor,
   /// method or function with the explicit [defaultValue]. If no default value
   /// is declared, [defaultValue] is `null`.
   ///
   /// For instance `a` in:
   ///
   ///     m([a = 42]) {}
   ///
   R visitOptionalParameterDeclaration(
       VariableDefinitions node,
       Node definition,
       ParameterElement parameter,
       ConstantExpression defaultValue,
       int index,
       A arg);
 
   /// A declaration of a named [parameter] in a constructor, method or function
   /// with the explicit [defaultValue]. If no default value is declared,
   /// [defaultValue] is `null`.
   ///
   /// For instance `a` in:
   ///
   ///     m({a: 42}) {}
   ///
-  R visitNamedParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      ConstantExpression defaultValue,
-      A arg);
+  R visitNamedParameterDeclaration(VariableDefinitions node, Node definition,
+      ParameterElement parameter, ConstantExpression defaultValue, A arg);
 
   /// A declaration of the [index]th [parameter] as an initializing formal in a
   /// constructor.
   ///
   /// For instance `a` in:
   ///
   ///     class C {
   ///       var a;
   ///       C(this.a);
   ///     }
   ///
-  R visitInitializingFormalDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      InitializingFormalElement parameter,
-      int index,
-      A arg);
+  R visitInitializingFormalDeclaration(VariableDefinitions node,
+      Node definition, InitializingFormalElement parameter, int index, A arg);
 
   /// A declaration of the [index]th optional [parameter] as an initializing
   /// formal in a constructor with the explicit [defaultValue]. If no default
   /// value is declared, [defaultValue] is `null`.
   ///
   /// For instance `a` in:
   ///
   ///     class C {
   ///       var a;
   ///       C([this.a = 42]);
@@ skipping 27 matching lines @@
 
   /// A declaration of a local [variable] with the explicit [initializer]. If
   /// no initializer is declared, [initializer] is `null`.
   ///
   /// For instance `a` in:
   ///
   ///     m() {
   ///       var a = 42;
   ///     }
   ///
-  R visitLocalVariableDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      LocalVariableElement variable,
-      Node initializer,
-      A arg);
+  R visitLocalVariableDeclaration(VariableDefinitions node, Node definition,
+      LocalVariableElement variable, Node initializer, A arg);
 
   /// A declaration of a local constant [variable] initialized to [constant].
   ///
   /// For instance `a` in:
   ///
   ///     m() {
   ///       const a = 42;
   ///     }
   ///
-  R visitLocalConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      LocalVariableElement variable,
-      ConstantExpression constant,
-      A arg);
+  R visitLocalConstantDeclaration(VariableDefinitions node, Node definition,
+      LocalVariableElement variable, ConstantExpression constant, A arg);
 
   /// A declaration of a top level [field] with the explicit [initializer].
   /// If no initializer is declared, [initializer] is `null`.
   ///
   /// For instance `a` in:
   ///
   ///     var a = 42;
   ///
-  R visitTopLevelFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
-      A arg);
+  R visitTopLevelFieldDeclaration(VariableDefinitions node, Node definition,
+      FieldElement field, Node initializer, A arg);
 
   /// A declaration of a top level constant [field] initialized to [constant].
   ///
   /// For instance `a` in:
   ///
   ///     const a = 42;
   ///
-  R visitTopLevelConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      ConstantExpression constant,
-      A arg);
+  R visitTopLevelConstantDeclaration(VariableDefinitions node, Node definition,
+      FieldElement field, ConstantExpression constant, A arg);
 
   /// A declaration of a static [field] with the explicit [initializer].
   /// If no initializer is declared, [initializer] is `null`.
   ///
   /// For instance `a` in:
   ///
   ///     class C {
   ///       static var a = 42;
   ///     }
   ///
-  R visitStaticFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
-      A arg);
+  R visitStaticFieldDeclaration(VariableDefinitions node, Node definition,
+      FieldElement field, Node initializer, A arg);
 
   /// A declaration of a static constant [field] initialized to [constant].
   ///
   /// For instance `a` in:
   ///
   ///     class C {
   ///       static const a = 42;
   ///     }
   ///
-  R visitStaticConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      ConstantExpression constant,
-      A arg);
+  R visitStaticConstantDeclaration(VariableDefinitions node, Node definition,
+      FieldElement field, ConstantExpression constant, A arg);
 
   /// A declaration of an instance [field] with the explicit [initializer].
   /// If no initializer is declared, [initializer] is `null`.
   ///
   /// For instance `a` in:
   ///
   ///     class C {
   ///       var a = 42;
   ///     }
   ///
-  R visitInstanceFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
-      A arg);
+  R visitInstanceFieldDeclaration(VariableDefinitions node, Node definition,
+      FieldElement field, Node initializer, A arg);
 
   /// A declaration of a generative [constructor] with the explicit constructor
   /// [initializers].
   ///
   /// For instance `C` in:
   ///
   ///     class C {
   ///       var a;
   ///       C(a) : this.a = a, super();
   ///     }
@@ skipping 28 matching lines @@
       A arg);
 
   /// A declaration of a factory [constructor].
   ///
   /// For instance `C` in:
   ///
   ///     class C {
   ///       factory C(a) => null;
   ///     }
   ///
-  R visitFactoryConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      Node body,
-      A arg);
+  R visitFactoryConstructorDeclaration(FunctionExpression node,
+      ConstructorElement constructor, NodeList parameters, Node body, A arg);
 
   /// A declaration of a redirecting factory [constructor]. The immediate
   /// redirection target and its type is provided in [redirectionTarget] and
   /// [redirectionType], respectively.
   ///
   /// For instance:
   ///
   ///    class C<T> {
   ///      factory C() = C<int>.a;
   ///      factory C.a() = C<C<T>>.b;
@@ skipping 14 matching lines @@
   /// initializers.
   ///
   /// For instance `this.a = 42` in:
   ///
   ///     class C {
   ///       var a;
   ///       C() : this.a = 42;
   ///     }
   ///
   R visitFieldInitializer(
-      SendSet node,
-      FieldElement field,
-      Node initializer,
-      A arg);
+      SendSet node, FieldElement field, Node initializer, A arg);
 
   /// An initializer of an unresolved field with [initializer] as found in
   /// generative constructor initializers.
   ///
   /// For instance `this.a = 42` in:
   ///
   ///     class C {
   ///       C() : this.a = 42;
   ///     }
   ///
   R errorUnresolvedFieldInitializer(
-      SendSet node,
-      Element element,
-      Node initializer,
-      A arg);
+      SendSet node, Element element, Node initializer, A arg);
 
   /// An super constructor invocation of [superConstructor] with [arguments] as
   /// found in generative constructor initializers.
   ///
   /// For instance `super(42)` in:
   ///
   ///     class B {
   ///       B(a);
   ///     }
   ///     class C extends B {
@@ skipping 13 matching lines @@
   ///
   /// For instance `super(42)` in:
   ///
   ///     class B {
   ///       B();
   ///     }
   ///     class C extends B {
   ///       C(); // Implicit super call of B().
   ///     }
   ///
-  R visitImplicitSuperConstructorInvoke(
-      FunctionExpression node,
-      ConstructorElement superConstructor,
-      InterfaceType type,
-      A arg);
+  R visitImplicitSuperConstructorInvoke(FunctionExpression node,
+      ConstructorElement superConstructor, InterfaceType type, A arg);
 
   /// An super constructor invocation of an unresolved with [arguments] as
   /// found in generative constructor initializers.
   ///
   /// For instance `super(42)` in:
   ///
   ///     class B {
   ///       B(a);
   ///     }
   ///     class C extends B {
   ///       C() : super.unresolved(42);
   ///     }
   ///
   R errorUnresolvedSuperConstructorInvoke(
-      Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+      Send node, Element element, NodeList arguments, Selector selector, A arg);
 
   /// An this constructor invocation of [thisConstructor] with [arguments] as
   /// found in a redirecting generative constructors initializer.
   ///
   /// For instance `this._(42)` in:
   ///
   ///     class C {
   ///       C() : this._(42);
   ///       C._(a);
   ///     }
   ///
-  R visitThisConstructorInvoke(
-      Send node,
-      ConstructorElement thisConstructor,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+  R visitThisConstructorInvoke(Send node, ConstructorElement thisConstructor,
+      NodeList arguments, CallStructure callStructure, A arg);
 
   /// An this constructor invocation of an unresolved constructor with
   /// [arguments] as found in a redirecting generative constructors initializer.
   ///
   /// For instance `this._(42)` in:
   ///
   ///     class C {
   ///       C() : this._(42);
   ///     }
   ///
   R errorUnresolvedThisConstructorInvoke(
-      Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
-      A arg);
+      Send node, Element element, NodeList arguments, Selector selector, A arg);
 }