Version 1.25.0-dev.7.0

Merge commit 'fa859c507fb6994b7a2b6b08001dfafaf2d89912' into dev
diff --git a/.clang-format b/.clang-format
index 96325ae..f3288a6 100644
--- a/.clang-format
+++ b/.clang-format
@@ -2,9 +2,6 @@
 # http://clang.llvm.org/docs/ClangFormatStyleOptions.html
 BasedOnStyle: Chromium
 
-# Keep up to 2 blank lines. More blank lines are removed.
-MaxEmptyLinesToKeep: 2
-
 # clang-format doesn't seem to do a good job of this for longer comments.
 ReflowComments: 'false'
 
diff --git a/.travis.yml b/.travis.yml
index efe6ae5..b92a121 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -88,6 +88,7 @@
   allow_failures:
     - env: ANALYZER=master CXX=clang++
     - env: ANALYZER=master DDC_BROWSERS=ChromeCanaryTravis
+    - env: ANALYZER=master DDC_BROWSERS=Firefox
 notifications:
   email:
     recipients:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 782fa28..39b5c66 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,6 +27,10 @@
     the system level timeout duration, a timeout may occur sooner than specified
     in 'timeout'.
 
+* `dart:core`
+  * The `Uri` class now correctly handles paths while running on Node.js on
+    Windows.
+
 ### Dart VM
 * Support for MIPS has been remvoed.
 
diff --git a/docs/language/dartLangSpec.tex b/docs/language/dartLangSpec.tex
index 347f5ec..1079288 100644
--- a/docs/language/dartLangSpec.tex
+++ b/docs/language/dartLangSpec.tex
@@ -628,7 +628,7 @@
 of the function that has this body.
 It is a static warning if $T$ is not \VOID{} and either
 the function is synchronous and the static type of $R$ is not assignable to $T$,
-or the function is asynchronous and \code{Future<$flatten${$R$}>}
+or the function is asynchronous and \code{Future<$flatten$($R$)>}
 is not assignable to $T$.
 
 \end{itemize}
@@ -3215,7 +3215,8 @@
 }
 
 \LMHash{}
-The static type of a map literal of the form  \CONST{}$ <K, V>\{k_1:e_1\ldots k_n :e_n\}$ or the form $<K, V>\{k_1:e_1\ldots k_n :e_n\}$ is $Map<K, V>$. The static type a map literal of the form  \CONST{}$\{k_1:e_1\ldots k_n :e_n\}$ or the form $\{k_1:e_1\ldots k_n :e_n\}$ is $Map<\DYNAMIC{},  \DYNAMIC{}>$.
+The static type of a map literal of the form \CONST{}$ <K, V>\{k_1:e_1\ldots k_n :e_n\}$ or the form $<K, V>\{k_1:e_1\ldots k_n :e_n\}$ is $Map<K, V>$.
+The static type of a map literal of the form \CONST{}$\{k_1:e_1\ldots k_n :e_n\}$ or the form $\{k_1:e_1\ldots k_n :e_n\}$ is $Map<\DYNAMIC{}, \DYNAMIC{}>$.
 
 
 \subsection{Throw}
@@ -3242,7 +3243,7 @@
 The expression $e$ is evaluated to a value $v$ (\ref{evaluation}).
 
 \commentary{
-There is no requirement that the expression $e$ evaluate to any special kind of object.
+There is no requirement that the expression $e$ must evaluate to any special kind of object.
 }
 
 \LMHash{}
@@ -3314,7 +3315,7 @@
 
 
 \rationale{
-We collapse multiple layers of futures into one. If $e$ evaluates to a future $f$, the future will not invoke its \code{then()} callback until f completes to a non-future value, and so the result of an await is never a future, and the result of an async function will never have type \code{Future$<X>$} where $X$ itself is an invocation of \code{Future}.
+We collapse multiple layers of futures into one. If $e$ evaluates to a future $f$, the future will not invoke its \code{then()} callback until f completes to a non-future value, and so the result of an await is never a future, and the result of an \ASYNC{} function will never have type \code{Future$<X>$} where $X$ itself is an invocation of \code{Future}.
 
 The  exception to that would be a type $X$ that extended or implemented \code{Future}. In that case, only one unwrapping takes place. As an example of why this is done, consider
 
@@ -3730,7 +3731,7 @@
 
 \LMHash{}
 Executing a body of the form \code{=> $e$} is equivalent to executing a body of the form \code{\{ return $e$; \}}.
-Execution a body of the form \code{async => $e$} is equivalent to executing a body of the form \code{async \{ return $e$; \}}.
+Execution a body of the form \code{\ASYNC{} => $e$} is equivalent to executing a body of the form \code{\ASYNC{} \{ return $e$; \}}.
 
 \LMHash{}
 If $f$ is synchronous and is not a generator (\ref{functions}) then execution of the body of $f$ begins immediately.
@@ -4112,7 +4113,7 @@
 \item
 $T$ or a superinterface of $T$ is annotated with an annotation denoting a constant identical to the constant \code{@proxy} defined in \code{dart:core}.  Or
 \item  $T$ is \code{Type}, $e$ is a constant type literal and the class corresponding to $e$ has a static getter named $m$.
-\item $T$ is \code{Function} and $m$ is \CALL. \rationale {The type \code{Function} is treated as if it has a \code{call} method for any possible signature of \CALL. The expectation is that any concrete subclass of \code{Function} will implement \CALL. Note that a warning will be issue if this is not the case. Furthermore, any use of \CALL{} on a subclass of \code{Function} that fails to implement \CALL{} will also provoke a warning, as this exemption is limited to type \code{Function}, and does not apply to its subtypes.
+\item $T$ is \code{Function} and $m$ is \CALL. \rationale {The type \code{Function} is treated as if it has a \code{call} method for any possible signature of \CALL. The expectation is that any concrete subclass of \code{Function} will implement \CALL. Note that a warning will be issued if this is not the case. Furthermore, any use of \CALL{} on a subclass of \code{Function} that fails to implement \CALL{} will also provoke a warning, as this exemption is limited to type \code{Function}, and does not apply to its subtypes.
 }
 \end{itemize}
 
@@ -4783,7 +4784,7 @@
  \label{ifNull}
 
  \LMHash{}
- An {\em if-null expression}evaluates an expression and if the result is \NULL, evaluates another.
+ An {\em if-null expression} evaluates an expression and if the result is \NULL, evaluates another.
 
 \begin{grammar}
 {\bf ifNullExpression:}
@@ -6506,7 +6507,8 @@
 }
 
 \LMHash{}
-Let $f$ be the function immediately enclosing a return statement of the form \RETURN{}; It is a static warning  $f$ is neither a generator nor a generative constructor and either:
+Let $f$ be the function immediately enclosing a return statement of the form \RETURN{};.
+It is a static warning if $f$ is neither a generator nor a generative constructor and either:
 \begin{itemize}
 \item  $f$ is synchronous and the return type of $f$ may not be assigned to \VOID{} (\ref{typeVoid}) or,
 \item  $f$ is asynchronous and the return type of $f$ may not be assigned to \code{Future<Null>}.
@@ -7449,7 +7451,7 @@
 \end{dartCode}
 
 \commentary{
-Since $i$ is not a type, a static warning will be issue at the declaration of $j$. However, the program can be executed without incident in production mode because he undeclared type $i$ is treated as \DYNAMIC{}. However, in checked mode, the implicit subtype test at the assignment will trigger an error at runtime.
+Since $i$ is not a type, a static warning will be issue at the declaration of $j$. However, the program can be executed without incident in production mode because the undeclared type $i$ is treated as \DYNAMIC{}. However, in checked mode, the implicit subtype test at the assignment will trigger an error at runtime.
 }
 
 
@@ -7836,7 +7838,7 @@
 A {\em parameterized type} is an invocation of a generic type declaration.
 
 \LMHash{}
-Let $T$ be a parameterized type  $G<S_1,  \ldots, S_n>$. If $G$ is not a generic type, the type arguments $S_i$, $1 \le i \le n$ are discarded. If $G$ has $m \ne n$ type parameters, $T$ is treated as as a parameterized type with $m$ arguments, all of which are \DYNAMIC{}.
+Let $T$ be a parameterized type  $G<S_1,  \ldots, S_n>$. If $G$ is not a generic type, the type arguments $S_i$, $1 \le i \le n$ are discarded. If $G$ has $m \ne n$ type parameters, $T$ is treated as a parameterized type with $m$ arguments, all of which are \DYNAMIC{}.
 
 \commentary{In short, any arity mismatch results in all type arguments being dropped, and replaced with the correct number of type arguments, all set to \DYNAMIC{}. Of course, a static warning will be issued.
 }
diff --git a/docs/language/informal/generic-function-type-alias.md b/docs/language/informal/generic-function-type-alias.md
new file mode 100644
index 0000000..9dd6681
--- /dev/null
+++ b/docs/language/informal/generic-function-type-alias.md
@@ -0,0 +1,368 @@
+# Feature: Generic Function Type Alias
+
+**Status**: Implemented.
+
+**This document** is an informal specification of a feature supporting the
+definition of function type aliases using a more expressive syntax than the
+one available today, such that it also covers generic function types. The
+feature also introduces syntax for specifying function types directly, such
+that they can be used in type annotations etc. without going via a
+`typedef`.
+
+In this document, a **generic function type** denotes the type of a function
+whose declaration includes a list of formal type parameters. It could also
+have been called a *generic-function type*, because it is "the type of a
+generic function". Note that this differs from "a type parameterized name
+*F* whose instances *F<T>* denote function types", which might perhaps be
+called a *generic function-type*. In this document the latter is designated
+as a **parameterized typedef**. Examples clarifying this distinction are
+given below.
+
+**This feature** introduces a new syntactic form of typedef declaration
+which includes an identifier and a type, connecting the two with an equals
+sign, `=`. The effect of such a declaration is that the name is declared to
+be an alias for the type. Type parameterization may occur in the declared
+type (declaring a generic function type) as well as on the declared name
+(declaring a parameterized typedef). This feature also introduces syntax for
+specifying function types directly, using a syntax which is similar to the
+header of a function declaration.
+
+The **motivation** for adding this feature is that it allows developers to
+specify generic function types at all, and to specify function types
+everywhere a type is expected. That includes type annotations, return types,
+actual type arguments, and formal type parameter bounds. Currently there is
+no way to specify a function type directly in these situations. Even in the
+case where a function type *can* be specified (such as a type annotation for
+a formal parameter) it may be useful for readability to declare a name as an
+alias of a complex type, and use that name instead of the type.
+
+## Examples
+
+Using the new syntax, a function type alias may be declared as follows:
+
+```dart
+typedef F = List<T> Function<T>(T);
+```
+
+This declares `F` to be the type of a function that accepts one type
+parameter `T` and one value parameter of type `T` whose name is
+unspecified, and returns a result of type `List<T>`. It is possible to use
+the new syntax to declare function types that we can already declare using
+the existing typedef declaration. For instance, `G` and `H` both declare
+the same type:
+
+```dart
+typedef G = List<int> Function(int); // New form.
+typedef List<int> H(int i); // Old form.
+```
+
+Note that the name of the parameter is required in the old form, but the
+type may be omitted. In contrast, the type is required in the new form, but
+the name may be omitted.
+
+The reason for having two ways to express the same thing is that the new
+form seamlessly covers non-generic functions as well as generic ones, and
+developers might prefer to use the new form everywhere, for improved
+readability.
+
+There is a difference between declaring a generic function type and
+declaring a typedef which takes a type argument. The former is a
+declaration of a single type which describes a certain class of runtime
+entities: Functions that are capable of accepting some type arguments as
+well as some value arguments, both at runtime. The latter is a compile-time 
+mapping from types to types: It accepts a type argument at compile time and
+returns a type, which may be used, say, as a type annotation. We use the
+phrase *parameterized typedef* to refer to the latter. Dart has had support
+for parameterized typedefs for a while, and the new syntax supports
+parameterized typedefs as well. Here is an example of a parameterized
+typedef, and a usage thereof:
+
+```dart
+typedef I<T> = List<T> Function(T); // New form.
+typedef List<T> J<T>(T t); // Old form.
+I<int> myFunction(J<int> f) => f;
+```
+
+In this example,
+we have declared two equivalent parameterized typedefs `I` and `J`,
+and we have used an instantiation of each of them in the type annotations
+on `myFunction`. Note that the type of `myFunction` does not include *any*
+generic types, it is just a function that accepts an argument and returns a
+result, both of which have a non-generic function type that we have
+obtained by instantiating a parameterized typedef. The argument type might
+as well have been declared using the traditional function signature syntax,
+and the return type (and the argument type, by the way) might as well have
+been declared using a regular, non-parameterized typedef:
+
+```dart
+typedef List<int> K(int i); // Old form, non-generic.
+K myFunction2(List<int> f(int i)) => f; // Same as myFunction.
+```
+
+The new syntax allows for using the two kinds of type parameters together:
+
+```dart
+typedef L<T> = List<T> Function<S>(S, {T Function(int, S) factory});
+```
+
+This declares `L` to be a parameterized typedef; when instantiating `L`
+with an actual type argument as in `L<String>`, it becomes the type of a
+generic function that accepts a type argument `S` and two value arguments:
+one required positional argument of type `S`, and one named optional
+argument with name `factory` and type `String Function(int, S)`; finally,
+it returns a value of type `List<String>`.
+
+## Syntax
+
+The new form of `typedef` declaration uses the following syntax (there are
+no deletions from the grammar; addition of a new rule or a new alternative
+in a rule is marked with NEW and modified rules are marked CHANGED):
+
+```
+typeAlias:
+  metadata 'typedef' typeAliasBody |
+  metadata 'typedef' identifier typeParameters? '=' functionType ';' // NEW
+functionType: // NEW
+  returnType? 'Function' typeParameters? parameterTypeList
+parameterTypeList: // NEW
+  '(' ')' |
+  '(' normalParameterTypes ','? ')' |
+  '(' normalParameterTypes ',' optionalParameterTypes ')' |
+  '(' optionalParameterTypes ')'
+normalParameterTypes: // NEW
+  normalParameterType (',' normalParameterType)*
+normalParameterType: // NEW
+  type | typedIdentifier
+optionalParameterTypes: // NEW
+  optionalPositionalParameterTypes | namedParameterTypes
+optionalPositionalParameterTypes: // NEW
+  '[' normalParameterTypes ','? ']'
+namedParameterTypes: // NEW
+  '{' typedIdentifier (',' typedIdentifier)* ','? '}'
+typedIdentifier: // NEW
+  type identifier
+type: // CHANGED
+  typeWithoutFunction |
+  functionType
+typeWithoutFunction: // NEW
+  typeName typeArguments?
+typeWithoutFunctionList: // NEW
+  typeWithoutFunction (',' typeWithoutFunction)*
+mixins: // CHANGED
+  'with' typeWithoutFunctionList
+interfaces: // CHANGED
+  'implements' typeWithoutFunctionList
+superclass: // CHANGED
+  'extends' typeWithoutFunction
+mixinApplication: // CHANGED
+  typeWithoutFunction mixins interfaces?
+newExpression: // CHANGED
+  'new' typeWithoutFunction ('.' identifier)? arguments
+constObjectExpression: // CHANGED
+  'const' typeWithoutFunction ('.' identifier)? arguments
+redirectingFactoryConstructorSignature: // CHANGED
+  'const'? 'factory' identifier ('.' identifier)?
+  formalParameterList '=' typeWithoutFunction ('.' identifier)?
+```
+
+The syntax relies on treating `Function` as a fixed element in a function
+type, similar to a keyword or a symbol (many languages use symbols like
+`->` to mark function types).
+
+*The rationale for using this form is that it makes a function type very
+similar to the header in a declaration of a function with that type: Just
+replace `Function` by the name of the function, and add missing parameter
+names and default values.*
+
+*The syntax differs from the existing function type syntax
+(`functionSignature`) in that the existing syntax allows the type of a
+parameter to be omitted, but the new syntax allows names of positional
+parameters to be
+omitted. The rationale for this change is that a function type where a
+parameter has a specified name and no type is very likely to be a
+mistake. For instance, `int Function(int)` should not be the type of a
+function that accepts an argument named "int" of type `dynamic`, it should
+specify `int` as the parameter type and allow the name to be
+unspecified. It is still possible to opt in and specify the parameter name,
+which may be useful as documentation, e.g., if several arguments have the
+same type.*
+
+The modification of the rule for the nonterminal `type` causes parsing
+ambiguities. The following disambiguation rule applies:
+If the parser is at a location L where the tokens starting
+at L may be a `type` or some other construct (e.g., in the body of a
+method, when parsing something that may be a statement and may also be a
+declaration), the parser must commit to parsing a `type` if it
+is looking at the identifier `Function` followed by `<` or `(`, or it
+is looking at a `type` followed by the identifier `Function` followed by `<`
+or `(`.
+
+*Note that this disambiguation rule does require parsers to have unlimited
+lookahead. However, if a parsing strategy is used where the token
+stream already contains references from each opening bracket (such as `<`
+or `(`) to the corresponding closing bracket then the decision can be
+taken in a fixed number of steps: If the current token is `Function` then
+check the immediate successor (`<` or `(` means yes, we are looking at
+a `type`, everything else means no) and we're done; if the first token is
+an `identifier` other than `Function` then we can check whether it is a
+`qualified` by looking at no more than the two next tokens, and we may then
+check whether the next token again is `<`; if it is not then we look for
+`Function` and the token after that, and if it is `<` then look for the
+corresponding `>` (we have now skipped a generic class type), and then
+the successor to that token again must be `Function`, and we finally check
+its successor (looking for `<` or `(` again). This skips over the
+presumed type arguments to a generic class type without checking that they
+are actually type arguments, but we conjecture that there are no
+syntactically correct alternatives (for example, we conjecture that there
+is no syntactically correct statement, not a declaration, starting with
+`SomeIdentifier<...> Function(...` where the angle brackets are balanced).*
+
+*Note that this disambiguation rule will prevent parsing some otherwise
+correct programs. For instance, the declaration of an asynchronous function
+named `Function` with an omitted return type (meaning `dynamic`) and an
+argument named `int` of type `dynamic` using `Function(int) async {}` will
+be a parse error, because the parser will commit to parsing a type after
+having seen "`Function(`" as a lookahead. However, we do not expect that it
+will be a serious problem for developers to be unable to write such
+programs.*
+
+## Scoping
+
+Consider a typedef declaration as introduced by this feature, i.e., a
+construct on the form
+
+```
+metadata 'typedef' identifier typeParameters? '=' functionType ';'
+```
+
+This declaration introduces `identifier` into the enclosing library scope.
+
+Consider a parameterized typedef, i.e., a construct on the form
+
+```
+metadata 'typedef' identifier typeParameters '=' functionType ';'
+```
+
+Note that in this case the `typeParameters` cannot be omitted. This
+construct introduces a scope known as the *typedef scope*. Each typedef
+scope is nested inside the library scope of the enclosing library. Every
+formal type parameter declared by the `typeParameters` in this construct
+introduces a type variable into its enclosing typedef scope. The typedef
+scope is the current scope for the `typeParameters` themselves, and for the
+`functionType`.
+
+Consider a `functionType` specifying a generic function type, i.e., a
+construct on the form
+
+```
+returnType? 'Function' typeParameters parameterTypeList
+```
+
+Note again that `typeParameters` are present, not optional. This construct
+introduces a scope known as a *function type scope*. The function type
+scope is nested inside the current scope for the associated `functionType`.
+Every formal type parameter declared by the `typeParameters` introduces a
+type variable into its enclosing function type scope. The function type
+scope is the current scope for the entire `functionType`.
+
+*This implies that parameterized typedefs and function types are capable of
+specifying F-bounded type parameters, because the type parameters are in
+scope in the type parameter list itself.*
+
+## Static Analysis
+
+Consider a typedef declaration as introduced by this feature, i.e., a
+construct on the form
+
+```
+metadata 'typedef' identifier typeParameters? '=' functionType ';'
+```
+
+It is a compile-time error if a name *N* introduced into a library scope by
+a typedef has an associated `functionType` which depends directly or
+indirectly on *N*. It is a compile-time error if a bound on a formal type
+parameter in `typeParameters` is not a type. It is a compile-time error if
+a typedef has an associated `functionType` which is not a well-bounded type
+when analyzed under the assumption that every identifier resolving to a
+formal type parameter in `typeParameters` is a type satisfying its bound. It
+is a compile-time error if an instantiation *F<T1..Tk>* of a parameterized
+typedef is mal-bounded.
+
+*This implies that a typedef cannot be recursive. It can only introduce a
+name as an alias for a type which is already expressible as a
+`functionType`, or a name for a type-level function F where every
+well-bounded invocation `F<T1..Tk>` denotes a type which could be expressed
+as a `functionType`. In the terminology of
+[kind systems](https://en.wikipedia.org/wiki/Kind_(type_theory)), we
+could say that a typedef can define entities of kind ` * ` and of kind
+` * -> * `, and, when it is assumed that every formal type parameter of the
+typedef (if any) has kind ` * `, it is an error if the right hand side of the
+declaration denotes an entity of any other kind than ` * `; in particular,
+declarations of entities of kind ` * -> * ` cannot be curried.*
+
+*Note that the constraints required to ensure that the body of a `typedef`
+is well-bounded may not be expressible in the language with some otherwise
+reasonable declarations:
+``` dart
+typedef F<X> = void Function(X);
+class C<Y extends F<num>> {}
+typedef G<Z> = C<F<Z>> Function();
+```
+The formal type parameter `Z` must be a supertype of `num` in order to
+ensure that `F<Z>` is a subtype of the bound `F<num>`, but we do not support
+lower bounds on type arguments in Dart. Consequently, a declaration like
+`G` is a compile-time error no matter which bound we specify for `Z`, because
+no bound will ensure that the body is well-bounded for all possible `Z`.
+Similarly, the body of a `typedef` may use a given type argument in
+two or more different covariant contexts, which may require a bound which
+is a subtype of the constraints needed for each of those usages; for
+nominal types we would need an intersection type constructor in order to
+express a useful constraint in this situation. A richer type algebra
+may be added to Dart in the future which could allow more of these
+complex `typedef`s, but it is not obvious that it is useful enough to
+justify the added complexity.*
+
+It is a compile-time error if a name declared in a typedef, with or without
+actual type arguments, is used as a superclass, superinterface, or mixin. It
+is a compile-time error if a generic function type is used as a bound for a
+formal type parameter of a class or a function. It is a compile-time error if
+a generic function type is used as an actual type argument.
+
+*Generic function types can thus only be used in the following situations:*
+
+- *as a type annotation on an local, instance, static, or global variable.*
+- *as a function return or parameter type.*
+- *in a type test.*
+- *in a type cast.*
+- *in an on-catch clause.*
+- *as a parameter or return type in a function type.*
+
+*The motivation for having this constraint is that it ensures that the Dart type
+system admits only predicative types. It does admit non-prenex types, e.g.,
+`int Function(T function<T>(T) f)`. From research into functional calculi
+it is well-known that impredicative types give rise to undecidable subtyping,
+e.g.,
+[(Pierce, 1993)](http://www2.tcs.ifi.lmu.de/lehre/SS07/Typen/pierce93bounded.pdf),
+and even though the Dart type system is very different from F-sub, we cannot
+assume that these difficulties are absent.*
+
+## Dynamic Semantics
+
+The addition of this feature does not change the dynamic semantics of
+Dart.
+
+## Changes
+
+2017-May-31: Added constraint on usage of generic function types: They
+cannot be used as type parameter bounds nor as type arguments.
+
+2017-Jan-04: Adjusted the grammar to require named parameter types to have
+a type (previously, the type was optional).
+
+2016-Dec-21: Changed the grammar to prevent the new function type syntax
+in several locations (for instance, as a super class or as a mixin). The
+main change in the grammar is the introduction of `typeWithoutFunction`.
+
+2016-Dec-15: Changed the grammar to prevent the old style function types
+(derived from `functionSignature` in the grammar) from occurring inside
+the new style (`functionType`).
diff --git a/docs/language/informal/generic-method-syntax.md b/docs/language/informal/generic-method-syntax.md
new file mode 100644
index 0000000..d69c400
--- /dev/null
+++ b/docs/language/informal/generic-method-syntax.md
@@ -0,0 +1,245 @@
+# Feature: Generic Method Syntax
+
+**This document** is an informal specification of the support in Dart 1.x
+for generic methods and functions which includes syntax and name
+resolution, but not reification of type arguments.
+
+The **motivation for** having this **feature** is that it enables partial
+support for generic methods and functions, thus providing a bridge between
+not having generic methods and having full support for generic methods. In
+particular, code declaring and using generic methods may be type checked and
+compiled in strong mode, and the same code will now be acceptable in
+standard (non-strong) mode as well. The semantics is different in certain
+cases, but standard mode analysis will emit diagnostic messages (e.g.,
+errors) for that.
+
+In this document, the word **routine** will be used when referring to
+an entity which can be a non-operator method declaration, a top level
+function declaration, a local function declaration, or a function literal
+expression. Depending on the context, the word routine may also denote the
+semantic entity associated with such a declaration, e.g., a closure
+corresponding to a function literal.
+
+With **this feature** it is possible to compile code where generic methods
+and functions are declared, implemented, and invoked. The runtime semantics
+does not include reification of type arguments. Usages of the runtime
+value of a routine type parameter is a runtime error or yields `dynamic`,
+depending on the context. No type checking takes place at usages of a method
+or function type parameter in the body, and no type checking regarding
+explicitly specified or omitted type arguments takes place at call sites.
+
+In short, generic methods and functions are supported syntactically, and the
+runtime semantics prevents dynamic usages of the type argument values, but
+it allows all usages where that dynamic value is not required. For instance,
+a generic routine type parameter, `T`, cannot be used in an expression like
+`x is T`, but it can be used as a type annotation. In a context where other
+tools may perform type checking, this allows for a similar level of
+expressive power as do language designs where type arguments are erased at
+compile time.
+
+The **motivation for** this **document** is that it serves as an informal
+specification for the implementation of support for the generic method
+syntax feature in all Dart tools.
+
+## Syntax
+
+The syntactic elements which are added or modified in order to support this
+feature are as follows, based on grammar rules given in the Dart Language
+Specification (Aug 19, 2015).
+
+```
+formalParameterPart:
+  typeParameters? formalParameterList
+functionSignature:
+  metadata returnType? identifier formalParameterPart
+typeParameter:
+  metadata identifier ('extends' type)?
+functionExpression:
+  formalParameterPart functionBody
+fieldFormalParameter:
+  metadata finalConstVarOrType? 'this' '.' identifier
+  formalParameterPart?
+argumentPart:
+  typeArguments? arguments
+selector:
+  assignableSelector | argumentPart
+assignableExpression:
+  primary (argumentPart* assignableSelector)+ |
+  'super' unconditionalAssignableSelector |
+  identifier
+cascadeSection:
+  '..' (cascadeSelector argumentPart*)
+  (assignableSelector argumentPart*)*
+  (assignmentOperator expressionWithoutCascade)?
+```
+
+In a [draft specification](https://codereview.chromium.org/1177073002) of
+generic methods from June 2015, the number of grammar changes is
+significantly higher, but that form can be obtained via renaming.
+
+This extension to the grammar gives rise to an **ambiguity** where the
+same tokens may be angle brackets of a type argument list as well as
+relational operators. For instance, `foo(a<b,c>(d))`[^1] may be parsed as  
+a `postfixExpression` on the form `primary arguments` where the arguments
+are two relational expressions (`a<b` and `c>(d)`), and it may also be
+parsed such that there is a single argument which is an invocation of a
+generic function (`a<b,c>(d)`).  The ambiguity is resolved in **favor** of
+the latter.
+
+*This is a breaking change, because existing code could include
+expressions like `foo(a < b, c > (d))` where `foo` receives two
+arguments. That expression will now be parsed as an invocation of `foo`
+with one argument. It is unlikely that this will introduce bugs silently,
+because the new parsing is likely to incur diagnostic messages at
+compile-time.*
+
+We chose to favor the generic function invocation over the
+relational expression because it is considered to be a rare exception that
+this ambiguity arises: It requires a balanced set of angle brackets followed
+by a left parenthesis, which is already an unusual form. On top of that, the
+style guide recommendation to use named parameters for boolean arguments
+helps making this situation even less common.
+
+If it does occur then there is an easy **workaround**: an extra set of
+parentheses (as in `foo(a<b,(2>(d)))`) will resolve the ambiguity in the
+direction of relational expressions; or we might simply be able to remove
+the parentheses around the last expression (as in `foo(a<b,2>d)`), which
+will also eliminate the ambiguity.
+
+_It should be noted that parsing techniques like recursive descent seem to
+conflict with this approach to disambiguation: Determining whether the
+remaining input starts with a balanced expression on the form `<` .. `>`
+seems to imply a need for unbounded lookahead. However, if some type of
+parsing is used where bracket tokens are matched up during lexical
+analysis then it takes only a simple O(1) operation in the parser to
+perform a check which will very frequently resolve the ambiguity._
+
+## Scope of the Mechanism
+
+With the syntax in place, it is obvious that certain potential extensions
+have **not** been **included**.
+
+For instance, constructors, setters, getters, and operators cannot be
+declared as generic: The syntax for passing actual type arguments at
+invocation sites for setters, getters, and operators is likely to be
+unwieldy and confusing, and for constructors there is a need to find
+a way to distinguish between type arguments for the new instance and
+type arguments for the constructor itself. However, there are plans
+to add support for generic constructors.
+
+This informal specification specifies a dynamic semantics where the values
+of **actual type arguments are not reified** at run time. A future
+extension of this mechanism may add this reification, such that dynamic
+type tests and type casts involving routine type variables will be
+supported.
+
+## Resolution and Type Checking
+
+In order to be useful, the support for generic methods and functions must be
+sufficiently complete and consistent to **avoid spurious** diagnostic
+**messages**. In particular, even though no regular type checks take place
+at usages of routine type parameters in the body where they are in scope,
+those type parameters should be resolved. If they had been ignored then any
+usage of a routine type parameter `X` would give rise to a `Cannot resolve
+type X` error message, or the usage might resolve to other declarations of
+`X` in enclosing scopes such as a class type parameter, both of which is
+unacceptable.
+
+In `dart2js` resolution, the desired behavior has been achieved by adding a
+new type parameter **scope** and putting the type parameters into that
+scope, giving each of them the bound `dynamic`. The type parameter scope is
+the current scope during resolution of the routine signature and the type
+parameter bounds, it encloses the formal parameter scope of the routine, and
+the formal parameter scope in turn encloses the body scope.
+
+This implies that every usage of a routine type parameter is treated during
+**type checking** as if it had been an alias for the type dynamic.
+
+Static checks for **invocations** of methods or functions where type
+arguments are passed are omitted entirely: The type arguments are parsed,
+but no checks are applied to certify that the given routine accepts type
+arguments, and no checks are applied for bound violations. Similarly, no
+checks are performed for invocations where no type arguments are passed,
+whether or not the given routine is statically known to accept type
+arguments.
+
+Certain usages of a routine type parameter `X` give rise to **errors**: It
+is a compile-time error if `X` is used as a type literal expression (e.g.,
+`foo(X)`), or in an expression on the form `e is X` or `e is! X`, or in a
+try/catch statement like `.. on T catch ..`.
+
+It could be argued that it should be a warning or an error if a routine type
+parameter `X` is used in an expression on the form `e as X`. The blind
+success of this test at runtime may introduce bugs into correct programs in
+situations where the type constraint is violated; in particular, this could
+cause "wrong" objects to propagate through local variables and parameters
+and even into data structures (say, when a `List<T>` is actually a
+`List<dynamic>`, because `T` is not present at runtime when the list is
+created). However, considering that these type constraint violations are
+expected to be rare, and considering that it is common to require that
+programs compile without warnings, we have chosen to omit this warning. A
+tool is still free to emit a hint, or in some other way indicate that there
+is an issue.
+
+## Dynamic semantics
+
+If a routine invocation specifies actual type arguments, e.g., `int` in the
+**invocation** `f<int>(42)`, those type arguments will not be evaluated at
+runtime, and they will not be passed to the routine in the
+invocation. Similarly, no type arguments are ever passed to a generic
+routine due to call-site inference. This corresponds to the fact that the
+type arguments have no runtime representation.
+
+When the body of a generic **routine** is **executed**, usages of the formal
+type parameters will either result in a run-time error, or they will yield
+the type dynamic, following the treatment of malformed types in
+Dart. There are the following cases:
+
+When `X` is a routine type parameter, the evaluation of `e is X`, `e is! X`,
+and `X` used as an expression proceeds as if `X` had been a malformed type,
+producing a dynamic error; the evaluation of `e as X` has the same outcome
+as the evaluation of `e`.
+
+Note that the forms containing `is` are compile-time errors, which means
+that compilers may reject the program or offer ways to compile the program
+with a different runtime semantics for these expressions. The rationale for
+`dart2js` allowing the construct and compiling it to a run time error is
+that (1) this allows more programs using generic methods to be compiled,
+and (2) an `is` expression that blindly returns `true` every time (or
+`false` every time) may silently introduce a bug into an otherwise correct
+program, so the expression must fail if it is ever evaluated.
+
+When `X` is a routine type parameter which is passed as a type argument to a
+generic class instantiation `G`, it is again treated like a malformed type,
+i.e., it is considered to denote the type dynamic.
+
+This may be surprising, so let us consider a couple of examples: When `X` is
+a routine type parameter, `42 is X` raises a dynamic error, `<int>[42] is
+List<X>` yields the value `true`, and `42 as X` yields `42`, no matter
+whether the syntax for the invocation of the routine included an actual type
+argument, and, if so, no matter which value the actual type argument would
+have had at the invocation.
+
+Object construction is similar: When `X` is a routine type parameter which
+is a passed as a type argument in a constructor invocation, the actual
+value of the type type argument will be the type dynamic, as it would have
+been with a malformed type.
+
+In **checked mode**, when `X` is a routine type parameter, no checked mode
+checks will ever fail for initialization or assignment to a local variable
+or parameter whose type annotation is `X`, and if the type annotation is a
+generic type `G` that contains `X`, checked mode checks will succeed or
+fail as if `X` had been the type dynamic. Note that this differs from the
+treatment of malformed types.
+
+## Changes
+
+2017-Jan-04: Changed 'static error' to 'compile-time error', which is the
+phrase that the language specification uses.
+
+## Notes
+
+[^1]: These expressions violate the common style in Dart with respect to
+spacing and capitalization. That is because the ambiguity implies
+conflicting requirements, and we do not want to bias the appearance in
+one of the two directions.
diff --git a/pkg/analysis_server/lib/src/plugin/plugin_manager.dart b/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
index e69d1f3..6b4fdc7 100644
--- a/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
+++ b/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
@@ -311,7 +311,9 @@
     // TODO(brianwilkerson) Figure out the right list of plugin paths.
     _whitelistGlobs = <Glob>[
       new Glob(resourceProvider.pathContext.separator,
-          '**/angular_analyzer_plugin/tools/analyzer_plugin')
+          '**/angular_analyzer_plugin/tools/analyzer_plugin'),
+      new Glob(resourceProvider.pathContext.separator,
+          '**angular/tools/analyzer_plugin')
     ];
   }
 
diff --git a/pkg/analysis_server/test/abstract_context.dart b/pkg/analysis_server/test/abstract_context.dart
index 5d61bf5..e7dfc1c 100644
--- a/pkg/analysis_server/test/abstract_context.dart
+++ b/pkg/analysis_server/test/abstract_context.dart
@@ -56,10 +56,7 @@
 
   AnalysisDriver get driver => _driver;
 
-  Source addMetaPackageSource() => addPackageSource(
-      'meta',
-      'meta.dart',
-      r'''
+  Source addMetaPackageSource() => addPackageSource('meta', 'meta.dart', r'''
 library meta;
 
 const Required required = const Required();
diff --git a/pkg/analysis_server/test/analysis/get_errors_test.dart b/pkg/analysis_server/test/analysis/get_errors_test.dart
index 76ee3f3..431f5ed 100644
--- a/pkg/analysis_server/test/analysis/get_errors_test.dart
+++ b/pkg/analysis_server/test/analysis/get_errors_test.dart
@@ -46,16 +46,12 @@
   test_errorInPart() async {
     String libPath = '$testFolder/main.dart';
     String partPath = '$testFolder/main_part.dart';
-    addFile(
-        libPath,
-        r'''
+    addFile(libPath, r'''
 library main;
 part 'main_part.dart';
 class A {}
 ''');
-    addFile(
-        partPath,
-        r'''
+    addFile(partPath, r'''
 part of main;
 class A {}
 ''');
@@ -81,9 +77,7 @@
   test_fileWithoutContext() {
     // Broken under the new driver.
     String file = '/outside.dart';
-    addFile(
-        file,
-        '''
+    addFile(file, '''
 main() {
   print(42);
 }
diff --git a/pkg/analysis_server/test/analysis/notification_errors_test.dart b/pkg/analysis_server/test/analysis/notification_errors_test.dart
index 98539b3..904a0e4 100644
--- a/pkg/analysis_server/test/analysis/notification_errors_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_errors_test.dart
@@ -66,9 +66,7 @@
   test_lintError() async {
     var camelCaseTypesLintName = 'camel_case_types';
 
-    addFile(
-        '$projectPath/.analysis_options',
-        '''
+    addFile('$projectPath/.analysis_options', '''
 linter:
   rules:
     - $camelCaseTypesLintName
diff --git a/pkg/analysis_server/test/analysis/notification_highlights_test.dart b/pkg/analysis_server/test/analysis/notification_highlights_test.dart
index 77d28da..ccd8350 100644
--- a/pkg/analysis_server/test/analysis/notification_highlights_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_highlights_test.dart
@@ -934,9 +934,7 @@
   }
 
   void _addLibraryForTestPart() {
-    addFile(
-        '$testFolder/my_lib.dart',
-        '''
+    addFile('$testFolder/my_lib.dart', '''
 library lib;
 part 'test.dart';
     ''');
diff --git a/pkg/analysis_server/test/analysis/notification_highlights_test2.dart b/pkg/analysis_server/test/analysis/notification_highlights_test2.dart
index a0f2a18..a522793 100644
--- a/pkg/analysis_server/test/analysis/notification_highlights_test2.dart
+++ b/pkg/analysis_server/test/analysis/notification_highlights_test2.dart
@@ -1085,9 +1085,7 @@
   }
 
   void _addLibraryForTestPart() {
-    addFile(
-        '$testFolder/my_lib.dart',
-        '''
+    addFile('$testFolder/my_lib.dart', '''
 library lib;
 part 'test.dart';
     ''');
diff --git a/pkg/analysis_server/test/analysis/notification_implemented_test.dart b/pkg/analysis_server/test/analysis/notification_implemented_test.dart
index 27c1f59..cc80eb9 100644
--- a/pkg/analysis_server/test/analysis/notification_implemented_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_implemented_test.dart
@@ -271,9 +271,7 @@
   }
 
   test_method_withMethod_private_differentLib() async {
-    addFile(
-        '$testFolder/lib.dart',
-        r'''
+    addFile('$testFolder/lib.dart', r'''
 import 'test.dart';
 class B extends A {
   void _m() {}
diff --git a/pkg/analysis_server/test/analysis/notification_navigation_test.dart b/pkg/analysis_server/test/analysis/notification_navigation_test.dart
index e0f0cc3..f57c671 100644
--- a/pkg/analysis_server/test/analysis/notification_navigation_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_navigation_test.dart
@@ -229,9 +229,7 @@
   }
 
   test_annotationConstructor_importPrefix() async {
-    addFile(
-        '$testFolder/my_annotation.dart',
-        r'''
+    addFile('$testFolder/my_annotation.dart', r'''
 library an;
 class MyAnnotation {
   const MyAnnotation();
@@ -306,9 +304,7 @@
   }
 
   test_annotationField_importPrefix() async {
-    addFile(
-        '$testFolder/mayn.dart',
-        r'''
+    addFile('$testFolder/mayn.dart', r'''
 library an;
 const myan = new Object();
 ''');
diff --git a/pkg/analysis_server/test/analysis/notification_overrides_test.dart b/pkg/analysis_server/test/analysis/notification_overrides_test.dart
index ab9efad..10abe23 100644
--- a/pkg/analysis_server/test/analysis/notification_overrides_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_overrides_test.dart
@@ -232,9 +232,7 @@
   }
 
   test_BAD_privateByPrivate_inDifferentLib() async {
-    addFile(
-        '$testFolder/lib.dart',
-        r'''
+    addFile('$testFolder/lib.dart', r'''
 class A {
   void _m() {}
 }
diff --git a/pkg/analysis_server/test/analysis/set_priority_files_test.dart b/pkg/analysis_server/test/analysis/set_priority_files_test.dart
index 6ec0b4b..1de25bf 100644
--- a/pkg/analysis_server/test/analysis/set_priority_files_test.dart
+++ b/pkg/analysis_server/test/analysis/set_priority_files_test.dart
@@ -64,9 +64,7 @@
 
   test_ignoredInAnalysisOptions() async {
     String sampleFile = '$projectPath/samples/sample.dart';
-    addFile(
-        '$projectPath/.analysis_options',
-        r'''
+    addFile('$projectPath/.analysis_options', r'''
 analyzer:
   exclude:
     - 'samples/**'
@@ -81,9 +79,7 @@
     addFile('$projectPath/.packages', '');
     addFile('$projectPath/child/.packages', '');
     String sampleFile = '$projectPath/child/samples/sample.dart';
-    addFile(
-        '$projectPath/child/.analysis_options',
-        r'''
+    addFile('$projectPath/child/.analysis_options', r'''
 analyzer:
   exclude:
     - 'samples/**'
@@ -98,9 +94,7 @@
     addFile('$projectPath/.packages', '');
     addFile('$projectPath/child/.packages', '');
     String sampleFile = '$projectPath/child/samples/sample.dart';
-    addFile(
-        '$projectPath/.analysis_options',
-        r'''
+    addFile('$projectPath/.analysis_options', r'''
 analyzer:
   exclude:
     - 'child/samples/**'
diff --git a/pkg/analysis_server/test/analysis/update_content_test.dart b/pkg/analysis_server/test/analysis/update_content_test.dart
index ea7db86..8bd671c 100644
--- a/pkg/analysis_server/test/analysis/update_content_test.dart
+++ b/pkg/analysis_server/test/analysis/update_content_test.dart
@@ -69,23 +69,17 @@
 
   test_multiple_contexts() async {
     String fooPath = '/project1/foo.dart';
-    resourceProvider.newFile(
-        fooPath,
-        '''
+    resourceProvider.newFile(fooPath, '''
 library foo;
 import '../project2/baz.dart';
 main() { f(); }''');
     String barPath = '/project2/bar.dart';
-    resourceProvider.newFile(
-        barPath,
-        '''
+    resourceProvider.newFile(barPath, '''
 library bar;
 import 'baz.dart';
 main() { f(); }''');
     String bazPath = '/project2/baz.dart';
-    resourceProvider.newFile(
-        bazPath,
-        '''
+    resourceProvider.newFile(bazPath, '''
 library baz;
 f(int i) {}
 ''');
diff --git a/pkg/analysis_server/test/analysis_server_test.dart b/pkg/analysis_server/test/analysis_server_test.dart
index e74b13d..a79dea6 100644
--- a/pkg/analysis_server/test/analysis_server_test.dart
+++ b/pkg/analysis_server/test/analysis_server_test.dart
@@ -153,9 +153,7 @@
   test_setAnalysisSubscriptions_fileInIgnoredFolder_newOptions() async {
     String path = '/project/samples/sample.dart';
     resourceProvider.newFile(path, '');
-    resourceProvider.newFile(
-        '/project/analysis_options.yaml',
-        r'''
+    resourceProvider.newFile('/project/analysis_options.yaml', r'''
 analyzer:
   exclude:
     - 'samples/**'
@@ -174,9 +172,7 @@
   test_setAnalysisSubscriptions_fileInIgnoredFolder_oldOptions() async {
     String path = '/project/samples/sample.dart';
     resourceProvider.newFile(path, '');
-    resourceProvider.newFile(
-        '/project/.analysis_options',
-        r'''
+    resourceProvider.newFile('/project/.analysis_options', r'''
 analyzer:
   exclude:
     - 'samples/**'
diff --git a/pkg/analysis_server/test/completion_test.dart b/pkg/analysis_server/test/completion_test.dart
index 691a58f..8e56e6a 100644
--- a/pkg/analysis_server/test/completion_test.dart
+++ b/pkg/analysis_server/test/completion_test.dart
@@ -40,41 +40,28 @@
   }
 
   void buildCommentSnippetTests() {
-    buildTests(
-        'testCommentSnippets001',
-        '''
+    buildTests('testCommentSnippets001', '''
 class X {static final num MAX = 0;num yc,xc;mth() {xc = yc = MA!1X;x!2c.abs();num f = M!3AX;}}''',
         <String>["1+MAX", "2+xc", "3+MAX"]);
 
-    buildTests(
-        'testCommentSnippets002',
-        '''
+    buildTests('testCommentSnippets002', '''
 class Y {String x='hi';mth() {x.l!1ength;int n = 0;x!2.codeUnitAt(n!3);}}''',
         <String>["1+length", "2+x", "3+n"]);
 
-    buildTests(
-        'testCommentSnippets004',
-        '''
+    buildTests('testCommentSnippets004', '''
 class A {!1int x; !2mth() {!3int y = this.!5x!6;}}class B{}''',
         <String>["1+A", "2+B", "3+x", "3-y", "5+mth", "6+x"]);
 
-    buildTests(
-        'testCommentSnippets005',
-        '''
+    buildTests('testCommentSnippets005', '''
 class Date { static Date JUN, JUL;}class X { m() { return Da!1te.JU!2L; }}''',
         <String>["1+Date", "2+JUN", "2+JUL"]);
 
-    buildTests(
-        'testCommentSnippets007',
-        '''
+    buildTests('testCommentSnippets007', '''
 class C {mth(Map x, !1) {}mtf(!2, Map x) {}m() {for (in!3t i=0; i<5; i++); A!4 x;}}class int{}class Arrays{}''',
         <String>["1+bool", "2+bool", "3+int", "4+Arrays"]);
 
-    buildTests(
-        'testCommentSnippets008',
-        '''
-class Date{}final num M = Dat!1''',
-        <String>["1+Date"]);
+    buildTests('testCommentSnippets008', '''
+class Date{}final num M = Dat!1''', <String>["1+Date"]);
 
     // space, char, eol are important
     buildTests(
@@ -94,138 +81,81 @@
         failingTests: '46');
 
     // space, char, eol are important
-    buildTests(
-        'testCommentSnippets010',
-        '''
-class x implements !1{}''',
-        <String>["1+Map"]);
+    buildTests('testCommentSnippets010', '''
+class x implements !1{}''', <String>["1+Map"]);
 
     // space, char, eol are important
-    buildTests(
-        'testCommentSnippets011',
-        '''
-class x implements M!1{}''',
-        <String>["1+Map"]);
+    buildTests('testCommentSnippets011', '''
+class x implements M!1{}''', <String>["1+Map"]);
 
     // space, char, eol are important
-    buildTests(
-        'testCommentSnippets012',
-        '''
-class x implements M!1\n{}''',
-        <String>["1+Map"]);
+    buildTests('testCommentSnippets012', '''
+class x implements M!1\n{}''', <String>["1+Map"]);
 
-    buildTests(
-        'testCommentSnippets013',
-        '''
-class x !2{!1}!3''',
-        <String>["1+num", "2-num", "3+num"]);
+    buildTests('testCommentSnippets013', '''
+class x !2{!1}!3''', <String>["1+num", "2-num", "3+num"]);
 
     // trailing space is important
-    buildTests(
-        'testCommentSnippets014',
-        '''
-typedef n!1 ;''',
-        <String>["1+num"]);
+    buildTests('testCommentSnippets014', '''
+typedef n!1 ;''', <String>["1+num"]);
 
-    buildTests(
-        'testCommentSnippets015',
-        '''
-class D {f(){} g(){f!1(f!2);}}''',
-        <String>["1+f", "2+f"]);
+    buildTests('testCommentSnippets015', '''
+class D {f(){} g(){f!1(f!2);}}''', <String>["1+f", "2+f"]);
 
-    buildTests(
-        'testCommentSnippets016',
-        '''
-class F {m() { m(); !1}}''',
-        <String>["1+m"]);
+    buildTests('testCommentSnippets016', '''
+class F {m() { m(); !1}}''', <String>["1+m"]);
 
-    buildTests(
-        'testCommentSnippets017',
-        '''
-class F {var x = !1false;}''',
-        <String>["1+true"]);
+    buildTests('testCommentSnippets017', '''
+class F {var x = !1false;}''', <String>["1+true"]);
 
-    buildTests(
-        'testCommentSnippets018',
-        '''
+    buildTests('testCommentSnippets018', '''
 class Map{}class Arrays{}class C{ m(!1){} n(!2 x, q)''',
         <String>["1+Map", "1-void", "1-null", "2+Arrays", "2-void", "2-null"]);
 
-    buildTests(
-        'testCommentSnippets019',
-        '''
-class A{m(){Object x;x.!1/**/clear()''',
-        <String>["1+toString"]);
+    buildTests('testCommentSnippets019', '''
+class A{m(){Object x;x.!1/**/clear()''', <String>["1+toString"]);
 
-    buildTests(
-        'testCommentSnippets020',
-        '''
+    buildTests('testCommentSnippets020', '''
 classMap{}class tst {var newt;void newf(){}test() {var newz;new!1/**/;}}''',
         <String>["1+newt", "1+newf", "1+newz", "1-Map"]);
 
-    buildTests(
-        'testCommentSnippets021',
-        '''
+    buildTests('testCommentSnippets021', '''
 class Map{}class tst {var newt;void newf(){}test() {var newz;new !1/**/;}}''',
         <String>["1+Map", "1-newt"]);
 
-    buildTests(
-        'testCommentSnippets022',
-        '''
-class Map{}class F{m(){new !1;}}''',
-        <String>["1+Map"]);
+    buildTests('testCommentSnippets022', '''
+class Map{}class F{m(){new !1;}}''', <String>["1+Map"]);
 
-    buildTests(
-        'testCommentSnippets022a',
-        '''
-class Map{}class F{m(){new !1''',
-        <String>["1+Map"]);
+    buildTests('testCommentSnippets022a', '''
+class Map{}class F{m(){new !1''', <String>["1+Map"]);
 
-    buildTests(
-        'testCommentSnippets022b',
-        '''
+    buildTests('testCommentSnippets022b', '''
 class Map{factory Map.qq(){return null;}}class F{m(){new Map.!1qq();}}''',
         <String>["1+qq"]);
 
-    buildTests(
-        'testCommentSnippets023',
-        '''
+    buildTests('testCommentSnippets023', '''
 class X {X c; X(this.!1c!3) : super() {c.!2}}''',
         <String>["1+c", "2+c", "3+c"]);
 
-    buildTests(
-        'testCommentSnippets024',
-        '''
-class q {m(Map q){var x;m(!1)}n(){var x;n(!2)}}''',
-        <String>["1+x", "2+x"]);
+    buildTests('testCommentSnippets024', '''
+class q {m(Map q){var x;m(!1)}n(){var x;n(!2)}}''', <String>["1+x", "2+x"]);
 
-    buildTests(
-        'testCommentSnippets025',
-        '''
+    buildTests('testCommentSnippets025', '''
 class q {num m() {var q; num x=!1 q!3 + !2/**/;}}''',
         <String>["1+q", "2+q", "3+q"]);
 
-    buildTests(
-        'testCommentSnippets026',
-        '''
-class List{}class a implements !1{}''',
-        <String>["1+List"]);
+    buildTests('testCommentSnippets026', '''
+class List{}class a implements !1{}''', <String>["1+List"]);
 
-    buildTests(
-        'testCommentSnippets027',
-        '''
+    buildTests('testCommentSnippets027', '''
 class String{}class List{}class test <X extends !1String!2> {}''',
         <String>["1+List", "2+String", "2-List"]);
 
-    buildTests(
-        'testCommentSnippets028',
-        '''
+    buildTests('testCommentSnippets028', '''
 class String{}class List{}class DateTime{}typedef T Y<T extends !1>(List input);''',
         <String>["1+DateTime", "1+String"]);
 
-    buildTests(
-        'testCommentSnippets029',
-        '''
+    buildTests('testCommentSnippets029', '''
 interface A<X> default B<X extends !1List!2> {}''',
         <String>["1+DateTime", "2+List"]);
 
@@ -251,117 +181,74 @@
         failingTests: '1');
 
     // Type propagation
-    buildTests(
-        'testCommentSnippets033',
-        '''
+    buildTests('testCommentSnippets033', '''
 class List{add(){}length(){}}t1() {var x;if (x is List) {x.!1add(3);}}''',
         <String>["1+add", "1+length"]);
 
     // Type propagation
-    buildTests(
-        'testCommentSnippets035',
-        '''
+    buildTests('testCommentSnippets035', '''
 class List{clear(){}length(){}}t3() {var x=new List(), y=x.!1length();x.!2clear();}''',
         <String>["1+length", "2+clear"]);
 
-    buildTests(
-        'testCommentSnippets036',
-        '''
-class List{}t3() {var x=new List!1}''',
-        <String>["1+List"]);
+    buildTests('testCommentSnippets036', '''
+class List{}t3() {var x=new List!1}''', <String>["1+List"]);
 
-    buildTests(
-        'testCommentSnippets037',
-        '''
+    buildTests('testCommentSnippets037', '''
 class List{factory List.from(){}}t3() {var x=new List.!1}''',
         <String>["1+from"]);
 
-    buildTests(
-        'testCommentSnippets038',
-        '''
-f(){int xa; String s = '\$x!1';}''',
-        <String>["1+xa"]);
+    buildTests('testCommentSnippets038', '''
+f(){int xa; String s = '\$x!1';}''', <String>["1+xa"]);
 
-    buildTests(
-        'testCommentSnippets038a',
-        '''
-int xa; String s = '\$x!1\'''',
-        <String>["1+xa"]);
+    buildTests('testCommentSnippets038a', '''
+int xa; String s = '\$x!1\'''', <String>["1+xa"]);
 
-    buildTests(
-        'testCommentSnippets039',
-        '''
-f(){int xa; String s = '\$!1';}''',
-        <String>["1+xa"]);
+    buildTests('testCommentSnippets039', '''
+f(){int xa; String s = '\$!1';}''', <String>["1+xa"]);
 
-    buildTests(
-        'testCommentSnippets039a',
-        '''
-int xa; String s = '\$!1\'''',
-        <String>["1+xa"]);
+    buildTests('testCommentSnippets039a', '''
+int xa; String s = '\$!1\'''', <String>["1+xa"]);
 
-    buildTests(
-        'testCommentSnippets040',
-        '''
+    buildTests('testCommentSnippets040', '''
 class List{add(){}}class Map{}class X{m(){List list; list.!1 Map map;}}''',
         <String>["1+add"]);
 
-    buildTests(
-        'testCommentSnippets041',
-        '''
+    buildTests('testCommentSnippets041', '''
 class List{add(){}length(){}}class X{m(){List list; list.!1 zox();}}''',
         <String>["1+add"]);
 
-    buildTests(
-        'testCommentSnippets042',
-        '''
+    buildTests('testCommentSnippets042', '''
 class DateTime{static const int WED=3;int get day;}fd(){DateTime d=new DateTime.now();d.!1WED!2;}''',
         <String>["1+day", "2-WED"]);
 
-    buildTests(
-        'testCommentSnippets043',
-        '''
-class L{var k;void.!1}''',
-        <String>["1-k"]);
+    buildTests('testCommentSnippets043', '''
+class L{var k;void.!1}''', <String>["1-k"]);
 
-    buildTests(
-        'testCommentSnippets044',
-        '''
+    buildTests('testCommentSnippets044', '''
 class List{}class XXX {XXX.fisk();}main() {main(); new !1}}''',
         <String>["1+List", "1+XXX.fisk"]);
 
-    buildTests(
-        'testCommentSnippets047',
-        '''
-f(){int x;int y=!1;}''',
-        <String>["1+x"]);
+    buildTests('testCommentSnippets047', '''
+f(){int x;int y=!1;}''', <String>["1+x"]);
 
-    buildTests(
-        'testCommentSnippets048',
-        '''
-import 'dart:convert' as json;f() {var x=new js!1}''',
-        <String>["1+json"]);
+    buildTests('testCommentSnippets048', '''
+import 'dart:convert' as json;f() {var x=new js!1}''', <String>["1+json"]);
 
-    buildTests(
-        'testCommentSnippets049',
-        '''
+    buildTests('testCommentSnippets049', '''
 import 'dart:convert' as json;
 import 'dart:convert' as jxx;
 class JsonDecoderX{}
-f1() {var x=new !2j!1s!3}''',
-        <String>[
-          "1+json",
-          "1+jxx",
-          "2+json",
-          "2+jxx",
-          "2-JsonDecoder",
-          "3+json",
-          "3-jxx"
-        ]);
+f1() {var x=new !2j!1s!3}''', <String>[
+      "1+json",
+      "1+jxx",
+      "2+json",
+      "2+jxx",
+      "2-JsonDecoder",
+      "3+json",
+      "3-jxx"
+    ]);
 
-    buildTests(
-        'testCommentSnippets050',
-        '''
+    buildTests('testCommentSnippets050', '''
 class xdr {
   xdr();
   const xdr.a(a,b,c);
@@ -372,24 +259,21 @@
 k() {
   new x!1dr().f();
   const x!2dr.!3a(1, 2, 3);
-}''',
-        <String>[
-          "1+xdr",
-          "1+xa",
-          "1+xdr.a",
-          "1+xdr.b",
-          "2+xa", // suggest default constructor
-          "2+xdr", // suggest normal constructor
-          "2+xdr.a",
-          "2+xdr.b", // suggest named constructor
-          "3+b", // suggest named constructor
-          "3+a"
-        ]);
+}''', <String>[
+      "1+xdr",
+      "1+xa",
+      "1+xdr.a",
+      "1+xdr.b",
+      "2+xa", // suggest default constructor
+      "2+xdr", // suggest normal constructor
+      "2+xdr.a",
+      "2+xdr.b", // suggest named constructor
+      "3+b", // suggest named constructor
+      "3+a"
+    ]);
 
     // Type propagation.
-    buildTests(
-        'testCommentSnippets051',
-        '''
+    buildTests('testCommentSnippets051', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void r() {
   var v;
@@ -397,13 +281,10 @@
     v.!1length;
     v.!2getKeys;
   }
-}''',
-        <String>["1+length", "2-getKeys"]);
+}''', <String>["1+length", "2-getKeys"]);
 
     // Type propagation.
-    buildTests(
-        'testCommentSnippets052',
-        '''
+    buildTests('testCommentSnippets052', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void r() {
   List<String> values = ['a','b','c'];
@@ -411,13 +292,10 @@
     v.!1toUpperCase;
     v.!2getKeys;
   }
-}''',
-        <String>["1+toUpperCase", "2-getKeys"]);
+}''', <String>["1+toUpperCase", "2-getKeys"]);
 
     // Type propagation.
-    buildTests(
-        'testCommentSnippets053',
-        '''
+    buildTests('testCommentSnippets053', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void r() {
   var v;
@@ -425,12 +303,9 @@
     v.!1toUpperCase;
     v.!2getKeys;
   }
-}''',
-        <String>["1+toUpperCase", "2-getKeys"]);
+}''', <String>["1+toUpperCase", "2-getKeys"]);
 
-    buildTests(
-        'testCommentSnippets054',
-        '''
+    buildTests('testCommentSnippets054', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void r() {
   var v;
@@ -438,45 +313,35 @@
     v.!2toUpperCase;
     v.!3getKeys;
   }
-}''',
-        <String>["1+isEmpty", "2+toUpperCase", "3-getKeys"]);
+}''', <String>["1+isEmpty", "2+toUpperCase", "3-getKeys"]);
 
-    buildTests(
-        'testCommentSnippets055',
-        '''
+    buildTests('testCommentSnippets055', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void r() {
   String v;
   if (v is Object) {
     v.!1toUpperCase;
   }
-}''',
-        <String>["1+toUpperCase"]);
+}''', <String>["1+toUpperCase"]);
 
     // Type propagation.
-    buildTests(
-        'testCommentSnippets056',
-        '''
+    buildTests('testCommentSnippets056', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void f(var v) {
   if (v is!! String) {
     return;
   }
   v.!1toUpperCase;
-}''',
-        <String>["1+toUpperCase"]);
+}''', <String>["1+toUpperCase"]);
 
     // Type propagation.
-    buildTests(
-        'testCommentSnippets057',
-        '''
+    buildTests('testCommentSnippets057', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void f(var v) {
   if ((v as String).!2length == 0) {
     v.!1toUpperCase;
   }
-}''',
-        <String>["1+toUpperCase", "2+length"]);
+}''', <String>["1+toUpperCase", "2+length"]);
 
     buildTests(
         'testCommentSnippets058',
@@ -490,15 +355,10 @@
         <String>["1+v", "2+void"],
         failingTests: '2');
 
-    buildTests(
-        'testCommentSnippets059',
-        '''
-f(){((int x) => x+4).!1call(1);}''',
-        <String>["1-call"]);
+    buildTests('testCommentSnippets059', '''
+f(){((int x) => x+4).!1call(1);}''', <String>["1-call"]);
 
-    buildTests(
-        'testCommentSnippets060',
-        '''
+    buildTests('testCommentSnippets060', '''
 class Map{}
 abstract class MM extends Map{factory MM() => new Map();}
 class Z {
@@ -506,30 +366,22 @@
   f() {
     x!1
   }
-}''',
-        <String>["1+x", "1-x[]"]);
+}''', <String>["1+x", "1-x[]"]);
 
-    buildTests(
-        'testCommentSnippets061',
-        '''
+    buildTests('testCommentSnippets061', '''
 class A{m(){!1f(3);!2}}n(){!3f(3);!4}f(x)=>x*3;''',
         <String>["1+f", "1+n", "2+f", "2+n", "3+f", "3+n", "4+f", "4+n"]);
 
     // Type propagation.
-    buildTests(
-        'testCommentSnippets063',
-        '''
+    buildTests('testCommentSnippets063', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void r(var v) {
   v.!1toUpperCase;
   assert(v is String);
   v.!2toUpperCase;
-}''',
-        <String>["1-toUpperCase", "2+toUpperCase"]);
+}''', <String>["1-toUpperCase", "2+toUpperCase"]);
 
-    buildTests(
-        'testCommentSnippets064',
-        '''
+    buildTests('testCommentSnippets064', '''
 class Spline {
   Line c;
   Spline a() {
@@ -552,24 +404,21 @@
   Spline h() {
     return null;
   }
-}''',
-        <String>[
-          "1+a",
-          "2+b",
-          "1-g",
-          "2-h",
-          "3+b",
-          "4+c",
-          "5+a",
-          "6+c",
-          "7+g",
-          "8+j",
-          "9+h"
-        ]);
+}''', <String>[
+      "1+a",
+      "2+b",
+      "1-g",
+      "2-h",
+      "3+b",
+      "4+c",
+      "5+a",
+      "6+c",
+      "7+g",
+      "8+j",
+      "9+h"
+    ]);
 
-    buildTests(
-        'testCommentSnippets065',
-        '''
+    buildTests('testCommentSnippets065', '''
 class Spline {
   Line c;
   Spline a() {
@@ -591,12 +440,9 @@
   Spline h() {
     return null;
   }
-}''',
-        <String>["1+a"]);
+}''', <String>["1+a"]);
 
-    buildTests(
-        'testCommentSnippets066',
-        '''
+    buildTests('testCommentSnippets066', '''
 class Spline {
   Line c;
   Spline a() {
@@ -618,12 +464,9 @@
   Spline h() {
     return null;
   }
-}''',
-        <String>["1+b"]);
+}''', <String>["1+b"]);
 
-    buildTests(
-        'testCommentSnippets067',
-        '''
+    buildTests('testCommentSnippets067', '''
 class Spline {
   Line c;
   Spline a() {
@@ -645,12 +488,9 @@
   Spline h() {
     return null;
   }
-}''',
-        <String>["1+b"]);
+}''', <String>["1+b"]);
 
-    buildTests(
-        'testCommentSnippets068',
-        '''
+    buildTests('testCommentSnippets068', '''
 class Spline {
   Line c;
   Spline a() {
@@ -672,12 +512,9 @@
   Spline h() {
     return null;
   }
-}''',
-        <String>["1+c"]);
+}''', <String>["1+c"]);
 
-    buildTests(
-        'testCommentSnippets069',
-        '''
+    buildTests('testCommentSnippets069', '''
 class Spline {
   Line c;
   Spline a() {
@@ -699,12 +536,9 @@
   Spline h() {
     return null;
   }
-}''',
-        <String>["1+c"]);
+}''', <String>["1+c"]);
 
-    buildTests(
-        'testCommentSnippets070',
-        '''
+    buildTests('testCommentSnippets070', '''
 class Spline {
   Line c;
   Spline a() {
@@ -726,12 +560,9 @@
   Spline h() {
     return null;
   }
-}''',
-        <String>["1+b"]);
+}''', <String>["1+b"]);
 
-    buildTests(
-        'testCommentSnippets072',
-        '''
+    buildTests('testCommentSnippets072', '''
 class X {
   int _p;
   set p(int x) => _p = x;
@@ -739,12 +570,9 @@
 f() {
   X x = new X();
   x.!1p = 3;
-}''',
-        <String>["1+p"]);
+}''', <String>["1+p"]);
 
-    buildTests(
-        'testCommentSnippets073',
-        '''
+    buildTests('testCommentSnippets073', '''
 class X {
   m() {
     JSON.stri!1;
@@ -753,41 +581,28 @@
 }
 class JSON {
   static stringify() {}
-}''',
-        <String>["1+stringify"]);
+}''', <String>["1+stringify"]);
 
-    buildTests(
-        'testCommentSnippets074',
-        '''
+    buildTests('testCommentSnippets074', '''
 class X {
   m() {
     _x!1
   }
   _x1(){}
-}''',
-        <String>["1+_x1"]);
+}''', <String>["1+_x1"]);
 
-    buildTests(
-        'testCommentSnippets075',
-        '''
-p(x)=>0;var E;f(q)=>!1p(!2E);''',
-        <String>["1+p", "2+E"]);
+    buildTests('testCommentSnippets075', '''
+p(x)=>0;var E;f(q)=>!1p(!2E);''', <String>["1+p", "2+E"]);
 
-    buildTests(
-        'testCommentSnippets076',
-        '''
+    buildTests('testCommentSnippets076', '''
 class Map<K,V>{}class List<E>{}class int{}main() {var m=new Map<Lis!1t<Map<int,in!2t>>,List<!3int>>();}''',
         <String>["1+List", "2+int", "3+int"]);
 
-    buildTests(
-        'testCommentSnippets076a',
-        '''
+    buildTests('testCommentSnippets076a', '''
 class Map<K,V>{}class List<E>{}class int{}main() {var m=new Map<Lis!1t<Map<int,in!2t>>,List<!3>>();}''',
         <String>["1+List", "2+int", "3+int"]);
 
-    buildTests(
-        'testCommentSnippets077',
-        '''
+    buildTests('testCommentSnippets077', '''
 class FileMode {
   static const READ = const FileMode._internal(0);
   static const WRITE = const FileMode._internal(1);
@@ -801,30 +616,23 @@
   factory File(String path) => null;
   factory File.fromPath(Path path) => null;
 }
-f() => new Fil!1''',
-        <String>[
-          "1+File",
-          "1+File.fromPath",
-          "1+FileMode",
-          "1+FileMode._internal1",
-          "1+FileMode._internal"
-        ]);
+f() => new Fil!1''', <String>[
+      "1+File",
+      "1+File.fromPath",
+      "1+FileMode",
+      "1+FileMode._internal1",
+      "1+FileMode._internal"
+    ]);
 
-    buildTests(
-        'testCommentSnippets078',
-        '''
+    buildTests('testCommentSnippets078', '''
 class Map{static from()=>null;clear(){}}void main() { Map.!1 }''',
         <String>["1+from", "1-clear"]); // static method, instance method
 
-    buildTests(
-        'testCommentSnippets079',
-        '''
+    buildTests('testCommentSnippets079', '''
 class Map{static from()=>null;clear(){}}void main() { Map s; s.!1 }''',
         <String>["1-from", "1+clear"]); // static method, instance method
 
-    buildTests(
-        'testCommentSnippets080',
-        '''
+    buildTests('testCommentSnippets080', '''
 class RuntimeError{var message;}void main() { RuntimeError.!1 }''',
         <String>["1-message"]); // field
 
@@ -835,37 +643,23 @@
         <String>["1-Object"],
         failingTests: '1');
 
-    buildTests(
-        'testCommentSnippets082',
-        '''
+    buildTests('testCommentSnippets082', '''
         class HttpRequest {}
         class HttpResponse {}
         main() {
           var v = (HttpRequest req, HttpResp!1)
-        }''',
-        <String>["1+HttpResponse"]);
+        }''', <String>["1+HttpResponse"]);
 
-    buildTests(
-        'testCommentSnippets083',
-        '''
-main() {(.!1)}''',
-        <String>["1-toString"]);
+    buildTests('testCommentSnippets083', '''
+main() {(.!1)}''', <String>["1-toString"]);
 
-    buildTests(
-        'testCommentSnippets083a',
-        '''
-main() { .!1 }''',
-        <String>["1-toString"]);
+    buildTests('testCommentSnippets083a', '''
+main() { .!1 }''', <String>["1-toString"]);
 
-    buildTests(
-        'testCommentSnippets083b',
-        '''
-main() { null.!1 }''',
-        <String>["1+toString"]);
+    buildTests('testCommentSnippets083b', '''
+main() { null.!1 }''', <String>["1+toString"]);
 
-    buildTests(
-        'testCommentSnippets085',
-        '''
+    buildTests('testCommentSnippets085', '''
 class List{}class Map{}class Z extends List with !1Ma!2p {}''',
         <String>["1+List", "1+Map", "2+Map", "2-List"]);
 
@@ -876,15 +670,11 @@
         <String>["1+xy", "2+f", "2-xy"],
         failingTests: '2');
 
-    buildTests(
-        'testCommentSnippets087',
-        '''
+    buildTests('testCommentSnippets087', '''
 class Map{}class Q extends Object with !1Map {}''',
         <String>["1+Map", "1-HashMap"]);
 
-    buildTests(
-        'testCommentSnippets088',
-        '''
+    buildTests('testCommentSnippets088', '''
 class A {
   int f;
   B m(){}
@@ -896,8 +686,7 @@
 class Z {
   B q;
   f() {q.!1}
-}''',
-        <String>["1+f", "1+m"]); // f->num, m()->A
+}''', <String>["1+f", "1+m"]); // f->num, m()->A
 
     buildTests(
         'testCommentSnippets089',
@@ -954,19 +743,13 @@
         ],
         failingTests: '123');
 
-    buildTests(
-        'testCommentSnippets090',
-        '''
-class X { f() { var a = 'x'; a.!1 }}''',
-        <String>["1+length"]);
+    buildTests('testCommentSnippets090', '''
+class X { f() { var a = 'x'; a.!1 }}''', <String>["1+length"]);
   }
 
   void buildCompletionTests() {
-    buildTests(
-        'testCompletion_alias_field',
-        '''
-typedef int fnint(int k); fn!1int x;''',
-        <String>["1+fnint"]);
+    buildTests('testCompletion_alias_field', '''
+typedef int fnint(int k); fn!1int x;''', <String>["1+fnint"]);
 
     buildTests(
         'testCompletion_annotation_argumentList',
@@ -1014,75 +797,55 @@
         ],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_annotation_type_inClass_withoutMember',
-        '''
+    buildTests('testCompletion_annotation_type_inClass_withoutMember', '''
 class AAA {
   const AAA();
 }
 
 class C {
   @A!1
-}''',
-        <String>["1+AAA" /*":" + ProposalKind.CONSTRUCTOR*/]);
+}''', <String>["1+AAA" /*":" + ProposalKind.CONSTRUCTOR*/]);
 
-    buildTests(
-        'testCompletion_argument_typeName',
-        '''
+    buildTests('testCompletion_argument_typeName', '''
 class Enum {
   static Enum FOO = new Enum();
 }
 f(Enum e) {}
 main() {
   f(En!1);
-}''',
-        <String>["1+Enum"]);
+}''', <String>["1+Enum"]);
 
-    buildTests(
-        'testCompletion_arguments_ignoreEmpty',
-        '''
+    buildTests('testCompletion_arguments_ignoreEmpty', '''
 class A {
   test() {}
 }
 main(A a) {
   a.test(!1);
-}''',
-        <String>["1-test"]);
+}''', <String>["1-test"]);
 
-    buildTests(
-        'testCompletion_as_asIdentifierPrefix',
-        '''
+    buildTests('testCompletion_as_asIdentifierPrefix', '''
 main(p) {
   var asVisible;
   var v = as!1;
-}''',
-        <String>["1+asVisible"]);
+}''', <String>["1+asVisible"]);
 
-    buildTests(
-        'testCompletion_as_asPrefixedIdentifierStart',
-        '''
+    buildTests('testCompletion_as_asPrefixedIdentifierStart', '''
 class A {
   var asVisible;
 }
 
 main(A p) {
   var v = p.as!1;
-}''',
-        <String>["1+asVisible"]);
+}''', <String>["1+asVisible"]);
 
-    buildTests(
-        'testCompletion_as_incompleteStatement',
-        '''
+    buildTests('testCompletion_as_incompleteStatement', '''
 class MyClass {}
 main(p) {
   var justSomeVar;
   var v = p as !1
-}''',
-        <String>["1+MyClass", "1-justSomeVar"]);
+}''', <String>["1+MyClass", "1-justSomeVar"]);
 
-    buildTests(
-        'testCompletion_cascade',
-        '''
+    buildTests('testCompletion_cascade', '''
 class A {
   aaa() {}
 }
@@ -1090,42 +853,29 @@
 
 main(A a) {
   a..!1 aaa();
-}''',
-        <String>["1+aaa", "1-main"]);
+}''', <String>["1+aaa", "1-main"]);
 
-    buildTests(
-        'testCompletion_combinator_afterComma',
-        '''
+    buildTests('testCompletion_combinator_afterComma', '''
 import 'dart:math' show cos, !1;''',
         <String>["1+PI", "1+sin", "1+Random", "1-String"]);
 
-    buildTests(
-        'testCompletion_combinator_ended',
-        '''
+    buildTests('testCompletion_combinator_ended', '''
 import 'dart:math' show !1;"''',
         <String>["1+PI", "1+sin", "1+Random", "1-String"]);
 
-    buildTests(
-        'testCompletion_combinator_export',
-        '''
+    buildTests('testCompletion_combinator_export', '''
 export 'dart:math' show !1;"''',
         <String>["1+PI", "1+sin", "1+Random", "1-String"]);
 
-    buildTests(
-        'testCompletion_combinator_hide',
-        '''
+    buildTests('testCompletion_combinator_hide', '''
 import 'dart:math' hide !1;"''',
         <String>["1+PI", "1+sin", "1+Random", "1-String"]);
 
-    buildTests(
-        'testCompletion_combinator_notEnded',
-        '''
+    buildTests('testCompletion_combinator_notEnded', '''
 import 'dart:math' show !1"''',
         <String>["1+PI", "1+sin", "1+Random", "1-String"]);
 
-    buildTests(
-        'testCompletion_combinator_usePrefix',
-        '''
+    buildTests('testCompletion_combinator_usePrefix', '''
 import 'dart:math' show s!1"''',
         <String>["1+sin", "1+sqrt", "1-cos", "1-String"]);
 
@@ -1159,21 +909,16 @@
         <String>["1+Random:ARGUMENT_LIST"],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_dartDoc_reference_forClass',
-        '''
+    buildTests('testCompletion_dartDoc_reference_forClass', '''
 /**
  * [int!1]
  * [method!2]
  */
 class AAA {
   methodA() {}
-}''',
-        <String>["1+int", "1-method", "2+methodA", "2-int"]);
+}''', <String>["1+int", "1-method", "2+methodA", "2-int"]);
 
-    buildTests(
-        'testCompletion_dartDoc_reference_forConstructor',
-        '''
+    buildTests('testCompletion_dartDoc_reference_forConstructor', '''
 class A {
   /**
    * [aa!1]
@@ -1182,8 +927,7 @@
    */
   A.named(aaa, bbb) {}
   methodA() {}
-}''',
-        <String>["1+aaa", "1-bbb", "2+int", "2-double", "3+methodA"]);
+}''', <String>["1+aaa", "1-bbb", "2+int", "2-double", "3+methodA"]);
 
     buildTests(
         'testCompletion_dartDoc_reference_forFunction',
@@ -1227,9 +971,7 @@
         ],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_dartDoc_reference_forMethod',
-        '''
+    buildTests('testCompletion_dartDoc_reference_forMethod', '''
 class A {
   /**
    * [aa!1]
@@ -1238,20 +980,17 @@
    */
   methodA(aaa, bbb) {}
   methodB() {}
-}''',
-        <String>[
-          "1+aaa",
-          "1-bbb",
-          "2+int",
-          "2-double",
-          "3+methodA",
-          "3+methodB",
-          "3-int"
-        ]);
+}''', <String>[
+      "1+aaa",
+      "1-bbb",
+      "2+int",
+      "2-double",
+      "3+methodA",
+      "3+methodB",
+      "3-int"
+    ]);
 
-    buildTests(
-        'testCompletion_dartDoc_reference_incomplete',
-        '''
+    buildTests('testCompletion_dartDoc_reference_incomplete', '''
 /**
  * [doubl!1 some text
  * other text
@@ -1265,66 +1004,53 @@
 /**
  * [!3] some text
  */
-class C {}''',
-        <String>[
-          "1+double",
-          "1-int",
-          "2+int",
-          "2+String",
-          "3+int",
-          "3+String"
-        ]);
+class C {}''', <String>[
+      "1+double",
+      "1-int",
+      "2+int",
+      "2+String",
+      "3+int",
+      "3+String"
+    ]);
 
-    buildTests(
-        'testCompletion_double_inFractionPart',
-        '''
+    buildTests('testCompletion_double_inFractionPart', '''
 main() {
   1.0!1
-}''',
-        <String>["1-abs", "1-main"]);
+}''', <String>["1-abs", "1-main"]);
 
-    buildTests(
-        'testCompletion_enum',
-        '''
+    buildTests('testCompletion_enum', '''
 enum MyEnum {A, B, C}
 main() {
   MyEnum.!1;
-}''',
-        <String>["1+values", "1+A", "1+B", "1+C"]);
+}''', <String>["1+values", "1+A", "1+B", "1+C"]);
 
-    buildTests(
-        'testCompletion_exactPrefix_hasHigherRelevance',
-        '''
+    buildTests('testCompletion_exactPrefix_hasHigherRelevance', '''
 var STR;
 main(p) {
   var str;
   str!1;
   STR!2;
   Str!3;
-}''',
-        <String>[
-          "1+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/,
-          "1+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/,
-          "2+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/,
-          "2+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/,
-          "3+String" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/,
-          "3+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/,
-          "3+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/
-        ]);
+}''', <String>[
+      "1+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/,
+      "1+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/,
+      "2+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/,
+      "2+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/,
+      "3+String" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/,
+      "3+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/,
+      "3+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/
+    ]);
 
-    buildTests(
-        'testCompletion_export_dart',
-        '''
+    buildTests('testCompletion_export_dart', '''
 import 'dart:math
 import 'dart:_chrome
 import 'dart:_collection.dev
-export 'dart:!1''',
-        <String>[
-          "1+dart:core",
-          "1+dart:math",
-          "1-dart:_chrome",
-          "1-dart:_collection.dev"
-        ]);
+export 'dart:!1''', <String>[
+      "1+dart:core",
+      "1+dart:math",
+      "1-dart:_chrome",
+      "1-dart:_collection.dev"
+    ]);
 
     buildTests(
         'testCompletion_export_noStringLiteral_noSemicolon',
@@ -1335,21 +1061,15 @@
         <String>["1+'dart:!';", "1+'package:!';"],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_forStmt_vars',
-        '''
+    buildTests('testCompletion_forStmt_vars', '''
 class int{}class Foo { mth() { for (in!1t i = 0; i!2 < 5; i!3++); }}''',
         <String>["1+int", "2+i", "3+i"]);
 
-    buildTests(
-        'testCompletion_function',
-        '''
+    buildTests('testCompletion_function', '''
 class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1) => a.compareTo(b)); }}''',
         <String>["1+String"]);
 
-    buildTests(
-        'testCompletion_function_partial',
-        '''
+    buildTests('testCompletion_function_partial', '''
 class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1)); }}''',
         <String>["1+String"]);
 
@@ -1363,59 +1083,32 @@
         <String>["1+x1", "2-x2"],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_ifStmt_field1',
-        '''
-class Foo { int myField = 7; mth() { if (!1) {}}}''',
-        <String>["1+myField"]);
+    buildTests('testCompletion_ifStmt_field1', '''
+class Foo { int myField = 7; mth() { if (!1) {}}}''', <String>["1+myField"]);
 
-    buildTests(
-        'testCompletion_ifStmt_field1a',
-        '''
-class Foo { int myField = 7; mth() { if (!1) }}''',
-        <String>["1+myField"]);
+    buildTests('testCompletion_ifStmt_field1a', '''
+class Foo { int myField = 7; mth() { if (!1) }}''', <String>["1+myField"]);
 
-    buildTests(
-        'testCompletion_ifStmt_field2',
-        '''
-class Foo { int myField = 7; mth() { if (m!1) {}}}''',
-        <String>["1+myField"]);
+    buildTests('testCompletion_ifStmt_field2', '''
+class Foo { int myField = 7; mth() { if (m!1) {}}}''', <String>["1+myField"]);
 
-    buildTests(
-        'testCompletion_ifStmt_field2a',
-        '''
-class Foo { int myField = 7; mth() { if (m!1) }}''',
-        <String>["1+myField"]);
+    buildTests('testCompletion_ifStmt_field2a', '''
+class Foo { int myField = 7; mth() { if (m!1) }}''', <String>["1+myField"]);
 
-    buildTests(
-        'testCompletion_ifStmt_field2b',
-        '''
-class Foo { myField = 7; mth() { if (m!1) {}}}''',
-        <String>["1+myField"]);
+    buildTests('testCompletion_ifStmt_field2b', '''
+class Foo { myField = 7; mth() { if (m!1) {}}}''', <String>["1+myField"]);
 
-    buildTests(
-        'testCompletion_ifStmt_localVar',
-        '''
-class Foo { mth() { int value = 7; if (v!1) {}}}''',
-        <String>["1+value"]);
+    buildTests('testCompletion_ifStmt_localVar', '''
+class Foo { mth() { int value = 7; if (v!1) {}}}''', <String>["1+value"]);
 
-    buildTests(
-        'testCompletion_ifStmt_localVara',
-        '''
-class Foo { mth() { value = 7; if (v!1) {}}}''',
-        <String>["1-value"]);
+    buildTests('testCompletion_ifStmt_localVara', '''
+class Foo { mth() { value = 7; if (v!1) {}}}''', <String>["1-value"]);
 
-    buildTests(
-        'testCompletion_ifStmt_topLevelVar',
-        '''
-int topValue = 7; class Foo { mth() { if (t!1) {}}}''',
-        <String>["1+topValue"]);
+    buildTests('testCompletion_ifStmt_topLevelVar', '''
+int topValue = 7; class Foo { mth() { if (t!1) {}}}''', <String>["1+topValue"]);
 
-    buildTests(
-        'testCompletion_ifStmt_topLevelVara',
-        '''
-topValue = 7; class Foo { mth() { if (t!1) {}}}''',
-        <String>["1+topValue"]);
+    buildTests('testCompletion_ifStmt_topLevelVara', '''
+topValue = 7; class Foo { mth() { if (t!1) {}}}''', <String>["1+topValue"]);
 
     buildTests(
         'testCompletion_ifStmt_unionType_nonStrict',
@@ -1453,33 +1146,24 @@
         <String>["1+a", "1-x", "1-y"],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_import',
-        '''
-import '!1';''',
-        <String>["1+dart:!", "1+package:!"]);
+    buildTests('testCompletion_import', '''
+import '!1';''', <String>["1+dart:!", "1+package:!"]);
 
-    buildTests(
-        'testCompletion_import_dart',
-        '''
+    buildTests('testCompletion_import_dart', '''
 import 'dart:math
 import 'dart:_chrome
 import 'dart:_collection.dev
-import 'dart:!1''',
-        <String>[
-          "1+dart:core",
-          "1+dart:math",
-          "1-dart:_chrome",
-          "1-dart:_collection.dev"
-        ]);
+import 'dart:!1''', <String>[
+      "1+dart:core",
+      "1+dart:math",
+      "1-dart:_chrome",
+      "1-dart:_collection.dev"
+    ]);
 
-    buildTests(
-        'testCompletion_import_hasStringLiteral_noSemicolon',
-        '''
+    buildTests('testCompletion_import_hasStringLiteral_noSemicolon', '''
 import '!1'
 
-class A {}''',
-        <String>["1+dart:!", "1+package:!"]);
+class A {}''', <String>["1+dart:!", "1+package:!"]);
 
     buildTests(
         'testCompletion_import_noSpace',
@@ -1504,25 +1188,19 @@
         <String>["1+'dart:!';", "1+'package:!';"],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_incompleteClassMember',
-        '''
+    buildTests('testCompletion_incompleteClassMember', '''
 class A {
   Str!1
   final f = null;
-}''',
-        <String>["1+String", "1-bool"]);
+}''', <String>["1+String", "1-bool"]);
 
-    buildTests(
-        'testCompletion_incompleteClosure_parameterType',
-        '''
+    buildTests('testCompletion_incompleteClosure_parameterType', '''
 f1(cb(String s)) {}
 f2(String s) {}
 main() {
   f1((Str!1));
   f2((Str!2));
-}''',
-        <String>["1+String", "1-bool", "2+String", "2-bool"]);
+}''', <String>["1+String", "1-bool", "2+String", "2-bool"]);
 
     buildTests(
         'testCompletion_inPeriodPeriod',
@@ -1536,16 +1214,13 @@
         failingTests: '123');
 
     // no checks, but no exceptions
-    buildTests(
-        'testCompletion_instanceCreation_unresolved',
-        '''
+    buildTests('testCompletion_instanceCreation_unresolved', '''
 class A {
 }
 main() {
   new NoSuchClass(!1);
   new A.noSuchConstructor(!2);
-}''',
-        <String>["1+int", "2+int"]);
+}''', <String>["1+int", "2+int"]);
 
     buildTests(
         'testCompletion_import_lib',
@@ -1555,9 +1230,7 @@
         extraFiles: <String, String>{"/my_lib.dart": ""},
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_is',
-        '''
+    buildTests('testCompletion_is', '''
 class MyClass {}
 main(p) {
   var isVariable;
@@ -1565,29 +1238,23 @@
   var v1 = p is MyCla!2;
   var v2 = p is !3;
   var v2 = p is!4;
-}''',
-        <String>[
-          "1+MyClass",
-          "2+MyClass",
-          "3+MyClass",
-          "3-v1",
-          "4+is",
-          "4-isVariable"
-        ]);
+}''', <String>[
+      "1+MyClass",
+      "2+MyClass",
+      "3+MyClass",
+      "3-v1",
+      "4+is",
+      "4-isVariable"
+    ]);
 
-    buildTests(
-        'testCompletion_is_asIdentifierStart',
-        '''
+    buildTests('testCompletion_is_asIdentifierStart', '''
 main(p) {
   var isVisible;
   var v1 = is!1;
   var v2 = is!2
-}''',
-        <String>["1+isVisible", "2+isVisible"]);
+}''', <String>["1+isVisible", "2+isVisible"]);
 
-    buildTests(
-        'testCompletion_is_asPrefixedIdentifierStart',
-        '''
+    buildTests('testCompletion_is_asPrefixedIdentifierStart', '''
 class A {
   var isVisible;
 }
@@ -1595,56 +1262,37 @@
 main(A p) {
   var v1 = p.is!1;
   var v2 = p.is!2
-}''',
-        <String>["1+isVisible", "2+isVisible"]);
+}''', <String>["1+isVisible", "2+isVisible"]);
 
-    buildTests(
-        'testCompletion_is_incompleteStatement1',
-        '''
+    buildTests('testCompletion_is_incompleteStatement1', '''
 class MyClass {}
 main(p) {
   var justSomeVar;
   var v = p is !1
-}''',
-        <String>["1+MyClass", "1-justSomeVar"]);
+}''', <String>["1+MyClass", "1-justSomeVar"]);
 
-    buildTests(
-        'testCompletion_is_incompleteStatement2',
-        '''
+    buildTests('testCompletion_is_incompleteStatement2', '''
 class MyClass {}
 main(p) {
   var isVariable;
   var v = p is!1
-}''',
-        <String>["1+is", "1-isVariable"]);
+}''', <String>["1+is", "1-isVariable"]);
 
-    buildTests(
-        'testCompletion_keyword_in',
-        '''
-class Foo { int input = 7; mth() { if (in!1) {}}}''',
-        <String>["1+input"]);
+    buildTests('testCompletion_keyword_in', '''
+class Foo { int input = 7; mth() { if (in!1) {}}}''', <String>["1+input"]);
 
-    buildTests(
-        'testCompletion_keyword_syntheticIdentifier',
-        '''
+    buildTests('testCompletion_keyword_syntheticIdentifier', '''
 main() {
   var caseVar;
   var otherVar;
   var v = case!1
-}''',
-        <String>["1+caseVar", "1-otherVar"]);
+}''', <String>["1+caseVar", "1-otherVar"]);
 
-    buildTests(
-        'testCompletion_libraryIdentifier_atEOF',
-        '''
-library int.!1''',
-        <String>["1-parse", "1-bool"]);
+    buildTests('testCompletion_libraryIdentifier_atEOF', '''
+library int.!1''', <String>["1-parse", "1-bool"]);
 
-    buildTests(
-        'testCompletion_libraryIdentifier_notEOF',
-        '''
-library int.!1''',
-        <String>["1-parse", "1-bool"]);
+    buildTests('testCompletion_libraryIdentifier_notEOF', '''
+library int.!1''', <String>["1-parse", "1-bool"]);
 
     buildTests(
         'testCompletion_methodRef_asArg_incompatibleFunctionType',
@@ -1681,26 +1329,20 @@
         ],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_methodRef_asArg_ofFunctionType',
-        '''
+    buildTests('testCompletion_methodRef_asArg_ofFunctionType', '''
 foo( f(int p) ) {}
 class Functions {
   static int myFunc(int p) {}
 }
 main(p) {
   foo(Functions.!1);
-}''',
-        <String>[
-          "1+myFunc" /*":" + ProposalKind.METHOD*/,
-          "1+myFunc" /*":" + ProposalKind.METHOD_NAME*/
-        ]);
+}''', <String>[
+      "1+myFunc" /*":" + ProposalKind.METHOD*/,
+      "1+myFunc" /*":" + ProposalKind.METHOD_NAME*/
+    ]);
 
-    buildTests(
-        'testCompletion_namedArgument_alreadyUsed',
-        '''
-func({foo}) {} main() { func(foo: 0, fo!1); }''',
-        <String>["1-foo"]);
+    buildTests('testCompletion_namedArgument_alreadyUsed', '''
+func({foo}) {} main() { func(foo: 0, fo!1); }''', <String>["1-foo"]);
 
     buildTests(
         'testCompletion_namedArgument_constructor',
@@ -1726,39 +1368,25 @@
         <String>["1+foo", "1-bar"],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_namedArgument_notNamed',
-        '''
-func([foo]) {} main() { func(fo!1); }''',
-        <String>["1-foo"]);
+    buildTests('testCompletion_namedArgument_notNamed', '''
+func([foo]) {} main() { func(fo!1); }''', <String>["1-foo"]);
 
-    buildTests(
-        'testCompletion_namedArgument_unresolvedFunction',
-        '''
-main() { func(fo!1); }''',
-        <String>["1-foo"]);
+    buildTests('testCompletion_namedArgument_unresolvedFunction', '''
+main() { func(fo!1); }''', <String>["1-foo"]);
 
-    buildTests(
-        'testCompletion_newMemberType1',
-        '''
+    buildTests('testCompletion_newMemberType1', '''
 class Collection{}class List extends Collection{}class Foo { !1 }''',
         <String>["1+Collection", "1+List"]);
 
-    buildTests(
-        'testCompletion_newMemberType2',
-        '''
+    buildTests('testCompletion_newMemberType2', '''
 class Collection{}class List extends Collection{}class Foo {!1}''',
         <String>["1+Collection", "1+List"]);
 
-    buildTests(
-        'testCompletion_newMemberType3',
-        '''
+    buildTests('testCompletion_newMemberType3', '''
 class Collection{}class List extends Collection{}class Foo {L!1}''',
         <String>["1-Collection", "1+List"]);
 
-    buildTests(
-        'testCompletion_newMemberType4',
-        '''
+    buildTests('testCompletion_newMemberType4', '''
 class Collection{}class List extends Collection{}class Foo {C!1}''',
         <String>["1+Collection", "1-List"]);
 
@@ -1818,45 +1446,34 @@
         ],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_privateElement_sameLibrary_constructor',
-        '''
+    buildTests('testCompletion_privateElement_sameLibrary_constructor', '''
 class A {
   A._c();
   A.c();
 }
 main() {
   new A.!1
-}''',
-        <String>["1+_c", "1+c"]);
+}''', <String>["1+_c", "1+c"]);
 
-    buildTests(
-        'testCompletion_privateElement_sameLibrary_member',
-        '''
+    buildTests('testCompletion_privateElement_sameLibrary_member', '''
 class A {
   _m() {}
   m() {}
 }
 main(A a) {
   a.!1
-}''',
-        <String>["1+_m", "1+m"]);
+}''', <String>["1+_m", "1+m"]);
 
-    buildTests(
-        'testCompletion_propertyAccess_whenClassTarget',
-        '''
+    buildTests('testCompletion_propertyAccess_whenClassTarget', '''
 class A {
   static int FIELD;
   int field;
 }
 main() {
   A.!1
-}''',
-        <String>["1+FIELD", "1-field"]);
+}''', <String>["1+FIELD", "1-field"]);
 
-    buildTests(
-        'testCompletion_propertyAccess_whenClassTarget_excludeSuper',
-        '''
+    buildTests('testCompletion_propertyAccess_whenClassTarget_excludeSuper', '''
 class A {
   static int FIELD_A;
   static int methodA() {}
@@ -1867,12 +1484,9 @@
 }
 main() {
   B.!1;
-}''',
-        <String>["1+FIELD_B", "1-FIELD_A", "1+methodB", "1-methodA"]);
+}''', <String>["1+FIELD_B", "1-FIELD_A", "1+methodB", "1-methodA"]);
 
-    buildTests(
-        'testCompletion_propertyAccess_whenInstanceTarget',
-        '''
+    buildTests('testCompletion_propertyAccess_whenInstanceTarget', '''
 class A {
   static int FIELD;
   int fieldA;
@@ -1886,30 +1500,19 @@
 main(B b, C c) {
   b.a.!1;
   c.!2;
-}''',
-        <String>["1-FIELD", "1+fieldA", "2+fieldC", "2+fieldA"]);
+}''', <String>["1-FIELD", "1+fieldA", "2+fieldC", "2+fieldA"]);
 
-    buildTests(
-        'testCompletion_return_withIdentifierPrefix',
-        '''
-f() { var vvv = 42; return v!1 }''',
-        <String>["1+vvv"]);
+    buildTests('testCompletion_return_withIdentifierPrefix', '''
+f() { var vvv = 42; return v!1 }''', <String>["1+vvv"]);
 
-    buildTests(
-        'testCompletion_return_withoutExpression',
-        '''
-f() { var vvv = 42; return !1 }''',
-        <String>["1+vvv"]);
+    buildTests('testCompletion_return_withoutExpression', '''
+f() { var vvv = 42; return !1 }''', <String>["1+vvv"]);
 
-    buildTests(
-        'testCompletion_staticField1',
-        '''
+    buildTests('testCompletion_staticField1', '''
 class num{}class Sunflower {static final n!2um MAX_D = 300;nu!3m xc, yc;Sun!4flower() {x!Xc = y!Yc = MA!1 }}''',
         <String>["1+MAX_D", "X+xc", "Y+yc", "2+num", "3+num", "4+Sunflower"]);
 
-    buildTests(
-        'testCompletion_super_superType',
-        '''
+    buildTests('testCompletion_super_superType', '''
 class A {
   var fa;
   ma() {}
@@ -1920,8 +1523,7 @@
   main() {
     super.!1
   }
-}''',
-        <String>["1+fa", "1-fb", "1+ma", "1-mb"]);
+}''', <String>["1+fa", "1-fb", "1+ma", "1-mb"]);
 
     buildTests(
         'testCompletion_superConstructorInvocation_noNamePrefix',
@@ -1997,21 +1599,16 @@
         <String>["1-toString"],
         failingTests: '1');
 
-    buildTests(
-        'testCompletion_this_OK_inConstructorBody',
-        '''
+    buildTests('testCompletion_this_OK_inConstructorBody', '''
 class A {
   var f;
   m() {}
   A() {
     this.!1;
   }
-}''',
-        <String>["1+f", "1+m"]);
+}''', <String>["1+f", "1+m"]);
 
-    buildTests(
-        'testCompletion_this_OK_localAndSuper',
-        '''
+    buildTests('testCompletion_this_OK_localAndSuper', '''
 class A {
   var fa;
   ma() {}
@@ -2022,34 +1619,25 @@
   main() {
     this.!1
   }
-}''',
-        <String>["1+fa", "1+fb", "1+ma", "1+mb"]);
+}''', <String>["1+fa", "1+fb", "1+ma", "1+mb"]);
 
-    buildTests(
-        'testCompletion_topLevelField_init2',
-        '''
+    buildTests('testCompletion_topLevelField_init2', '''
 class DateTime{static var JUN;}final num M = Dat!1eTime.JUN;''',
         <String>["1+DateTime", "1-void"]);
 
-    buildTests(
-        'testCompletion_while',
-        '''
-class Foo { int boo = 7; mth() { while (b!1) {} }}''',
-        <String>["1+boo"]);
+    buildTests('testCompletion_while', '''
+class Foo { int boo = 7; mth() { while (b!1) {} }}''', <String>["1+boo"]);
   }
 
   void buildLibraryTests() {
     Map<String, String> sources = new HashMap<String, String>();
 
-    buildTests(
-        'test_export_ignoreIfThisLibraryExports',
-        '''
+    buildTests('test_export_ignoreIfThisLibraryExports', '''
 export 'dart:math';
 libFunction() {};
 main() {
   !1
-}''',
-        <String>["1-cos", "1+libFunction"]);
+}''', <String>["1-cos", "1+libFunction"]);
 
     sources.clear();
     sources["/lib.dart"] = '''
@@ -2172,23 +1760,20 @@
 
     // TODO Include corelib analysis
     // Resolving dart:html takes between 2.5s and 30s; json, about 0.12s
-    buildTests(
-        'testLibrary004',
-        '''
+    buildTests('testLibrary004', '''
             library foo;
             import 'dart:convert' as json;
             class JsonDecoderX{}
             f1() {var x=new json.!1}
             f2() {var x=new json.JsonDe!2}
-            f3() {var x=new json.JsonDecoder!3}''',
-        <String>[
-          "1+JsonDecoder",
-          "1-JsonDecoderX",
-          "2+JsonDecoder",
-          "2-JsonDecoderX",
-          "3+JsonDecoder",
-          "3-JsonDecoderX"
-        ]);
+            f3() {var x=new json.JsonDecoder!3}''', <String>[
+      "1+JsonDecoder",
+      "1-JsonDecoderX",
+      "2+JsonDecoder",
+      "2-JsonDecoderX",
+      "3+JsonDecoder",
+      "3-JsonDecoderX"
+    ]);
 
     // TODO Enable after type propagation is implemented. Not yet.
     // TODO Include corelib analysis
@@ -2323,38 +1908,29 @@
   }
 
   void buildNumberedTests() {
-    buildTests(
-        'test001',
-        '''
+    buildTests('test001', '''
 void r1(var v) {
   v.!1toString!2().!3hash!4Code
-}''',
-        <String>[
-          "1+toString",
-          "1-==",
-          "2+toString",
-          "3+hashCode",
-          "3+toString",
-          "4+hashCode",
-          "4-toString"
-        ]);
+}''', <String>[
+      "1+toString",
+      "1-==",
+      "2+toString",
+      "3+hashCode",
+      "3+toString",
+      "4+hashCode",
+      "4-toString"
+    ]);
 
-    buildTests(
-        'test002',
-        '''
+    buildTests('test002', '''
 void r2(var vim) {
   v!1.toString()
-}''',
-        <String>["1+vim"]);
+}''', <String>["1+vim"]);
 
-    buildTests(
-        'test003',
-        '''
+    buildTests('test003', '''
 class A {
   int a() => 3;
   int b() => this.!1a();
-}''',
-        <String>["1+a"]);
+}''', <String>["1+a"]);
 
     buildTests(
         'test004',
@@ -2402,21 +1978,15 @@
         ],
         failingTests: '1');
 
-    buildTests(
-        'test006',
-        '''
+    buildTests('test006', '''
 void r2(var vim, {va: 2, b: 3}) {
   v!1.toString()
-}''',
-        <String>["1+va", "1-b"]);
+}''', <String>["1+va", "1-b"]);
 
-    buildTests(
-        'test007',
-        '''
+    buildTests('test007', '''
 void r2(var vim, [va: 2, b: 3]) {
   v!1.toString()
-}''',
-        <String>["1+va", "1-b"]);
+}''', <String>["1+va", "1-b"]);
 
     // keywords
     buildTests(
@@ -2633,15 +2203,12 @@
     buildTests('test018', '''!1part !2of foo;''', <String>["1+part", "2+of"],
         failingTests: '12');
 
-    buildTests(
-        'test019',
-        '''
+    buildTests('test019', '''
 var truefalse = 0;
 var falsetrue = 1;
 main() {
   var foo = true!1
-}''',
-        <String>["1+true", "1+truefalse", "1-falsetrue"]);
+}''', <String>["1+true", "1+truefalse", "1-falsetrue"]);
 
     buildTests('test020', '''var x = null.!1''', <String>["1+toString"]);
 
@@ -2649,9 +2216,7 @@
 
     buildTests('test022', '''var x = .!1;''', <String>["1-toString"]);
 
-    buildTests(
-        'test023',
-        '''
+    buildTests('test023', '''
 class Map{getKeys(){}}
 class X {
   static x1(Map m) {
@@ -2660,24 +2225,18 @@
   x2(Map m) {
     m.!2getKeys;
   }
-}''',
-        <String>["1+getKeys", "2+getKeys"]);
+}''', <String>["1+getKeys", "2+getKeys"]);
 
 // Note lack of semicolon following completion location
-    buildTests(
-        'test024',
-        '''
+    buildTests('test024', '''
 class List{factory List.from(Iterable other) {}}
 class F {
   f() {
     new List.!1
   }
-}''',
-        <String>["1+from"]);
+}''', <String>["1+from"]);
 
-    buildTests(
-        'test025',
-        '''
+    buildTests('test025', '''
 class R {
   static R _m;
   static R m;
@@ -2709,24 +2268,23 @@
     var g = R.!Em;
     var h = R.!Fg();
   }
-}''',
-        <String>[
-          "1+m",
-          "2+_m",
-          "3+g",
-          "4+m",
-          "5+_m",
-          "6+g",
-          "7-g",
-          "8-m",
-          "9-_m",
-          "A+_m",
-          "B+m",
-          "C+g",
-          "D+_m",
-          "E+m",
-          "F+g"
-        ]);
+}''', <String>[
+      "1+m",
+      "2+_m",
+      "3+g",
+      "4+m",
+      "5+_m",
+      "6+g",
+      "7-g",
+      "8-m",
+      "9-_m",
+      "A+_m",
+      "B+m",
+      "C+g",
+      "D+_m",
+      "E+m",
+      "F+g"
+    ]);
 
     buildTests('test026', '''var aBcD; var x=ab!1''', <String>["1+aBcD"]);
 
@@ -2744,9 +2302,7 @@
         '''class Caster {} m() {try {} on Cas!1ter catch (CastBlock) {!2}}''',
         <String>["1+Caster", "1-CastBlock", "2+Caster", "2+CastBlock"]);
 
-    buildTests(
-        'test032',
-        '''
+    buildTests('test032', '''
 const ONE = 1;
 const ICHI = 10;
 const UKSI = 100;
@@ -2760,17 +2316,16 @@
     case ONE!1: return;
     default: return;
   }
-}''',
-        <String>[
-          "1+ONE",
-          "1-UKSI",
-          "2+EIN",
-          "2-ICHI",
-          "3+ICHI",
-          "3+UKSI",
-          "3+EIN",
-          "3+ONE"
-        ]);
+}''', <String>[
+      "1+ONE",
+      "1-UKSI",
+      "2+EIN",
+      "2-ICHI",
+      "3+ICHI",
+      "3+UKSI",
+      "3+EIN",
+      "3+ONE"
+    ]);
 
     buildTests(
         'test033',
diff --git a/pkg/analysis_server/test/context_manager_test.dart b/pkg/analysis_server/test/context_manager_test.dart
index 26aaa31..d39d8fc 100644
--- a/pkg/analysis_server/test/context_manager_test.dart
+++ b/pkg/analysis_server/test/context_manager_test.dart
@@ -100,9 +100,7 @@
     newFile([embedderSrcPath, 'part.dart']);
 
     // Setup _embedder.yaml.
-    newFile(
-        [libPath, '_embedder.yaml'],
-        r'''
+    newFile([libPath, '_embedder.yaml'], r'''
 embedded_libs:
   "dart:foobar": "../embedder/entry.dart"
   "dart:typed_data": "../embedder/src/part"
@@ -125,9 +123,7 @@
     expect(sourceFactory.forUri('dart:typed_data'), isNull);
 
     // Add .packages file that introduces a dependency with embedded libs.
-    newFile(
-        [projPath, '.packages'],
-        r'''
+    newFile([projPath, '.packages'], r'''
 test_pack:lib/''');
 
     await pumpEventQueue();
@@ -151,17 +147,13 @@
     String sdkExtSrcPath = newFolder([projPath, 'sdk_ext', 'src']);
     newFile([sdkExtSrcPath, 'part.dart']);
     // Setup _embedder.yaml.
-    newFile(
-        [libPath, '_embedder.yaml'],
-        r'''
+    newFile([libPath, '_embedder.yaml'], r'''
 embedded_libs:
   "dart:foobar": "../sdk_ext/entry.dart"
   "dart:typed_data": "../sdk_ext/src/part"
   ''');
     // Setup .packages file
-    newFile(
-        [projPath, '.packages'],
-        r'''
+    newFile([projPath, '.packages'], r'''
 test_pack:lib/''');
     // Setup context.
 
@@ -385,17 +377,13 @@
     String sdkExtSrcPath = newFolder([projPath, 'sdk_ext', 'src']);
     newFile([sdkExtSrcPath, 'part.dart']);
     // Setup sdk extension mapping.
-    newFile(
-        [libPath, '_sdkext'],
-        r'''
+    newFile([libPath, '_sdkext'], r'''
 {
   "dart:foobar": "../sdk_ext/entry.dart"
 }
 ''');
     // Setup .packages file
-    newFile(
-        [projPath, '.packages'],
-        r'''
+    newFile([projPath, '.packages'], r'''
 test_pack:lib/''');
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
@@ -1850,9 +1838,7 @@
 
   test_analysis_options_file_delete() async {
     // Setup analysis options
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 embedded_libs:
   "dart:foobar": "../sdk_ext/entry.dart"
 analyzer:
@@ -1890,9 +1876,7 @@
     // flag from the embedder.yaml file.
     // Setup _embedder.yaml.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
-    newFile(
-        [libPath, '_embedder.yaml'],
-        r'''
+    newFile([libPath, '_embedder.yaml'], r'''
 analyzer:
   strong-mode: true
   errors:
@@ -1903,15 +1887,11 @@
 ''');
 
     // Setup .packages file
-    newFile(
-        [projPath, '.packages'],
-        r'''
+    newFile([projPath, '.packages'], r'''
 test_pack:lib/''');
 
     // Setup analysis options
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   language:
     enableStrictCallChecks: true
@@ -1953,14 +1933,10 @@
     String sdkExtSrcPath = newFolder([projPath, 'sdk_ext', 'src']);
     newFile([sdkExtSrcPath, 'part.dart']);
     // Setup analysis options file which includes another options file.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 include: other_options.yaml
 ''');
-    newFile(
-        [projPath, 'other_options.yaml'],
-        r'''
+    newFile([projPath, 'other_options.yaml'], r'''
 analyzer:
   language:
     enableStrictCallChecks: true
@@ -1990,9 +1966,7 @@
     newFile([sdkExtSrcPath, 'part.dart']);
     // Setup package
     String booLibPosixPath = '/my/pkg/boo/lib';
-    newFile(
-        [booLibPosixPath, 'other_options.yaml'],
-        r'''
+    newFile([booLibPosixPath, 'other_options.yaml'], r'''
 analyzer:
   language:
     enableStrictCallChecks: true
@@ -2005,9 +1979,7 @@
     // Setup analysis options file which includes another options file.
     newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME],
         'boo:$booLibPosixPath\n');
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 include: package:boo/other_options.yaml
 ''');
     // Setup context.
@@ -2029,9 +2001,7 @@
     String sdkExtSrcPath = newFolder([projPath, 'sdk_ext', 'src']);
     newFile([sdkExtSrcPath, 'part.dart']);
     // Setup analysis options file with ignore list.
-    String optionsFilePath = newFile(
-        [projPath, optionsFileName],
-        r'''
+    String optionsFilePath = newFile([projPath, optionsFileName], r'''
 ;
 ''');
     // Setup context.
@@ -2069,9 +2039,7 @@
     List<int> bytes = new SummaryBuilder([], null, true).build();
     newFileFromBytes([projPath, 'sdk.ds'], bytes);
     // Setup _embedder.yaml.
-    newFile(
-        [libPath, '_embedder.yaml'],
-        r'''
+    newFile([libPath, '_embedder.yaml'], r'''
 embedded_libs:
   "dart:foobar": "../sdk_ext/entry.dart"
 analyzer:
@@ -2085,15 +2053,11 @@
     - avoid_as
 ''');
     // Setup .packages file
-    newFile(
-        [projPath, '.packages'],
-        r'''
+    newFile([projPath, '.packages'], r'''
 test_pack:lib/''');
 
     // Setup analysis options
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   exclude:
     - 'test/**'
@@ -2153,9 +2117,7 @@
 
   test_error_filter_analysis_option() async {
     // Create files.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   errors:
     unused_local_variable: ignore
@@ -2170,9 +2132,7 @@
 
   test_error_filter_analysis_option_multiple_filters() async {
     // Create files.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   errors:
     invalid_assignment: ignore
@@ -2190,9 +2150,7 @@
 
   test_error_filter_analysis_option_synonyms() async {
     // Create files.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   errors:
     unused_local_variable: ignore
@@ -2208,9 +2166,7 @@
 
   test_error_filter_analysis_option_unpsecified() async {
     // Create files.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
 #  errors:
 #    unused_local_variable: ignore
@@ -2230,18 +2186,14 @@
     // After a few other changes, the test now times out on my machine, so I'm
     // disabling it in order to prevent it from being flaky.
     fail('Test times out');
-    var file = resourceProvider.newFile(
-        '$projPath/bin/test.dart',
-        r'''
+    var file = resourceProvider.newFile('$projPath/bin/test.dart', r'''
 main() {
   var paths = <int>[];
   var names = <String>[];
   paths.addAll(names.map((s) => s.length));
 }
 ''');
-    resourceProvider.newFile(
-        '$projPath/$optionsFileName',
-        r'''
+    resourceProvider.newFile('$projPath/$optionsFileName', r'''
 analyzer:
   strong-mode: false
 ''');
@@ -2258,9 +2210,7 @@
     expect(result.errors, isEmpty);
 
     // Update the options file - turn on 'strong-mode'.
-    resourceProvider.updateFile(
-        '$projPath/$optionsFileName',
-        r'''
+    resourceProvider.updateFile('$projPath/$optionsFileName', r'''
 analyzer:
   strong-mode: true
 ''');
@@ -2290,9 +2240,7 @@
     String sdkExtSrcPath = newFolder([projPath, 'sdk_ext', 'src']);
     newFile([sdkExtSrcPath, 'part.dart']);
     // Setup analysis options file with ignore list.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   exclude:
     - lib/nope.dart
@@ -2316,23 +2264,17 @@
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
-    newFile(
-        [libPath, 'pubspec.yaml'],
-        r'''
+    newFile([libPath, 'pubspec.yaml'], r'''
 name: foobar
 ''');
     String otherLibPath = newFolder([projPath, 'other_lib']);
     newFile([otherLibPath, 'entry.dart']);
-    newFile(
-        [otherLibPath, 'pubspec.yaml'],
-        r'''
+    newFile([otherLibPath, 'pubspec.yaml'], r'''
 name: other_lib
 ''');
     // Setup analysis options file with ignore list that ignores the 'other_lib'
     // directory by name.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   exclude:
     - 'other_lib'
@@ -2352,23 +2294,17 @@
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
-    newFile(
-        [libPath, 'pubspec.yaml'],
-        r'''
+    newFile([libPath, 'pubspec.yaml'], r'''
   name: foobar
   ''');
     String otherLibPath = newFolder([projPath, 'other_lib']);
     newFile([otherLibPath, 'entry.dart']);
-    newFile(
-        [otherLibPath, 'pubspec.yaml'],
-        r'''
+    newFile([otherLibPath, 'pubspec.yaml'], r'''
   name: other_lib
   ''');
     // Setup analysis options file with ignore list that ignores 'other_lib'
     // and all descendants.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   exclude:
     - 'other_lib/**'
@@ -2389,23 +2325,17 @@
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
-    newFile(
-        [libPath, 'pubspec.yaml'],
-        r'''
+    newFile([libPath, 'pubspec.yaml'], r'''
 name: foobar
 ''');
     String otherLibPath = newFolder([projPath, 'other_lib']);
     newFile([otherLibPath, 'entry.dart']);
-    newFile(
-        [otherLibPath, 'pubspec.yaml'],
-        r'''
+    newFile([otherLibPath, 'pubspec.yaml'], r'''
 name: other_lib
 ''');
     // Setup analysis options file with ignore list that ignores 'other_lib'
     // and all immediate children.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   exclude:
     - 'other_lib/*'
@@ -2428,9 +2358,7 @@
     // create files
     resourceProvider.newFile(projectPubspec, 'name: project');
     resourceProvider.newFile(examplePubspec, 'name: example');
-    newFile(
-        [project, optionsFileName],
-        r'''
+    newFile([project, optionsFileName], r'''
 analyzer:
   exclude:
     - 'example'
@@ -2464,9 +2392,7 @@
     // create files
     resourceProvider.newFile(aPubspec, 'name: aaa');
     resourceProvider.newFile(cPubspec, 'name: ccc');
-    newFile(
-        [a, optionsFileName],
-        r'''
+    newFile([a, optionsFileName], r'''
 analyzer:
   exclude:
     - 'b**'
@@ -2493,9 +2419,7 @@
 
   test_strong_mode_analysis_option() async {
     // Create files.
-    newFile(
-        [projPath, optionsFileName],
-        r'''
+    newFile([projPath, optionsFileName], r'''
 analyzer:
   strong-mode: true
 ''');
diff --git a/pkg/analysis_server/test/domain_analysis_test.dart b/pkg/analysis_server/test/domain_analysis_test.dart
index cd25fb0..172fd22 100644
--- a/pkg/analysis_server/test/domain_analysis_test.dart
+++ b/pkg/analysis_server/test/domain_analysis_test.dart
@@ -390,9 +390,7 @@
   test_setRoots_packages() {
     // prepare package
     String pkgFile = '/packages/pkgA/libA.dart';
-    resourceProvider.newFile(
-        pkgFile,
-        '''
+    resourceProvider.newFile(pkgFile, '''
 library lib_a;
 class A {}
 ''');
@@ -680,9 +678,7 @@
 
   test_afterAnalysis_packageFile_external() async {
     String pkgFile = '/packages/pkgA/lib/libA.dart';
-    resourceProvider.newFile(
-        pkgFile,
-        '''
+    resourceProvider.newFile(pkgFile, '''
 library lib_a;
 class A {}
 ''');
@@ -711,15 +707,11 @@
     String pkgB = '/pkgA';
     String pkgFileA = '$pkgA/lib/libA.dart';
     String pkgFileB = '$pkgA/lib/libB.dart';
-    resourceProvider.newFile(
-        pkgFileA,
-        '''
+    resourceProvider.newFile(pkgFileA, '''
 library lib_a;
 class A {}
 ''');
-    resourceProvider.newFile(
-        pkgFileB,
-        '''
+    resourceProvider.newFile(pkgFileB, '''
 import 'package:pkgA/libA.dart';
 main() {
   new A();
@@ -749,9 +741,7 @@
 
   test_afterAnalysis_packageFile_notUsed() async {
     String pkgFile = '/packages/pkgA/lib/libA.dart';
-    resourceProvider.newFile(
-        pkgFile,
-        '''
+    resourceProvider.newFile(pkgFile, '''
 library lib_a;
 class A {}
 ''');
diff --git a/pkg/analysis_server/test/domain_completion_test.dart b/pkg/analysis_server/test/domain_completion_test.dart
index d69cab3..3415c64 100644
--- a/pkg/analysis_server/test/domain_completion_test.dart
+++ b/pkg/analysis_server/test/domain_completion_test.dart
@@ -488,9 +488,7 @@
   }
 
   test_inDartDoc_reference1() async {
-    addFile(
-        '/testA.dart',
-        '''
+    addFile('/testA.dart', '''
   part of libA;
   foo(bar) => 0;''');
     addTestFile('''
@@ -654,9 +652,7 @@
   }
 
   test_partFile() {
-    addFile(
-        '/project/bin/testA.dart',
-        '''
+    addFile('/project/bin/testA.dart', '''
       library libA;
       part "$testFile";
       import 'dart:html';
@@ -676,9 +672,7 @@
   }
 
   test_partFile2() {
-    addFile(
-        '/testA.dart',
-        '''
+    addFile('/testA.dart', '''
       part of libA;
       class A { }''');
     addTestFile('''
diff --git a/pkg/analysis_server/test/edit/assists_test.dart b/pkg/analysis_server/test/edit/assists_test.dart
index ac270f9..5eecb57 100644
--- a/pkg/analysis_server/test/edit/assists_test.dart
+++ b/pkg/analysis_server/test/edit/assists_test.dart
@@ -79,9 +79,7 @@
 ''');
     await waitForTasksFinished();
     await prepareAssists('v =');
-    _assertHasChange(
-        'Remove type annotation',
-        '''
+    _assertHasChange('Remove type annotation', '''
 main() {
   var v = 1;
 }
@@ -96,9 +94,7 @@
 ''');
     await waitForTasksFinished();
     await prepareAssists('v =');
-    _assertHasChange(
-        'Split variable declaration',
-        '''
+    _assertHasChange('Split variable declaration', '''
 main() {
   int v;
   v = 1;
@@ -117,9 +113,7 @@
     int offset = findOffset('  print(1)');
     int length = findOffset('}') - offset;
     await prepareAssistsAt(offset, length);
-    _assertHasChange(
-        "Surround with 'if'",
-        '''
+    _assertHasChange("Surround with 'if'", '''
 main() {
   if (condition) {
     print(1);
diff --git a/pkg/analysis_server/test/edit/postfix_completion_test.dart b/pkg/analysis_server/test/edit/postfix_completion_test.dart
index ebb8a6d..136b816 100644
--- a/pkg/analysis_server/test/edit/postfix_completion_test.dart
+++ b/pkg/analysis_server/test/edit/postfix_completion_test.dart
@@ -39,9 +39,7 @@
 ''');
     await waitForTasksFinished();
     await _prepareCompletion('.for', atStart: true);
-    _assertHasChange(
-        'Expand .for',
-        '''
+    _assertHasChange('Expand .for', '''
 main() {
   for (var value in []) {
     /*caret*/
diff --git a/pkg/analysis_server/test/edit/refactoring_test.dart b/pkg/analysis_server/test/edit/refactoring_test.dart
index 93f15e7..6c84f57 100644
--- a/pkg/analysis_server/test/edit/refactoring_test.dart
+++ b/pkg/analysis_server/test/edit/refactoring_test.dart
@@ -44,8 +44,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return _sendConvertRequest('test =>');
-    },
-        '''
+    }, '''
 int test() => 42;
 main() {
   var a = 1 + test();
@@ -94,8 +93,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return _sendConvertRequest('test => 2');
-    },
-        '''
+    }, '''
 class A {
   int test() => 1;
 }
@@ -141,8 +139,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return _sendConvertRequest('test() =>');
-    },
-        '''
+    }, '''
 int get test => 42;
 main() {
   var a = 1 + test;
@@ -208,8 +205,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return _sendConvertRequest('test() => 2');
-    },
-        '''
+    }, '''
 class A {
   int get test => 1;
 }
@@ -277,9 +273,7 @@
   test_analysis_onlyOneFile() async {
     shouldWaitForFullAnalysis = false;
     String otherFile = '$testFolder/other.dart';
-    addFile(
-        otherFile,
-        r'''
+    addFile(otherFile, r'''
 foo(int myName) {}
 ''');
     addTestFile('''
@@ -326,8 +320,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendStringRequest('1 + 2', 'res', true);
-    },
-        '''
+    }, '''
 main() {
   var res = 1 + 2;
   print(res);
@@ -345,8 +338,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendStringSuffixRequest('1 + 2', '); // marker', 'res', false);
-    },
-        '''
+    }, '''
 main() {
   print(1 + 2);
   var res = 1 + 2;
@@ -384,9 +376,7 @@
     assertResultProblemsWarning(result.optionsProblems,
         'Variable name should start with a lowercase letter.');
     // ...but there is still a change
-    assertTestRefactoringResult(
-        result,
-        '''
+    assertTestRefactoringResult(result, '''
 main() {
   var Name = 1 + 2;
   print(Name);
@@ -517,9 +507,7 @@
 }
 ''');
     _setOffsetLengthForString('1 + 2');
-    return assertSuccessfulRefactoring(
-        _computeChange,
-        '''
+    return assertSuccessfulRefactoring(_computeChange, '''
 main() {
   print(res());
   print(res());
@@ -539,9 +527,7 @@
 }
 ''');
     _setOffsetLengthForString('a + b');
-    return assertSuccessfulRefactoring(
-        _computeChange,
-        '''
+    return assertSuccessfulRefactoring(_computeChange, '''
 main() {
   int a = 1;
   int b = 2;
@@ -571,9 +557,7 @@
       parameters[1].type = 'num';
       parameters.insert(0, parameters.removeLast());
       options.parameters = parameters;
-      return assertSuccessfulRefactoring(
-          _sendExtractRequest,
-          '''
+      return assertSuccessfulRefactoring(_sendExtractRequest, '''
 main() {
   int a = 1;
   int b = 2;
@@ -652,9 +636,7 @@
 }
 ''');
     _setOffsetLengthForStartEnd();
-    return assertSuccessfulRefactoring(
-        _computeChange,
-        '''
+    return assertSuccessfulRefactoring(_computeChange, '''
 main() {
   int a = 1;
   int b = 2;
@@ -780,13 +762,9 @@
   }
 
   Future test_convertMethodToGetter_hasElement() {
-    return assertHasKind(
-        '''
+    return assertHasKind('''
 int getValue() => 42;
-''',
-        'getValue',
-        RefactoringKind.CONVERT_METHOD_TO_GETTER,
-        true);
+''', 'getValue', RefactoringKind.CONVERT_METHOD_TO_GETTER, true);
   }
 
   Future test_extractLocal() async {
@@ -802,130 +780,108 @@
   }
 
   Future test_rename_hasElement_class() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 class Test {}
 main() {
   Test v;
 }
-''',
-        'Test v');
+''', 'Test v');
   }
 
   Future test_rename_hasElement_constructor() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 class A {
   A.test() {}
 }
 main() {
   new A.test();
 }
-''',
-        'test();');
+''', 'test();');
   }
 
   Future test_rename_hasElement_function() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 main() {
   test();
 }
 test() {}
-''',
-        'test();');
+''', 'test();');
   }
 
   Future test_rename_hasElement_importElement_directive() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 import 'dart:math' as math;
 main() {
   math.PI;
 }
-''',
-        'import ');
+''', 'import ');
   }
 
   Future test_rename_hasElement_importElement_prefixDecl() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 import 'dart:math' as math;
 main() {
   math.PI;
 }
-''',
-        'math;');
+''', 'math;');
   }
 
   Future test_rename_hasElement_importElement_prefixRef() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 import 'dart:async' as test;
 import 'dart:math' as test;
 main() {
   test.PI;
 }
-''',
-        'test.PI;');
+''', 'test.PI;');
   }
 
   Future test_rename_hasElement_instanceGetter() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 class A {
   get test => 0;
 }
 main(A a) {
   a.test;
 }
-''',
-        'test;');
+''', 'test;');
   }
 
   Future test_rename_hasElement_instanceSetter() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 class A {
   set test(x) {}
 }
 main(A a) {
   a.test = 2;
 }
-''',
-        'test = 2;');
+''', 'test = 2;');
   }
 
   Future test_rename_hasElement_library() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 library my.lib;
-''',
-        'library ');
+''', 'library ');
   }
 
   Future test_rename_hasElement_localVariable() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 main() {
   int test = 0;
   print(test);
 }
-''',
-        'test = 0;');
+''', 'test = 0;');
   }
 
   Future test_rename_hasElement_method() {
-    return assertHasRenameRefactoring(
-        '''
+    return assertHasRenameRefactoring('''
 class A {
   test() {}
 }
 main(A a) {
   a.test();
 }
-''',
-        'test();');
+''', 'test();');
   }
 
   Future test_rename_noElement() async {
@@ -945,9 +901,7 @@
   test_analysis_onlyOneFile() async {
     shouldWaitForFullAnalysis = false;
     String otherFile = '$testFolder/other.dart';
-    addFile(
-        otherFile,
-        r'''
+    addFile(otherFile, r'''
 foo(int p) {}
 ''');
     addTestFile('''
@@ -1006,8 +960,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return _sendInlineRequest('test + 2');
-    },
-        '''
+    }, '''
 main() {
   int a = 42 + 2;
   print(42);
@@ -1114,8 +1067,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return _sendInlineRequest('test(int p)');
-    },
-        '''
+    }, '''
 class A {
   int f;
   main() {
@@ -1140,8 +1092,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return _sendInlineRequest('test(a');
-    },
-        '''
+    }, '''
 main() {
   print(1 + 2);
   print(10 + 20);
@@ -1163,8 +1114,7 @@
     options.inlineAll = false;
     return assertSuccessfulRefactoring(() {
       return _sendInlineRequest('test(10,');
-    },
-        '''
+    }, '''
 test(a, b) {
   print(a + b);
 }
@@ -1203,8 +1153,7 @@
     _setOptions('/project/test.dart');
     return assertSuccessfulRefactoring(() {
       return _sendMoveRequest();
-    },
-        '''
+    }, '''
 import 'dart:math';
 import 'bin/lib.dart';
 ''');
@@ -1276,8 +1225,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('Test {', 'NewName');
-    },
-        '''
+    }, '''
 class NewName {
   NewName() {}
   NewName.named() {}
@@ -1338,9 +1286,7 @@
       assertResultProblemsWarning(result.optionsProblems,
           'Class name should start with an uppercase letter.');
       // ...but there is still a change
-      assertTestRefactoringResult(
-          result,
-          '''
+      assertTestRefactoringResult(result, '''
 class newName {}
 main() {
   newName v;
@@ -1353,9 +1299,7 @@
       }).then((result) {
         assertResultProblemsOK(result);
         // ...and there is a new change
-        assertTestRefactoringResult(
-            result,
-            '''
+        assertTestRefactoringResult(result, '''
 class NewName {}
 main() {
   NewName v;
@@ -1377,8 +1321,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test = 0', 'newName');
-    },
-        '''
+    }, '''
 class A {
   var newName = 0;
   A(this.newName);
@@ -1401,8 +1344,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test);', 'newName');
-    },
-        '''
+    }, '''
 class A {
   var newName = 0;
   A(this.newName);
@@ -1425,8 +1367,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test: 42', 'newName');
-    },
-        '''
+    }, '''
 class A {
   final int newName;
   A({this.newName: 0});
@@ -1448,8 +1389,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test =>', 'newName');
-    },
-        '''
+    }, '''
 class A {
   get newName => 0;
   main() {
@@ -1473,8 +1413,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test() {}', 'newName');
-    },
-        '''
+    }, '''
 class A {
   newName() {}
   main() {
@@ -1525,8 +1464,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test = 0', 'newName');
-    },
-        '''
+    }, '''
 class A {
   set newName(x) {}
   main() {
@@ -1547,8 +1485,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('B;', 'newName');
-    },
-        '''
+    }, '''
 class A {
   A() = B.newName;
 }
@@ -1569,8 +1506,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test();', 'newName');
-    },
-        '''
+    }, '''
 class A {
   A.newName() {}
 }
@@ -1591,8 +1527,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('A();', 'newName');
-    },
-        '''
+    }, '''
 class A {
   A.newName() {}
 }
@@ -1613,8 +1548,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('new A();', 'newName');
-    },
-        '''
+    }, '''
 class A {
   A.newName() {}
 }
@@ -1651,8 +1585,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test() {}', 'newName');
-    },
-        '''
+    }, '''
 newName() {}
 main() {
   newName();
@@ -1672,8 +1605,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest("import 'dart:async';", 'new_name');
-    },
-        '''
+    }, '''
 import 'dart:math';
 import 'dart:async' as new_name;
 main() {
@@ -1694,8 +1626,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest("import 'dart:async' as test;", '');
-    },
-        '''
+    }, '''
 import 'dart:math' as test;
 import 'dart:async';
 main() {
@@ -1723,8 +1654,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('library aaa', 'my.new_name');
-    },
-        '''
+    }, '''
 library my.new_name;
 ''');
   }
@@ -1735,8 +1665,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('aaa', 'my.new_name');
-    },
-        '''
+    }, '''
 library my.new_name;
 ''');
   }
@@ -1747,16 +1676,13 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('.bbb', 'my.new_name');
-    },
-        '''
+    }, '''
 library my.new_name;
 ''');
   }
 
   test_library_partOfDirective() {
-    addFile(
-        '$testFolder/my_lib.dart',
-        '''
+    addFile('$testFolder/my_lib.dart', '''
 library aaa.bbb.ccc;
 part 'test.dart';
 ''');
@@ -1765,8 +1691,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('aaa.bb', 'my.new_name');
-    },
-        '''
+    }, '''
 part of my.new_name;
 ''');
   }
@@ -1782,8 +1707,7 @@
 ''');
     return assertSuccessfulRefactoring(() {
       return sendRenameRequest('test = 1', 'newName');
-    },
-        '''
+    }, '''
 main() {
   int newName = 0;
   newName = 1;
diff --git a/pkg/analysis_server/test/edit/sort_members_test.dart b/pkg/analysis_server/test/edit/sort_members_test.dart
index ff05f8f..da59fe9 100644
--- a/pkg/analysis_server/test/edit/sort_members_test.dart
+++ b/pkg/analysis_server/test/edit/sort_members_test.dart
@@ -181,9 +181,7 @@
   }
 
   test_OK_genericFunctionType() async {
-    addFile(
-        projectPath + '/analysis_options.yaml',
-        '''
+    addFile(projectPath + '/analysis_options.yaml', '''
 analyzer:
   strong-mode: true
 ''');
diff --git a/pkg/analysis_server/test/edit/statement_completion_test.dart b/pkg/analysis_server/test/edit/statement_completion_test.dart
index c1db24a..fca2ae7 100644
--- a/pkg/analysis_server/test/edit/statement_completion_test.dart
+++ b/pkg/analysis_server/test/edit/statement_completion_test.dart
@@ -39,9 +39,7 @@
 ''');
     await waitForTasksFinished();
     await _prepareCompletion('v = 1;', atStart: true);
-    _assertHasChange(
-        'Insert a newline at the end of the current line',
-        '''
+    _assertHasChange('Insert a newline at the end of the current line', '''
 main() {
   int v = 1;
   /*caret*/
@@ -57,9 +55,7 @@
 ''');
     await waitForTasksFinished();
     await _prepareCompletion('v = 1;', atEnd: true);
-    _assertHasChange(
-        'Insert a newline at the end of the current line',
-        '''
+    _assertHasChange('Insert a newline at the end of the current line', '''
 main() {
   int v = 1;
   /*caret*/
diff --git a/pkg/analysis_server/test/integration/analysis/analysis_options_test.dart b/pkg/analysis_server/test/integration/analysis/analysis_options_test.dart
index 4d07ff3..e437193 100644
--- a/pkg/analysis_server/test/integration/analysis/analysis_options_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/analysis_options_test.dart
@@ -25,9 +25,7 @@
     fail('test timeout expected - #28868');
 
     String options = sourcePath(AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
-    writeFile(
-        options,
-        '''
+    writeFile(options, '''
 linter:
   rules:
     - camel_case_typo # :)
@@ -58,9 +56,7 @@
     fail('test timeout expected - #28868');
 
     String options = sourcePath(AnalysisEngine.ANALYSIS_OPTIONS_FILE);
-    writeFile(
-        options,
-        '''
+    writeFile(options, '''
 linter:
   rules:
     - camel_case_typo # :)
diff --git a/pkg/analysis_server/test/integration/analysis/error_test.dart b/pkg/analysis_server/test/integration/analysis/error_test.dart
index 6cb0288..1c32caa 100644
--- a/pkg/analysis_server/test/integration/analysis/error_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/error_test.dart
@@ -20,9 +20,7 @@
     extends AbstractAnalysisServerIntegrationTest {
   test_detect_simple_error() {
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        '''
+    writeFile(pathname, '''
 main() {
   print(null) // parse error: missing ';'
 }''');
@@ -37,9 +35,7 @@
 
   test_super_mixins_disabled() async {
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        '''
+    writeFile(pathname, '''
 class Test extends Object with C {
   void foo() {}
 }
@@ -79,9 +75,7 @@
     //  ]
 
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        '''
+    writeFile(pathname, '''
 class Test extends Object with C {
   void foo() {}
 }
diff --git a/pkg/analysis_server/test/integration/analysis/lint_test.dart b/pkg/analysis_server/test/integration/analysis/lint_test.dart
index 97a9772..699b43b 100644
--- a/pkg/analysis_server/test/integration/analysis/lint_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/lint_test.dart
@@ -19,9 +19,7 @@
 class LintIntegrationTest extends AbstractAnalysisServerIntegrationTest {
   test_no_lints_when_not_specified() async {
     String source = sourcePath('test.dart');
-    writeFile(
-        source,
-        '''
+    writeFile(source, '''
 class abc { // lint: not CamelCase (should get ignored though)
 }''');
     standardAnalysisSetup();
@@ -34,18 +32,14 @@
   }
 
   test_simple_lint_newOptionsFile() async {
-    writeFile(
-        sourcePath(AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE),
-        '''
+    writeFile(sourcePath(AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE), '''
 linter:
   rules:
     - camel_case_types
 ''');
 
     String source = sourcePath('test.dart');
-    writeFile(
-        source,
-        '''
+    writeFile(source, '''
 class a { // lint: not CamelCase
 }''');
 
@@ -63,18 +57,14 @@
   }
 
   test_simple_lint_oldOptionsFile() async {
-    writeFile(
-        sourcePath(AnalysisEngine.ANALYSIS_OPTIONS_FILE),
-        '''
+    writeFile(sourcePath(AnalysisEngine.ANALYSIS_OPTIONS_FILE), '''
 linter:
   rules:
     - camel_case_types
 ''');
 
     String source = sourcePath('test.dart');
-    writeFile(
-        source,
-        '''
+    writeFile(source, '''
 class a { // lint: not CamelCase
 }''');
 
diff --git a/pkg/analysis_server/test/integration/analysis/set_analysis_roots_test.dart b/pkg/analysis_server/test/integration/analysis/set_analysis_roots_test.dart
index 8722418..f6c1d61 100644
--- a/pkg/analysis_server/test/integration/analysis/set_analysis_roots_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/set_analysis_roots_test.dart
@@ -17,9 +17,7 @@
 class SetAnalysisRootsTest extends AbstractAnalysisServerIntegrationTest {
   test_options() async {
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        '''
+    writeFile(pathname, '''
 class Foo {
   void bar() {}
 }
diff --git a/pkg/analysis_server/test/integration/analysis/set_general_subscriptions_test.dart b/pkg/analysis_server/test/integration/analysis/set_general_subscriptions_test.dart
index 231b226..9d49157 100644
--- a/pkg/analysis_server/test/integration/analysis/set_general_subscriptions_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/set_general_subscriptions_test.dart
@@ -19,9 +19,7 @@
     extends AbstractAnalysisServerIntegrationTest {
   test_options() async {
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        '''
+    writeFile(pathname, '''
 class Foo {
   void bar() {}
 }
diff --git a/pkg/analysis_server/test/integration/analysis/set_subscriptions_test.dart b/pkg/analysis_server/test/integration/analysis/set_subscriptions_test.dart
index 6181f8a..9524b4d 100644
--- a/pkg/analysis_server/test/integration/analysis/set_subscriptions_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/set_subscriptions_test.dart
@@ -17,9 +17,7 @@
 class SetSubscriptionsTest extends AbstractAnalysisServerIntegrationTest {
   test_subscriptions() async {
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        '''
+    writeFile(pathname, '''
 class Foo {
   void bar() {}
 }
diff --git a/pkg/analysis_server/test/integration/analysis/update_content_test.dart b/pkg/analysis_server/test/integration/analysis/update_content_test.dart
index c136942..0e307b3 100644
--- a/pkg/analysis_server/test/integration/analysis/update_content_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/update_content_test.dart
@@ -63,9 +63,7 @@
   @failingTest
   test_updateContent_multipleAdds() async {
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        r'''
+    writeFile(pathname, r'''
 class Person {
   String _name;
   Person(this._name);
diff --git a/pkg/analysis_server/test/integration/analysis/update_options_test.dart b/pkg/analysis_server/test/integration/analysis/update_options_test.dart
index 18e28dc..1172d78 100644
--- a/pkg/analysis_server/test/integration/analysis/update_options_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/update_options_test.dart
@@ -21,9 +21,7 @@
     // We fail after the first analysis.updateOptions - we should not see a hint
     // for the unused import (#28800).
     String pathname = sourcePath('test.dart');
-    writeFile(
-        pathname,
-        '''
+    writeFile(pathname, '''
 import 'dart:async'; // unused
 
 class Foo {
diff --git a/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart b/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart
index 545735b..1efd154 100644
--- a/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart
+++ b/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart
@@ -33,9 +33,7 @@
   }
 
   test_getSuggestions() async {
-    setTestSource(
-        'test.dart',
-        r'''
+    setTestSource('test.dart', r'''
 String test = '';
 main() {
   test.^
@@ -57,9 +55,7 @@
   }
 
   test_getSuggestions_onlyOverlay() async {
-    setTestSource(
-        'test.dart',
-        r'''
+    setTestSource('test.dart', r'''
 String test = '';
 main() {
   test.^
@@ -83,9 +79,7 @@
   }
 
   test_getSuggestions_onlyOverlay_noWait() async {
-    setTestSource(
-        'test.dart',
-        r'''
+    setTestSource('test.dart', r'''
 String test = '';
 main() {
   test.^
diff --git a/pkg/analysis_server/test/integration/server/set_subscriptions_test.dart b/pkg/analysis_server/test/integration/server/set_subscriptions_test.dart
index 48e7a9d..9cfd81c 100644
--- a/pkg/analysis_server/test/integration/server/set_subscriptions_test.dart
+++ b/pkg/analysis_server/test/integration/server/set_subscriptions_test.dart
@@ -39,9 +39,7 @@
     });
     return sendServerSetSubscriptions([]).then((_) {
       String pathname = sourcePath('test.dart');
-      writeFile(
-          pathname,
-          '''
+      writeFile(pathname, '''
 main() {
   var x;
 }''');
@@ -52,9 +50,7 @@
         expect(statusReceived, isFalse);
         return sendServerSetSubscriptions([ServerService.STATUS]).then((_) {
           // Tickle test.dart just in case analysis has already completed.
-          writeFile(
-              pathname,
-              '''
+          writeFile(pathname, '''
 main() {
   var y;
 }''');
diff --git a/pkg/analysis_server/test/integration/server/status_test.dart b/pkg/analysis_server/test/integration/server/status_test.dart
index 4081e97..72163c3 100644
--- a/pkg/analysis_server/test/integration/server/status_test.dart
+++ b/pkg/analysis_server/test/integration/server/status_test.dart
@@ -35,9 +35,7 @@
         }
       }
     });
-    writeFile(
-        sourcePath('test.dart'),
-        '''
+    writeFile(sourcePath('test.dart'), '''
 main() {
   var x;
 }''');
diff --git a/pkg/analysis_server/test/mock_sdk.dart b/pkg/analysis_server/test/mock_sdk.dart
index d1e180c..a071987 100644
--- a/pkg/analysis_server/test/mock_sdk.dart
+++ b/pkg/analysis_server/test/mock_sdk.dart
@@ -14,10 +14,8 @@
 import 'package:analyzer/src/summary/summary_file_builder.dart';
 
 class MockSdk implements DartSdk {
-  static const MockSdkLibrary LIB_CORE = const MockSdkLibrary(
-      'dart:core',
-      '/lib/core/core.dart',
-      '''
+  static const MockSdkLibrary LIB_CORE =
+      const MockSdkLibrary('dart:core', '/lib/core/core.dart', '''
 library dart.core;
 
 import 'dart:async';
@@ -167,10 +165,8 @@
 }
 ''');
 
-  static const MockSdkLibrary LIB_ASYNC = const MockSdkLibrary(
-      'dart:async',
-      '/lib/async/async.dart',
-      '''
+  static const MockSdkLibrary LIB_ASYNC =
+      const MockSdkLibrary('dart:async', '/lib/async/async.dart', '''
 library dart.async;
 
 import 'dart:math';
@@ -189,19 +185,15 @@
 ''');
 
   static const MockSdkLibrary LIB_COLLECTION = const MockSdkLibrary(
-      'dart:collection',
-      '/lib/collection/collection.dart',
-      '''
+      'dart:collection', '/lib/collection/collection.dart', '''
 library dart.collection;
 
 abstract class HashMap<K, V> implements Map<K, V> {}
 abstract class LinkedHashMap<K, V> implements Map<K, V> {}
 ''');
 
-  static const MockSdkLibrary LIB_CONVERT = const MockSdkLibrary(
-      'dart:convert',
-      '/lib/convert/convert.dart',
-      '''
+  static const MockSdkLibrary LIB_CONVERT =
+      const MockSdkLibrary('dart:convert', '/lib/convert/convert.dart', '''
 library dart.convert;
 
 import 'dart:async';
@@ -210,10 +202,8 @@
 class JsonDecoder extends Converter<String, Object> {}
 ''');
 
-  static const MockSdkLibrary LIB_MATH = const MockSdkLibrary(
-      'dart:math',
-      '/lib/math/math.dart',
-      '''
+  static const MockSdkLibrary LIB_MATH =
+      const MockSdkLibrary('dart:math', '/lib/math/math.dart', '''
 library dart.math;
 const double E = 2.718281828459045;
 const double PI = 3.1415926535897932;
@@ -232,17 +222,13 @@
 ''');
 
   static const MockSdkLibrary LIB_HTML = const MockSdkLibrary(
-      'dart:html',
-      '/lib/html/dartium/html_dartium.dart',
-      '''
+      'dart:html', '/lib/html/dartium/html_dartium.dart', '''
 library dart.html;
 class HtmlElement {}
 ''');
 
-  static const MockSdkLibrary LIB_INTERNAL = const MockSdkLibrary(
-      'dart:_internal',
-      '/lib/internal/internal.dart',
-      '''
+  static const MockSdkLibrary LIB_INTERNAL =
+      const MockSdkLibrary('dart:_internal', '/lib/internal/internal.dart', '''
 library dart._internal;
 external void printToConsole(String line);
 ''');
diff --git a/pkg/analysis_server/test/plugin/protocol_dart_test.dart b/pkg/analysis_server/test/plugin/protocol_dart_test.dart
index 3f666b4..b4e10a5 100644
--- a/pkg/analysis_server/test/plugin/protocol_dart_test.dart
+++ b/pkg/analysis_server/test/plugin/protocol_dart_test.dart
@@ -104,9 +104,7 @@
   }
 
   test_fromElement_CLASS() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 @deprecated
 abstract class _A {}
 class B<K, V> {}''');
@@ -145,9 +143,7 @@
   }
 
   test_fromElement_CONSTRUCTOR() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   const A.myConstructor(int a, [String b]);
 }''');
@@ -185,9 +181,7 @@
   }
 
   test_fromElement_ENUM() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
@@ -226,9 +220,7 @@
   }
 
   test_fromElement_ENUM_CONSTANT() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
@@ -316,9 +308,7 @@
   }
 
   test_fromElement_FIELD() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   static const myField = 42;
 }''');
@@ -342,9 +332,7 @@
   }
 
   test_fromElement_FUNCTION_TYPE_ALIAS() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 typedef int F<T>(String x);
 ''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
@@ -369,9 +357,7 @@
   }
 
   test_fromElement_GETTER() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   String get myGetter => 42;
 }''');
@@ -396,9 +382,7 @@
   }
 
   test_fromElement_LABEL() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 main() {
 myLabel:
   while (true) {
@@ -425,9 +409,7 @@
   }
 
   test_fromElement_METHOD() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   static List<String> myMethod(int a, {String b, int c}) {
     return null;
@@ -453,9 +435,7 @@
   }
 
   test_fromElement_SETTER() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   set mySetter(String x) {}
 }''');
diff --git a/pkg/analysis_server/test/search/element_references_test.dart b/pkg/analysis_server/test/search/element_references_test.dart
index 0756353..3e411f4 100644
--- a/pkg/analysis_server/test/search/element_references_test.dart
+++ b/pkg/analysis_server/test/search/element_references_test.dart
@@ -439,9 +439,7 @@
 ''');
     await findElementReferences('A {}', false);
     assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
-    expect(
-        getPathString(result.path),
-        '''
+    expect(getPathString(result.path), '''
 LOCAL_VARIABLE a
 CONSTRUCTOR named
 CLASS B
@@ -463,9 +461,7 @@
 ''');
     await findElementReferences('A {}', false);
     assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
-    expect(
-        getPathString(result.path),
-        '''
+    expect(getPathString(result.path), '''
 LOCAL_VARIABLE a
 CONSTRUCTOR
 CLASS B
@@ -485,9 +481,7 @@
 ''');
     await findElementReferences('A {}', false);
     assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
-    expect(
-        getPathString(result.path),
-        '''
+    expect(getPathString(result.path), '''
 LOCAL_VARIABLE a
 FUNCTION main
 COMPILATION_UNIT test.dart
diff --git a/pkg/analysis_server/test/search/type_hierarchy_test.dart b/pkg/analysis_server/test/search/type_hierarchy_test.dart
index cf4e480..c2d1547 100644
--- a/pkg/analysis_server/test/search/type_hierarchy_test.dart
+++ b/pkg/analysis_server/test/search/type_hierarchy_test.dart
@@ -165,9 +165,7 @@
   test_class_extends_fileAndPackageUris() async {
     // prepare packages
     String pkgFile = '/packages/pkgA/lib/libA.dart';
-    resourceProvider.newFile(
-        pkgFile,
-        '''
+    resourceProvider.newFile(pkgFile, '''
 library lib_a;
 class A {}
 class B extends A {}
@@ -698,9 +696,7 @@
   }
 
   test_member_method_private_differentLib() async {
-    addFile(
-        '$testFolder/lib.dart',
-        r'''
+    addFile('$testFolder/lib.dart', r'''
 import 'test.dart';
 class A {
   void _m() {}
diff --git a/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart
index 3f6193e..a5a3381 100644
--- a/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/arglist_contributor_test.dart
@@ -159,9 +159,7 @@
   }
 
   test_Annotation_imported_constructor_named_param() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library libA; class A { const A({int one, String two: 'defaultValue'}); }''');
     addTestSource('import "/libA.dart"; @A(^) main() { }');
     await computeSuggestions();
@@ -480,9 +478,7 @@
 
   test_ArgumentList_imported_function_0() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect() { }
@@ -498,9 +494,7 @@
 
   test_ArgumentList_imported_function_1() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(String arg) { }
@@ -516,9 +510,7 @@
 
   test_ArgumentList_imported_function_2() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(String arg1, int arg2) { }
@@ -534,9 +526,7 @@
 
   test_ArgumentList_imported_function_3() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(String arg1, int arg2, {bool arg3}) { }
@@ -552,9 +542,7 @@
 
   test_ArgumentList_imported_function_3a() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(String arg1, int arg2, {bool arg3}) { }
@@ -570,9 +558,7 @@
 
   test_ArgumentList_imported_function_3b() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(String arg1, int arg2, {bool arg3}) { }
@@ -588,9 +574,7 @@
 
   test_ArgumentList_imported_function_3c() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(String arg1, int arg2, {bool arg3}) { }
@@ -606,9 +590,7 @@
 
   test_ArgumentList_imported_function_3d() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       expect(String arg1, int arg2, {bool arg3}) { }
@@ -1005,9 +987,7 @@
 
   test_ArgumentList_local_method_0() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
@@ -1023,9 +1003,7 @@
 
   test_ArgumentList_local_method_2() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
       library A;
       bool hasLength(int expected) { }
       void baz() { }''');
diff --git a/pkg/analysis_server/test/services/completion/dart/combinator_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/combinator_contributor_test.dart
index c0d7674..aa5e2ae 100644
--- a/pkg/analysis_server/test/services/completion/dart/combinator_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/combinator_contributor_test.dart
@@ -36,23 +36,17 @@
 
   test_Combinator_hide() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
       library libAB;
       part '/partAB.dart';
       class A { }
       class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
       part of libAB;
       var T1;
       PB F1() => new PB();
       class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
       class C { }
       class D { }''');
     addTestSource('''
@@ -82,26 +76,20 @@
 
   test_Combinator_show() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
       library libAB;
       part '/partAB.dart';
       class A { }
       class B { }
       class _AB''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
       part of libAB;
       var T1;
       PB F1() => new PB();
       typedef PB2 F2(int blat);
       class Clz = Object with Object;
       class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
       class C { }
       class D { }''');
     addTestSource('''
diff --git a/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart b/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart
index 5ca78e1..2ee39fb 100644
--- a/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart
@@ -30,9 +30,7 @@
   }
 
   test_resolveDirectives() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library libA;
 /// My class.
 /// Short description.
@@ -40,9 +38,7 @@
 /// Longer description.
 class A {}
 ''');
-    addSource(
-        '/libB.dart',
-        '''
+    addSource('/libB.dart', '''
 library libB;
 import "/libA.dart" as foo;
 part '$testFile';
diff --git a/pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart
index 24a2c60..2f6b5aa 100644
--- a/pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/imported_reference_contributor_test.dart
@@ -32,9 +32,7 @@
   test_ArgDefaults_function_with_required_named() async {
     addMetaPackageSource();
 
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib B;
 import 'package:meta/meta.dart';
 
@@ -53,9 +51,7 @@
 
   test_ArgumentList() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
@@ -81,9 +77,7 @@
 
   test_ArgumentList_imported_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         expect(arg) { }
@@ -110,9 +104,7 @@
 
   test_ArgumentList_InstanceCreationExpression_functionalArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
@@ -143,9 +135,7 @@
 
   test_ArgumentList_InstanceCreationExpression_typedefArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         typedef Funct();
         class A { A(Funct f) { } }
@@ -177,9 +167,7 @@
 
   test_ArgumentList_local_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
@@ -206,9 +194,7 @@
 
   test_ArgumentList_local_method() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
@@ -235,9 +221,7 @@
 
   test_ArgumentList_MethodInvocation_functionalArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
@@ -268,9 +252,7 @@
 
   test_ArgumentList_MethodInvocation_methodArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
@@ -300,9 +282,7 @@
   test_ArgumentList_namedParam() async {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
     // ExpressionStatement
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }''');
     addTestSource('''
@@ -340,9 +320,7 @@
 
   test_AsExpression_type_subtype_extends_filter() async {
     // SimpleIdentifier  TypeName  AsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
           foo() { }
           class A {} class B extends A {} class C extends B {}
           class X {X.c(); X._d(); z() {}}''');
@@ -364,9 +342,7 @@
 
   test_AsExpression_type_subtype_implements_filter() async {
     // SimpleIdentifier  TypeName  AsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
           foo() { }
           class A {} class B implements A {} class C implements B {}
           class X {X.c(); X._d(); z() {}}''');
@@ -515,9 +491,7 @@
   }
 
   test_AwaitExpression_function() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 Future y() async {return 0;}
 ''');
     addTestSource('''
@@ -537,9 +511,7 @@
 
   test_AwaitExpression_inherited() async {
     // SimpleIdentifier  AwaitExpression  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib libB;
 class A {
   Future y() async { return 0; }
@@ -590,29 +562,21 @@
 
   test_Block() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -698,29 +662,21 @@
 
   test_Block_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -819,29 +775,21 @@
 
   test_Block_final_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -928,29 +876,21 @@
 
   test_Block_final_var() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -1034,29 +974,21 @@
   }
 
   test_Block_identifier_partial() async {
-    resolveSource(
-        '/testAB.dart',
-        '''
+    resolveSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class DF { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         class D3 { }
         int T3;
@@ -1120,9 +1052,7 @@
 
   test_Block_inherited_imported() async {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class F { var f1; f2() { } get f3 => 0; set f4(fx) { } var _pf; }
         class E extends F { var e1; e2() { } }
@@ -1176,29 +1106,21 @@
   }
 
   test_Block_local_function() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -1236,29 +1158,21 @@
 
   test_Block_partial_results() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -1295,9 +1209,7 @@
 
   test_CascadeExpression_selector1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "/testB.dart";
@@ -1322,9 +1234,7 @@
 
   test_CascadeExpression_selector2() async {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "/testB.dart";
@@ -1347,9 +1257,7 @@
 
   test_CascadeExpression_selector2_withTrailingReturn() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "/testB.dart";
@@ -1444,9 +1352,7 @@
 
   test_ClassDeclaration_body() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1471,9 +1377,7 @@
 
   test_ClassDeclaration_body_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1494,9 +1398,7 @@
 
   test_ClassDeclaration_body_final_field() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1517,9 +1419,7 @@
 
   test_ClassDeclaration_body_final_field2() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as Soo;
@@ -1540,9 +1440,7 @@
 
   test_ClassDeclaration_body_final_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1563,9 +1461,7 @@
 
   test_ClassDeclaration_body_final_var() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1586,23 +1482,17 @@
 
   test_Combinator_hide() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         library libAB;
         part '/partAB.dart';
         class A { }
         class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
         part of libAB;
         var T1;
         PB F1() => new PB();
         class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         class C { }
         class D { }''');
     addTestSource('''
@@ -1616,25 +1506,19 @@
 
   test_Combinator_show() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         library libAB;
         part '/partAB.dart';
         class A { }
         class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
         part of libAB;
         var T1;
         PB F1() => new PB();
         typedef PB2 F2(int blat);
         class Clz = Object with Object;
         class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         class C { }
         class D { }''');
     addTestSource('''
@@ -1648,9 +1532,7 @@
 
   test_ConditionalExpression_elseExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1670,9 +1552,7 @@
 
   test_ConditionalExpression_elseExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1698,9 +1578,7 @@
 
   test_ConditionalExpression_partial_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1720,9 +1598,7 @@
 
   test_ConditionalExpression_partial_thenExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1748,9 +1624,7 @@
 
   test_ConditionalExpression_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1771,9 +1645,7 @@
   test_ConstructorName_importedClass() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
@@ -1798,9 +1670,7 @@
   test_ConstructorName_importedFactory() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
@@ -1901,9 +1771,7 @@
   }
 
   test_doc_class() async {
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library A;
 /// My class.
 /// Short description.
@@ -1922,9 +1790,7 @@
   }
 
   test_doc_function() async {
-    resolveSource(
-        '/libA.dart',
-        r'''
+    resolveSource('/libA.dart', r'''
 library A;
 /// My function.
 /// Short description.
@@ -1943,9 +1809,7 @@
   }
 
   test_doc_function_c_style() async {
-    resolveSource(
-        '/libA.dart',
-        r'''
+    resolveSource('/libA.dart', r'''
 library A;
 /**
  * My function.
@@ -1987,9 +1851,7 @@
 
   test_ExpressionStatement_identifier() async {
     // SimpleIdentifier  ExpressionStatement  Block
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         _B F1() { }
         class A {int x;}
         class _B { }''');
@@ -2016,9 +1878,7 @@
 
   test_ExpressionStatement_name() async {
     // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         B T1;
         class B{}''');
     addTestSource('''
@@ -2226,9 +2086,7 @@
   }
 
   test_function_parameters_mixed_required_and_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 int m(x, {int y}) {}
 ''');
     addTestSource('''
@@ -2249,9 +2107,7 @@
   }
 
   test_function_parameters_mixed_required_and_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, [int y]) {}
 ''');
     addTestSource('''
@@ -2272,9 +2128,7 @@
   }
 
   test_function_parameters_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m({x, int y}) {}
 ''');
     addTestSource('''
@@ -2295,9 +2149,7 @@
   }
 
   test_function_parameters_none() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m() {}
 ''');
     addTestSource('''
@@ -2316,9 +2168,7 @@
   }
 
   test_function_parameters_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m([x, int y]) {}
 ''');
     addTestSource('''
@@ -2339,9 +2189,7 @@
   }
 
   test_function_parameters_required() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, int y) {}
 ''');
     addTestSource('''
@@ -2363,9 +2211,7 @@
 
   test_FunctionDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2395,9 +2241,7 @@
 
   test_FunctionDeclaration_returnType_afterComment2() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2427,9 +2271,7 @@
 
   test_FunctionDeclaration_returnType_afterComment3() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2551,9 +2393,7 @@
 
   test_IndexExpression() async {
     // ExpressionStatement  Block
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -2579,9 +2419,7 @@
 
   test_IndexExpression2() async {
     // SimpleIdentifier IndexExpression ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -2600,9 +2438,7 @@
   }
 
   test_InstanceCreationExpression() async {
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
 class A {foo(){var f; {var x;}}}
 class B {B(this.x, [String boo]) { } int x;}
 class C {C.bar({boo: 'hoo', int z: 0}) { } }''');
@@ -2652,9 +2488,7 @@
 
   test_InstanceCreationExpression_imported() async {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {A(this.x) { } int x;}''');
@@ -2715,9 +2549,7 @@
 
   test_InterpolationExpression() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2747,9 +2579,7 @@
 
   test_InterpolationExpression_block() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2823,9 +2653,7 @@
 
   test_IsExpression() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class X {X.c(); X._d(); z() {}}''');
@@ -2895,9 +2723,7 @@
 
   test_IsExpression_type_subtype_extends_filter() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         foo() { }
         class A {} class B extends A {} class C extends B {}
         class X {X.c(); X._d(); z() {}}''');
@@ -2919,9 +2745,7 @@
 
   test_IsExpression_type_subtype_implements_filter() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         foo() { }
         class A {} class B implements A {} class C implements B {}
         class X {X.c(); X._d(); z() {}}''');
@@ -2942,9 +2766,7 @@
   }
 
   test_keyword() async {
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
         lib B;
         int newT1;
         int T1;
@@ -3005,9 +2827,7 @@
 
   test_MapLiteralEntry() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3041,9 +2861,7 @@
 
   test_MapLiteralEntry1() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3070,9 +2888,7 @@
 
   test_MapLiteralEntry2() async {
     // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3093,9 +2909,7 @@
   }
 
   test_method_parameters_mixed_required_and_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, {int y}) {}
 ''');
     addTestSource('''
@@ -3116,9 +2930,7 @@
   }
 
   test_method_parameters_mixed_required_and_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, [int y]) {}
 ''');
     addTestSource('''
@@ -3139,9 +2951,7 @@
   }
 
   test_method_parameters_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m({x, int y}) {}
 ''');
     addTestSource('''
@@ -3162,9 +2972,7 @@
   }
 
   test_method_parameters_none() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m() {}
 ''');
     addTestSource('''
@@ -3183,9 +2991,7 @@
   }
 
   test_method_parameters_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m([x, int y]) {}
 ''');
     addTestSource('''
@@ -3206,9 +3012,7 @@
   }
 
   test_method_parameters_required() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 void m(x, int y) {}
 ''');
     addTestSource('''
@@ -3242,9 +3046,7 @@
 
   test_MethodDeclaration_body_static() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testC.dart',
-        '''
+    addSource('/testC.dart', '''
         class C {
           c1() {}
           var c2;
@@ -3327,9 +3129,7 @@
 
   test_MethodDeclaration_returnType() async {
     // ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3358,9 +3158,7 @@
 
   test_MethodDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3389,9 +3187,7 @@
 
   test_MethodDeclaration_returnType_afterComment2() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3420,9 +3216,7 @@
 
   test_MethodDeclaration_returnType_afterComment3() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3485,9 +3279,7 @@
   }
 
   test_mixin_ordering() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 class B {}
 class M1 {
   void m() {}
@@ -3531,9 +3323,7 @@
     }
 
     // Check that source in 2nd context does not appear in completion in 1st
-    addSource(
-        '/context1/libA.dart',
-        '''
+    addSource('/context1/libA.dart', '''
       library libA;
       class ClassInLocalContext {int x;}''');
     testFile = '/context1/completionTest.dart';
@@ -3562,9 +3352,7 @@
   }
 
   test_no_parameters_field() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 int x;
 ''');
     addTestSource('''
@@ -3579,9 +3367,7 @@
   }
 
   test_no_parameters_getter() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 int get x => null;
 ''');
     addTestSource('''
@@ -3596,9 +3382,7 @@
   }
 
   test_no_parameters_setter() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 set x(int value) {};
 ''');
     addTestSource('''
@@ -3621,16 +3405,12 @@
 
   test_partFile_TypeName() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         library libA;
         import "/testB.dart";
         part "$testFile";
@@ -3661,16 +3441,12 @@
 
   test_partFile_TypeName2() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib libB;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         part of libA;
         class B { }''');
     addTestSource('''
@@ -3701,9 +3477,7 @@
 
   test_PrefixedIdentifier_class_const() async {
     // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class I {
           static const scI = 'boo';
@@ -3750,9 +3524,7 @@
 
   test_PrefixedIdentifier_class_imported() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class I {X get f => new A();get _g => new A();}
         class A implements I {
@@ -3831,9 +3603,7 @@
 
   test_PrefixedIdentifier_library() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -3860,9 +3630,7 @@
 
   test_PrefixedIdentifier_library_typesOnly() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -3889,9 +3657,7 @@
 
   test_PrefixedIdentifier_library_typesOnly2() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -3918,9 +3684,7 @@
 
   test_PrefixedIdentifier_parameter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class _W {M y; var _z;}
         class X extends _W {}
@@ -3939,9 +3703,7 @@
 
   test_PrefixedIdentifier_prefix() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class A {static int bar = 10;}
         _B() {}''');
     addTestSource('''
@@ -4382,9 +4144,7 @@
 
   test_TypeArgumentList() async {
     // SimpleIdentifier  BinaryExpression  ExpressionStatement
-    resolveSource(
-        '/testA.dart',
-        '''
+    resolveSource('/testA.dart', '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
@@ -4410,9 +4170,7 @@
 
   test_TypeArgumentList2() async {
     // TypeName  TypeArgumentList  TypeName
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
@@ -4434,9 +4192,7 @@
   test_VariableDeclaration_name() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class _B { }
@@ -4463,9 +4219,7 @@
   test_VariableDeclarationStatement_RHS() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class _B { }
@@ -4490,9 +4244,7 @@
   test_VariableDeclarationStatement_RHS_missing_semicolon() async {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
         lib B;
         foo1() { }
         void bar1() { }
diff --git a/pkg/analysis_server/test/services/completion/dart/inherited_reference_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/inherited_reference_contributor_test.dart
index 658a45a..e4c1c9a 100644
--- a/pkg/analysis_server/test/services/completion/dart/inherited_reference_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/inherited_reference_contributor_test.dart
@@ -29,9 +29,7 @@
   /// Sanity check.  Permutations tested in local_ref_contributor.
   test_ArgDefaults_inherited_method_with_required_named() async {
     addMetaPackageSource();
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 import 'package:meta/meta.dart';
 
 lib libB;
@@ -52,9 +50,7 @@
 
   test_AwaitExpression_inherited() async {
     // SimpleIdentifier  AwaitExpression  ExpressionStatement
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib libB;
 class A {
   Future y() async {return 0;}
@@ -80,9 +76,7 @@
 
   test_Block_inherited_imported() async {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
       lib B;
       class F { var f1; f2() { } get f3 => 0; set f4(fx) { } var _pf; }
       class E extends F { var e1; e2() { } }
@@ -132,9 +126,7 @@
   }
 
   test_inherited() async {
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib libB;
 class A2 {
   int x;
@@ -186,9 +178,7 @@
   }
 
   test_method_parameters_mixed_required_and_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   void m(x, {int y}) {}
 }
@@ -231,9 +221,7 @@
   }
 
   test_method_parameters_mixed_required_and_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   void m(x, [int y]) {}
 }
@@ -276,9 +264,7 @@
   }
 
   test_method_parameters_named() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   void m({x, int y}) {}
 }
@@ -321,9 +307,7 @@
   }
 
   test_method_parameters_none() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   void m() {}
 }
@@ -360,9 +344,7 @@
   }
 
   test_method_parameters_positional() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   void m([x, int y]) {}
 }
@@ -405,9 +387,7 @@
   }
 
   test_method_parameters_required() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   void m(x, int y) {}
 }
@@ -430,9 +410,7 @@
   }
 
   test_mixin_ordering() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class B {}
 class M1 {
   void m() {}
@@ -454,9 +432,7 @@
   }
 
   test_no_parameters_field() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   int x;
 }
@@ -473,9 +449,7 @@
   }
 
   test_no_parameters_getter() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   int get x => null;
 }
@@ -492,9 +466,7 @@
   }
 
   test_no_parameters_setter() async {
-    resolveSource(
-        '/libA.dart',
-        '''
+    resolveSource('/libA.dart', '''
 class A {
   set x(int value) {};
 }
@@ -511,9 +483,7 @@
   }
 
   test_outside_class() async {
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib libB;
 class A2 {
   int x;
@@ -554,9 +524,7 @@
   }
 
   test_static_field() async {
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib libB;
 class A2 {
   int x;
@@ -597,9 +565,7 @@
   }
 
   test_static_method() async {
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib libB;
 class A2 {
   int x;
diff --git a/pkg/analysis_server/test/services/completion/dart/library_member_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/library_member_contributor_test.dart
index 7491a8e..2c49eca 100644
--- a/pkg/analysis_server/test/services/completion/dart/library_member_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/library_member_contributor_test.dart
@@ -88,9 +88,7 @@
   test_libraryPrefix_deferred_inPart() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     var libFile = '${testFile.substring(0, testFile.length - 5)}A.dart';
-    addSource(
-        libFile,
-        '''
+    addSource(libFile, '''
         library testA;
         import "dart:async" deferred as bar;
         part "$testFile";''');
@@ -105,9 +103,7 @@
 
   test_libraryPrefix_with_exports() async {
     addSource('/libA.dart', 'library libA; class A { }');
-    addSource(
-        '/libB.dart',
-        '''
+    addSource('/libB.dart', '''
         library libB;
         export "/libA.dart";
         class B { }
@@ -122,9 +118,7 @@
 
   test_PrefixedIdentifier_library() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -150,16 +144,12 @@
   test_PrefixedIdentifier_library_inPart() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     var libFile = '${testFile.substring(0, testFile.length - 5)}A.dart';
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
         class Y { }''');
-    addSource(
-        libFile,
-        '''
+    addSource(libFile, '''
         library testA;
         import "/testB.dart" as b;
         part "$testFile";
@@ -185,9 +175,7 @@
 
   test_PrefixedIdentifier_library_typesOnly() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -212,9 +200,7 @@
 
   test_PrefixedIdentifier_library_typesOnly2() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -239,9 +225,7 @@
 
   test_PrefixedIdentifier_parameter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class _W {M y; var _z;}
         class X extends _W {}
@@ -255,9 +239,7 @@
 
   test_PrefixedIdentifier_prefix() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class A {static int bar = 10;}
         _B() {}''');
     addTestSource('''
diff --git a/pkg/analysis_server/test/services/completion/dart/library_prefix_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/library_prefix_contributor_test.dart
index 6cad0b2..3343e5e 100644
--- a/pkg/analysis_server/test/services/completion/dart/library_prefix_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/library_prefix_contributor_test.dart
@@ -42,29 +42,21 @@
 
   test_Block() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -97,29 +89,21 @@
 
   test_Block_final_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -152,29 +136,21 @@
 
   test_Block_final_var() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -207,9 +183,7 @@
 
   test_ClassDeclaration_body() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -224,9 +198,7 @@
 
   test_ClassDeclaration_body_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -241,9 +213,7 @@
 
   test_ClassDeclaration_body_final_field() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -258,9 +228,7 @@
 
   test_ClassDeclaration_body_final_field2() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as Soo;
@@ -275,9 +243,7 @@
 
   test_ClassDeclaration_body_final_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -292,9 +258,7 @@
 
   test_ClassDeclaration_body_final_var() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -308,9 +272,7 @@
   }
 
   test_InstanceCreationExpression() async {
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class A {foo(){var f; {var x;}}}
 class B {B(this.x, [String boo]) { } int x;}
 class C {C.bar({boo: 'hoo', int z: 0}) { } }''');
@@ -329,15 +291,11 @@
   }
 
   test_InstanceCreationExpression_inPart() async {
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class A {foo(){var f; {var x;}}}
 class B {B(this.x, [String boo]) { } int x;}
 class C {C.bar({boo: 'hoo', int z: 0}) { } }''');
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 library testB;
 import "/testA.dart" as t;
 import "dart:math" as math;
@@ -352,15 +310,11 @@
   }
 
   test_InstanceCreationExpression_inPart_detached() async {
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class A {foo(){var f; {var x;}}}
 class B {B(this.x, [String boo]) { } int x;}
 class C {C.bar({boo: 'hoo', int z: 0}) { } }''');
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 library testB;
 import "/testA.dart" as t;
 import "dart:math" as math;
diff --git a/pkg/analysis_server/test/services/completion/dart/local_constructor_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/local_constructor_contributor_test.dart
index dfef73b..89c378d 100644
--- a/pkg/analysis_server/test/services/completion/dart/local_constructor_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/local_constructor_contributor_test.dart
@@ -74,9 +74,7 @@
 
   test_ArgumentList() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 void baz() { }''');
@@ -102,9 +100,7 @@
 
   test_ArgumentList_imported_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 expect(arg) { }
@@ -131,9 +127,7 @@
 
   test_ArgumentList_InstanceCreationExpression_functionalArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 class A { A(f()) { } }
 bool hasLength(int expected) { }
@@ -162,9 +156,7 @@
 
   test_ArgumentList_InstanceCreationExpression_typedefArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 typedef Funct();
 class A { A(Funct f) { } }
@@ -194,9 +186,7 @@
 
   test_ArgumentList_local_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 void baz() { }''');
@@ -223,9 +213,7 @@
 
   test_ArgumentList_local_method() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 void baz() { }''');
@@ -252,9 +240,7 @@
 
   test_ArgumentList_MethodInvocation_functionalArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 class A { A(f()) { } }
 bool hasLength(int expected) { }
@@ -283,9 +269,7 @@
 
   test_ArgumentList_MethodInvocation_methodArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 class A { A(f()) { } }
 bool hasLength(int expected) { }
@@ -313,9 +297,7 @@
   test_ArgumentList_namedParam() async {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
     // ExpressionStatement
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }''');
     addTestSource('''
@@ -507,29 +489,21 @@
 
   test_Block() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -608,29 +582,21 @@
 
   test_Block_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -729,29 +695,21 @@
 
   test_Block_final_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -836,29 +794,21 @@
 
   test_Block_final_var() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -942,29 +892,21 @@
   }
 
   test_Block_identifier_partial() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 class D3 { }
 int T3;
@@ -1029,9 +971,7 @@
 
   test_Block_inherited_imported() async {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 class F { var f1; f2() { } get f3 => 0; set f4(fx) { } var _pf; }
 class E extends F { var e1; e2() { } }
@@ -1085,29 +1025,21 @@
   }
 
   test_Block_local_function() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -1161,9 +1093,7 @@
 
   test_CascadeExpression_selector1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "/testB.dart";
@@ -1188,9 +1118,7 @@
 
   test_CascadeExpression_selector2() async {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "/testB.dart";
@@ -1213,9 +1141,7 @@
 
   test_CascadeExpression_selector2_withTrailingReturn() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "/testB.dart";
@@ -1310,9 +1236,7 @@
 
   test_ClassDeclaration_body() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1333,9 +1257,7 @@
 
   test_ClassDeclaration_body_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1356,9 +1278,7 @@
 
   test_ClassDeclaration_body_final_field() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1379,9 +1299,7 @@
 
   test_ClassDeclaration_body_final_field2() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as Soo;
@@ -1402,9 +1320,7 @@
 
   test_ClassDeclaration_body_final_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1425,9 +1341,7 @@
 
   test_ClassDeclaration_body_final_var() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1448,23 +1362,17 @@
 
   test_Combinator_hide() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 library libAB;
 part '/partAB.dart';
 class A { }
 class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
 part of libAB;
 var T1;
 PB F1() => new PB();
 class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 class C { }
 class D { }''');
     addTestSource('''
@@ -1478,25 +1386,19 @@
 
   test_Combinator_show() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 library libAB;
 part '/partAB.dart';
 class A { }
 class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
 part of libAB;
 var T1;
 PB F1() => new PB();
 typedef PB2 F2(int blat);
 class Clz = Object with Object;
 class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 class C { }
 class D { }''');
     addTestSource('''
@@ -1510,9 +1412,7 @@
 
   test_ConditionalExpression_elseExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1532,9 +1432,7 @@
 
   test_ConditionalExpression_elseExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1560,9 +1458,7 @@
 
   test_ConditionalExpression_partial_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1582,9 +1478,7 @@
 
   test_ConditionalExpression_partial_thenExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1610,9 +1504,7 @@
 
   test_ConditionalExpression_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1668,9 +1560,7 @@
   test_ConstructorName_importedClass() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
@@ -1695,9 +1585,7 @@
   test_ConstructorName_importedFactory() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
@@ -1815,9 +1703,7 @@
 
   test_ExpressionStatement_identifier() async {
     // SimpleIdentifier  ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 _B F1() { }
 class A {int x;}
 class _B { }''');
@@ -1844,9 +1730,7 @@
 
   test_ExpressionStatement_name() async {
     // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         B T1;
         class B{}''');
     addTestSource('''
@@ -2104,9 +1988,7 @@
 
   test_FunctionDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2136,9 +2018,7 @@
 
   test_FunctionDeclaration_returnType_afterComment2() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2168,9 +2048,7 @@
 
   test_FunctionDeclaration_returnType_afterComment3() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2325,9 +2203,7 @@
 
   test_IndexExpression() async {
     // ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -2353,9 +2229,7 @@
 
   test_IndexExpression2() async {
     // SimpleIdentifier IndexExpression ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -2455,9 +2329,7 @@
 
   test_InstanceCreationExpression_imported() async {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {A(this.x) { } int x;}''');
@@ -2536,9 +2408,7 @@
 
   test_InterpolationExpression() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2568,9 +2438,7 @@
 
   test_InterpolationExpression_block() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2642,9 +2510,7 @@
 
   test_IsExpression() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo() { }
 class X {X.c(); X._d(); z() {}}''');
@@ -2713,9 +2579,7 @@
   }
 
   test_keyword() async {
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int newT1;
 int T1;
@@ -2777,9 +2641,7 @@
 
   test_MapLiteralEntry() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2808,9 +2670,7 @@
 
   test_MapLiteralEntry1() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2832,9 +2692,7 @@
 
   test_MapLiteralEntry2() async {
     // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2946,9 +2804,7 @@
 
   test_MethodDeclaration_body_static() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testC.dart',
-        '''
+    addSource('/testC.dart', '''
 class C {
   c1() {}
   var c2;
@@ -3032,9 +2888,7 @@
 
   test_MethodDeclaration_returnType() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3063,9 +2917,7 @@
 
   test_MethodDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3094,9 +2946,7 @@
 
   test_MethodDeclaration_returnType_afterComment2() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3125,9 +2975,7 @@
 
   test_MethodDeclaration_returnType_afterComment3() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3235,16 +3083,12 @@
 
   test_partFile_TypeName() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
 class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 library libA;
 import "/testB.dart";
 part "$testFile";
@@ -3273,16 +3117,12 @@
 
   test_partFile_TypeName2() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
 class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 part of libA;
 class B { }''');
     addTestSource('''
@@ -3310,9 +3150,7 @@
 
   test_PrefixedIdentifier_class_const() async {
     // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 class I {
   static const scI = 'boo';
@@ -3359,9 +3197,7 @@
 
   test_PrefixedIdentifier_class_imported() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 class I {X get f => new A();get _g => new A();}
 class A implements I {
@@ -3440,9 +3276,7 @@
 
   test_PrefixedIdentifier_library() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 var T1;
 class X { }
@@ -3469,9 +3303,7 @@
 
   test_PrefixedIdentifier_library_typesOnly() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 var T1;
 class X { }
@@ -3498,9 +3330,7 @@
 
   test_PrefixedIdentifier_library_typesOnly2() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 var T1;
 class X { }
@@ -3527,9 +3357,7 @@
 
   test_PrefixedIdentifier_parameter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 class _W {M y; var _z;}
 class X extends _W {}
@@ -3548,9 +3376,7 @@
 
   test_PrefixedIdentifier_prefix() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class A {static int bar = 10;}
 _B() {}''');
     addTestSource('''
@@ -4018,9 +3844,7 @@
 
   test_TypeArgumentList() async {
     // SimpleIdentifier  BinaryExpression  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class C1 {int x;}
 F1() => 0;
 typedef String T1(int blat);''');
@@ -4046,9 +3870,7 @@
 
   test_TypeArgumentList2() async {
     // TypeName  TypeArgumentList  TypeName
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class C1 {int x;}
 F1() => 0;
 typedef String T1(int blat);''');
@@ -4070,9 +3892,7 @@
   test_VariableDeclaration_name() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo() { }
 class _B { }
@@ -4099,9 +3919,7 @@
   test_VariableDeclarationStatement_RHS() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo() { }
 class _B { }
@@ -4126,9 +3944,7 @@
   test_VariableDeclarationStatement_RHS_missing_semicolon() async {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo1() { }
 void bar1() { }
diff --git a/pkg/analysis_server/test/services/completion/dart/local_library_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/local_library_contributor_test.dart
index ce5b62b..9d776dc 100644
--- a/pkg/analysis_server/test/services/completion/dart/local_library_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/local_library_contributor_test.dart
@@ -24,16 +24,12 @@
 
   test_partFile_Constructor() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         library libA;
         import "/testB.dart";
         part "$testFile";
@@ -63,16 +59,12 @@
 
   test_partFile_Constructor2() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         part of libA;
         class B { }''');
     addTestSource('''
@@ -102,16 +94,12 @@
 
   test_partFile_InstanceCreationExpression_assignment_filter() async {
     // ConstructorName  InstanceCreationExpression  VariableDeclarationList
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         part of libA;
         class A {} class B extends A {} class C implements A {} class D {}
         ''');
@@ -157,16 +145,12 @@
 
   test_partFile_InstanceCreationExpression_variable_declaration_filter() async {
     // ConstructorName  InstanceCreationExpression  VariableDeclarationList
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         part of libA;
         class A {} class B extends A {} class C implements A {} class D {}
         ''');
@@ -209,16 +193,12 @@
   }
 
   test_partFile_TypeName() async {
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         library libA;
         import "/testB.dart";
         part "$testFile";
@@ -256,16 +236,12 @@
   }
 
   test_partFile_TypeName2() async {
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         part of libA;
         class B { var b1; b2(){}}
         int bf() => 0;
diff --git a/pkg/analysis_server/test/services/completion/dart/local_reference_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/local_reference_contributor_test.dart
index f2b6e7c..64f561f 100644
--- a/pkg/analysis_server/test/services/completion/dart/local_reference_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/local_reference_contributor_test.dart
@@ -130,9 +130,7 @@
 
   test_ArgumentList() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 void baz() { }''');
@@ -159,9 +157,7 @@
 
   test_ArgumentList_imported_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 expect(arg) { }
@@ -189,9 +185,7 @@
 
   test_ArgumentList_InstanceCreationExpression_functionalArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 class A { A(f()) { } }
 bool hasLength(int expected) { }
@@ -222,9 +216,7 @@
 
   test_ArgumentList_InstanceCreationExpression_typedefArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 typedef Funct();
 class A { A(Funct f) { } }
@@ -256,9 +248,7 @@
 
   test_ArgumentList_local_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 void baz() { }''');
@@ -286,9 +276,7 @@
 
   test_ArgumentList_local_method() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }
 void baz() { }''');
@@ -316,9 +304,7 @@
 
   test_ArgumentList_MethodInvocation_functionalArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 class A { A(f()) { } }
 bool hasLength(int expected) { }
@@ -352,9 +338,7 @@
 
   test_ArgumentList_MethodInvocation_functionalArg2() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 class A { A(f()) { } }
 bool hasLength(int expected) { }
@@ -388,9 +372,7 @@
 
   test_ArgumentList_MethodInvocation_methodArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 class A { A(f()) { } }
 bool hasLength(int expected) { }
@@ -416,9 +398,7 @@
   }
 
   test_ArgumentList_namedFieldParam_tear_off() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
@@ -449,9 +429,7 @@
   test_ArgumentList_namedParam() async {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
     // ExpressionStatement
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 library A;
 bool hasLength(int expected) { }''');
     addTestSource('''
@@ -506,9 +484,7 @@
   }
 
   test_ArgumentList_namedParam_tear_off() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
@@ -536,9 +512,7 @@
   }
 
   test_ArgumentList_namedParam_tear_off_1() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
@@ -566,9 +540,7 @@
   }
 
   test_ArgumentList_namedParam_tear_off_2() async {
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
 typedef void VoidCallback();
         
 class Button {
@@ -837,29 +809,21 @@
 
   test_Block() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -943,29 +907,21 @@
 
   test_Block_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -1064,29 +1020,21 @@
 
   test_Block_final_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -1171,29 +1119,21 @@
 
   test_Block_final_var() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -1277,29 +1217,21 @@
   }
 
   test_Block_identifier_partial() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 class D3 { }
 int T3;
@@ -1365,9 +1297,7 @@
 
   test_Block_inherited_imported() async {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
-    resolveSource(
-        '/testB.dart',
-        '''
+    resolveSource('/testB.dart', '''
 lib B;
 class F { var f1; f2() { } get f3 => 0; set f4(fx) { } var _pf; }
 class E extends F { var e1; e2() { } }
@@ -1421,29 +1351,21 @@
   }
 
   test_Block_local_function() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 export "dart:math" hide max;
 class A {int x;}
 @deprecated D1() {int x;}
 class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 String T1;
 var _T2;
 class C { }
 class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
 class EE { }
 class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
 class H { }
 int T3;
 var _T4;'''); // not imported
@@ -1497,9 +1419,7 @@
 
   test_CascadeExpression_selector1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "/testB.dart";
@@ -1524,9 +1444,7 @@
 
   test_CascadeExpression_selector2() async {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "/testB.dart";
@@ -1549,9 +1467,7 @@
 
   test_CascadeExpression_selector2_withTrailingReturn() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "/testB.dart";
@@ -1646,9 +1562,7 @@
 
   test_ClassDeclaration_body() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1678,9 +1592,7 @@
 
   test_ClassDeclaration_body_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1701,9 +1613,7 @@
 
   test_ClassDeclaration_body_final_field() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1724,9 +1634,7 @@
 
   test_ClassDeclaration_body_final_field2() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as Soo;
@@ -1747,9 +1655,7 @@
 
   test_ClassDeclaration_body_final_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1770,9 +1676,7 @@
 
   test_ClassDeclaration_body_final_var() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 class B { }''');
     addTestSource('''
 import "testB.dart" as x;
@@ -1793,23 +1697,17 @@
 
   test_Combinator_hide() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 library libAB;
 part '/partAB.dart';
 class A { }
 class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
 part of libAB;
 var T1;
 PB F1() => new PB();
 class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 class C { }
 class D { }''');
     addTestSource('''
@@ -1823,25 +1721,19 @@
 
   test_Combinator_show() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
 library libAB;
 part '/partAB.dart';
 class A { }
 class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
 part of libAB;
 var T1;
 PB F1() => new PB();
 typedef PB2 F2(int blat);
 class Clz = Object with Object;
 class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
 class C { }
 class D { }''');
     addTestSource('''
@@ -1855,9 +1747,7 @@
 
   test_ConditionalExpression_elseExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1878,9 +1768,7 @@
 
   test_ConditionalExpression_elseExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1908,9 +1796,7 @@
 
   test_ConditionalExpression_partial_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1931,9 +1817,7 @@
 
   test_ConditionalExpression_partial_thenExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -1961,9 +1845,7 @@
 
   test_ConditionalExpression_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -2020,9 +1902,7 @@
   test_ConstructorName_importedClass() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
@@ -2047,9 +1927,7 @@
   test_ConstructorName_importedFactory() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
@@ -2301,9 +2179,7 @@
 
   test_ExpressionStatement_identifier() async {
     // SimpleIdentifier  ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 _B F1() { }
 class A {int x;}
 class _B { }''');
@@ -2332,9 +2208,7 @@
 
   test_ExpressionStatement_name() async {
     // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         B T1;
         class B{}''');
     addTestSource('''
@@ -2671,9 +2545,7 @@
 
   test_FunctionDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2703,9 +2575,7 @@
 
   test_FunctionDeclaration_returnType_afterComment2() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2735,9 +2605,7 @@
 
   test_FunctionDeclaration_returnType_afterComment3() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -2901,9 +2769,7 @@
 
   test_IndexExpression() async {
     // ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -2931,9 +2797,7 @@
 
   test_IndexExpression2() async {
     // SimpleIdentifier IndexExpression ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {int x;}''');
@@ -2965,9 +2829,7 @@
 
   test_InstanceCreationExpression_imported() async {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 class A {A(this.x) { } int x;}''');
@@ -3011,9 +2873,7 @@
 
   test_InterpolationExpression() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3044,9 +2904,7 @@
 
   test_InterpolationExpression_block() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3119,9 +2977,7 @@
 
   test_IsExpression() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo() { }
 class X {X.c(); X._d(); z() {}}''');
@@ -3236,9 +3092,7 @@
   }
 
   test_keyword() async {
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int newT1;
 int T1;
@@ -3302,9 +3156,7 @@
 
   test_MapLiteralEntry() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3334,9 +3186,7 @@
 
   test_MapLiteralEntry1() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3359,9 +3209,7 @@
 
   test_MapLiteralEntry2() async {
     // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3489,9 +3337,7 @@
 
   test_MethodDeclaration_body_static() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testC.dart',
-        '''
+    addSource('/testC.dart', '''
 class C {
   c1() {}
   var c2;
@@ -3632,9 +3478,7 @@
 
   test_MethodDeclaration_returnType() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3663,9 +3507,7 @@
 
   test_MethodDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3694,9 +3536,7 @@
 
   test_MethodDeclaration_returnType_afterComment2() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3725,9 +3565,7 @@
 
   test_MethodDeclaration_returnType_afterComment3() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 int T1;
 F1() { }
 typedef D1();
@@ -3835,16 +3673,12 @@
 
   test_partFile_TypeName() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
 class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 library libA;
 import "/testB.dart";
 part "$testFile";
@@ -3873,16 +3707,12 @@
 
   test_partFile_TypeName2() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 int T1;
 F1() { }
 class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 part of libA;
 class B { }''');
     addTestSource('''
@@ -3912,9 +3742,7 @@
 
   test_PrefixedIdentifier_class_const() async {
     // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 class I {
   static const scI = 'boo';
@@ -3961,9 +3789,7 @@
 
   test_PrefixedIdentifier_class_imported() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 class I {X get f => new A();get _g => new A();}
 class A implements I {
@@ -4042,9 +3868,7 @@
 
   test_PrefixedIdentifier_library() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 var T1;
 class X { }
@@ -4071,9 +3895,7 @@
 
   test_PrefixedIdentifier_library_typesOnly() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 var T1;
 class X { }
@@ -4100,9 +3922,7 @@
 
   test_PrefixedIdentifier_library_typesOnly2() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 var T1;
 class X { }
@@ -4129,9 +3949,7 @@
 
   test_PrefixedIdentifier_parameter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 class _W {M y; var _z;}
 class X extends _W {}
@@ -4150,9 +3968,7 @@
 
   test_PrefixedIdentifier_prefix() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class A {static int bar = 10;}
 _B() {}''');
     addTestSource('''
@@ -4637,9 +4453,7 @@
 
   test_TypeArgumentList() async {
     // SimpleIdentifier  BinaryExpression  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class C1 {int x;}
 F1() => 0;
 typedef String T1(int blat);''');
@@ -4665,9 +4479,7 @@
 
   test_TypeArgumentList2() async {
     // TypeName  TypeArgumentList  TypeName
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
 class C1 {int x;}
 F1() => 0;
 typedef String T1(int blat);''');
@@ -4689,9 +4501,7 @@
   test_VariableDeclaration_name() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo() { }
 class _B { }
@@ -4718,9 +4528,7 @@
   test_VariableDeclarationStatement_RHS() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo() { }
 class _B { }
@@ -4745,9 +4553,7 @@
   test_VariableDeclarationStatement_RHS_missing_semicolon() async {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
 lib B;
 foo1() { }
 void bar1() { }
diff --git a/pkg/analysis_server/test/services/completion/dart/named_constructor_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/named_constructor_contributor_test.dart
index d57f188..f753d8a 100644
--- a/pkg/analysis_server/test/services/completion/dart/named_constructor_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/named_constructor_contributor_test.dart
@@ -45,9 +45,7 @@
   test_ConstructorName_importedClass() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
@@ -71,9 +69,7 @@
   test_ConstructorName_importedClass_unresolved() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
@@ -98,9 +94,7 @@
   test_ConstructorName_importedFactory() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
diff --git a/pkg/analysis_server/test/services/completion/dart/override_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/override_contributor_test.dart
index 96ecf43c..e0d356c 100644
--- a/pkg/analysis_server/test/services/completion/dart/override_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/override_contributor_test.dart
@@ -53,9 +53,7 @@
   }
 
   test_fromPart() async {
-    addSource(
-        '/myLib.dart',
-        '''
+    addSource('/myLib.dart', '''
 library myLib;
 part '$testFile'
 part '/otherPart.dart'
@@ -64,9 +62,7 @@
   B suggested2(String y) => null;
 }
 ''');
-    addSource(
-        '/otherPart.dart',
-        '''
+    addSource('/otherPart.dart', '''
 part of myLib;
 class B extends A {
   B suggested2(String y) => null;
diff --git a/pkg/analysis_server/test/services/completion/dart/static_member_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/static_member_contributor_test.dart
index 8080621..8df73bd 100644
--- a/pkg/analysis_server/test/services/completion/dart/static_member_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/static_member_contributor_test.dart
@@ -240,9 +240,7 @@
 
   test_PrefixedIdentifier_class_const() async {
     // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class I {
           static const scI = 'boo';
diff --git a/pkg/analysis_server/test/services/completion/dart/type_member_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/type_member_contributor_test.dart
index 1622f89..a47714c 100644
--- a/pkg/analysis_server/test/services/completion/dart/type_member_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/type_member_contributor_test.dart
@@ -113,9 +113,7 @@
 
   test_ArgumentList() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
@@ -140,9 +138,7 @@
 
   test_ArgumentList_imported_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         expect(arg) { }
@@ -168,9 +164,7 @@
 
   test_ArgumentList_InstanceCreationExpression_functionalArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
@@ -198,9 +192,7 @@
 
   test_ArgumentList_InstanceCreationExpression_typedefArg() async {
     // ArgumentList  InstanceCreationExpression  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         typedef Funct();
         class A { A(Funct f) { } }
@@ -229,9 +221,7 @@
 
   test_ArgumentList_local_function() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
@@ -257,9 +247,7 @@
 
   test_ArgumentList_local_method() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }
         void baz() { }''');
@@ -285,9 +273,7 @@
 
   test_ArgumentList_MethodInvocation_functionalArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
@@ -315,9 +301,7 @@
 
   test_ArgumentList_MethodInvocation_methodArg() async {
     // ArgumentList  MethodInvocation  ExpressionStatement  Block
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         class A { A(f()) { } }
         bool hasLength(int expected) { }
@@ -344,9 +328,7 @@
   test_ArgumentList_namedParam() async {
     // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
     // ExpressionStatement
-    addSource(
-        '/libA.dart',
-        '''
+    addSource('/libA.dart', '''
         library A;
         bool hasLength(int expected) { }''');
     addTestSource('''
@@ -523,29 +505,21 @@
 
   test_Block() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -623,29 +597,21 @@
 
   test_Block_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -743,29 +709,21 @@
 
   test_Block_final_final() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -849,29 +807,21 @@
 
   test_Block_final_var() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -954,29 +904,21 @@
   }
 
   test_Block_identifier_partial() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         class D3 { }
         int T3;
@@ -1041,9 +983,7 @@
 
   test_Block_inherited_imported() async {
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class F { var f1; f2() { } get f3 => 0; set f4(fx) { } var _pf; }
         class E extends F { var e1; e2() { } }
@@ -1096,29 +1036,21 @@
   }
 
   test_Block_local_function() async {
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         export "dart:math" hide max;
         class A {int x;}
         @deprecated D1() {int x;}
         class _B {boo() { partBoo() {}} }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         String T1;
         var _T2;
         class C { }
         class D { }''');
-    addSource(
-        '/testEEF.dart',
-        '''
+    addSource('/testEEF.dart', '''
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource(
-        '/testH.dart',
-        '''
+    addSource('/testH.dart', '''
         class H { }
         int T3;
         var _T4;'''); // not imported
@@ -1169,9 +1101,7 @@
 
   test_CascadeExpression_method1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart";
@@ -1195,9 +1125,7 @@
 
   test_CascadeExpression_selector1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart";
@@ -1221,9 +1149,7 @@
 
   test_CascadeExpression_selector2() async {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart";
@@ -1245,9 +1171,7 @@
 
   test_CascadeExpression_selector2_withTrailingReturn() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart";
@@ -1336,9 +1260,7 @@
 
   test_ClassDeclaration_body() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1357,9 +1279,7 @@
 
   test_ClassDeclaration_body_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1378,9 +1298,7 @@
 
   test_ClassDeclaration_body_final_field() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1399,9 +1317,7 @@
 
   test_ClassDeclaration_body_final_field2() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as Soo;
@@ -1420,9 +1336,7 @@
 
   test_ClassDeclaration_body_final_final() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1441,9 +1355,7 @@
 
   test_ClassDeclaration_body_final_var() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         class B { }''');
     addTestSource('''
         import "testB.dart" as x;
@@ -1462,23 +1374,17 @@
 
   test_Combinator_hide() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         library libAB;
         part '/partAB.dart';
         class A { }
         class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
         part of libAB;
         var T1;
         PB F1() => new PB();
         class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         class C { }
         class D { }''');
     addTestSource('''
@@ -1491,25 +1397,19 @@
 
   test_Combinator_show() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
-    addSource(
-        '/testAB.dart',
-        '''
+    addSource('/testAB.dart', '''
         library libAB;
         part '/partAB.dart';
         class A { }
         class B { }''');
-    addSource(
-        '/partAB.dart',
-        '''
+    addSource('/partAB.dart', '''
         part of libAB;
         var T1;
         PB F1() => new PB();
         typedef PB2 F2(int blat);
         class Clz = Object with Object;
         class PB { }''');
-    addSource(
-        '/testCD.dart',
-        '''
+    addSource('/testCD.dart', '''
         class C { }
         class D { }''');
     addTestSource('''
@@ -1522,9 +1422,7 @@
 
   test_ConditionalExpression_elseExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1543,9 +1441,7 @@
 
   test_ConditionalExpression_elseExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1570,9 +1466,7 @@
 
   test_ConditionalExpression_partial_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1591,9 +1485,7 @@
 
   test_ConditionalExpression_partial_thenExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1618,9 +1510,7 @@
 
   test_ConditionalExpression_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -1640,9 +1530,7 @@
   test_ConstructorName_importedClass() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
@@ -1666,9 +1554,7 @@
   test_ConstructorName_importedFactory() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
@@ -1828,9 +1714,7 @@
 
   test_ExpressionStatement_identifier() async {
     // SimpleIdentifier  ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         _B F1() { }
         class A {int x;}
         class _B { }''');
@@ -1856,9 +1740,7 @@
 
   test_ExpressionStatement_name() async {
     // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         B T1;
         class B{}''');
     addTestSource('''
@@ -2034,9 +1916,7 @@
 
   test_FunctionDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2065,9 +1945,7 @@
 
   test_FunctionDeclaration_returnType_afterComment2() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2096,9 +1974,7 @@
 
   test_FunctionDeclaration_returnType_afterComment3() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2267,9 +2143,7 @@
 
   test_IndexExpression() async {
     // ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -2294,9 +2168,7 @@
 
   test_IndexExpression2() async {
     // SimpleIdentifier IndexExpression ExpressionStatement  Block
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {int x;}''');
@@ -2315,9 +2187,7 @@
 
   test_InstanceCreationExpression_imported() async {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         class A {A(this.x) { } int x;}''');
@@ -2358,9 +2228,7 @@
 
   test_InterpolationExpression() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2389,9 +2257,7 @@
 
   test_InterpolationExpression_block() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2457,9 +2323,7 @@
 
   test_IsExpression() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class X {X.c(); X._d(); z() {}}''');
@@ -2531,9 +2395,7 @@
   }
 
   test_keyword2() async {
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int newT1;
         int T1;
@@ -2652,9 +2514,7 @@
 
   test_MapLiteralEntry() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2681,9 +2541,7 @@
 
   test_MapLiteralEntry1() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2703,9 +2561,7 @@
 
   test_MapLiteralEntry2() async {
     // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2835,9 +2691,7 @@
 
   test_MethodDeclaration_body_static() async {
     // Block  BlockFunctionBody  MethodDeclaration
-    addSource(
-        '/testC.dart',
-        '''
+    addSource('/testC.dart', '''
         class C {
           c1() {}
           var c2;
@@ -2916,9 +2770,7 @@
 
   test_MethodDeclaration_returnType() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2946,9 +2798,7 @@
 
   test_MethodDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -2976,9 +2826,7 @@
 
   test_MethodDeclaration_returnType_afterComment2() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3006,9 +2854,7 @@
 
   test_MethodDeclaration_returnType_afterComment3() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         int T1;
         F1() { }
         typedef D1();
@@ -3205,16 +3051,12 @@
 
   test_partFile_TypeName() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         library libA;
         import "testB.dart";
         part "$testFile";
@@ -3241,16 +3083,12 @@
 
   test_partFile_TypeName2() async {
     // SimpleIdentifier  TypeName  ConstructorName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         part of libA;
         class B { }''');
     addTestSource('''
@@ -3277,9 +3115,7 @@
 
   test_PrefixedIdentifier_class_const() async {
     // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class I {
           static const scI = 'boo';
@@ -3325,9 +3161,7 @@
 
   test_PrefixedIdentifier_class_imported() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class I {X get f => new A();get _g => new A();}
         class A implements I {
@@ -3403,9 +3237,7 @@
 
   test_PrefixedIdentifier_library() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -3431,9 +3263,7 @@
 
   test_PrefixedIdentifier_library_typesOnly() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -3459,9 +3289,7 @@
 
   test_PrefixedIdentifier_library_typesOnly2() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         var T1;
         class X { }
@@ -3487,9 +3315,7 @@
 
   test_PrefixedIdentifier_parameter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         class _W {M y; var _z;}
         class X extends _W {}
@@ -3507,9 +3333,7 @@
 
   test_PrefixedIdentifier_prefix() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class A {static int bar = 10;}
         _B() {}''');
     addTestSource('''
@@ -4078,9 +3902,7 @@
 
   test_TypeArgumentList() async {
     // SimpleIdentifier  BinaryExpression  ExpressionStatement
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
@@ -4105,9 +3927,7 @@
 
   test_TypeArgumentList2() async {
     // TypeName  TypeArgumentList  TypeName
-    addSource(
-        '/testA.dart',
-        '''
+    addSource('/testA.dart', '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
@@ -4128,9 +3948,7 @@
   test_VariableDeclaration_name() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class _B { }
@@ -4155,9 +3973,7 @@
   test_VariableDeclarationStatement_RHS() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo() { }
         class _B { }
@@ -4181,9 +3997,7 @@
   test_VariableDeclarationStatement_RHS_missing_semicolon() async {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
-    addSource(
-        '/testB.dart',
-        '''
+    addSource('/testB.dart', '''
         lib B;
         foo1() { }
         void bar1() { }
diff --git a/pkg/analysis_server/test/services/completion/postfix/postfix_completion_test.dart b/pkg/analysis_server/test/services/completion/postfix/postfix_completion_test.dart
index e9c4fef..244b2b2 100644
--- a/pkg/analysis_server/test/services/completion/postfix/postfix_completion_test.dart
+++ b/pkg/analysis_server/test/services/completion/postfix/postfix_completion_test.dart
@@ -88,16 +88,12 @@
 @reflectiveTest
 class _AssertTest extends PostfixCompletionTest {
   test_assert() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f(bool expr) {
   expr.assert
 }
 ''');
-    _assertHasChange(
-        'Expand .assert',
-        '''
+    _assertHasChange('Expand .assert', '''
 f(bool expr) {
   assert(expr);
 }
@@ -105,16 +101,12 @@
   }
 
   test_assertFunc() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f() {
   () => true.assert
 }
 ''');
-    _assertHasChange(
-        'Expand .assert',
-        '''
+    _assertHasChange('Expand .assert', '''
 f() {
   assert(() => true);
 }
@@ -123,9 +115,7 @@
 
   @failingTest
   test_assertFunc_invalid() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f() {
   () => null.assert
 }
@@ -133,16 +123,12 @@
   }
 
   test_assertFuncCmp() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f(int x, int y) {
   () => x + 3 > y + 4.assert
 }
 ''');
-    _assertHasChange(
-        'Expand .assert',
-        '''
+    _assertHasChange('Expand .assert', '''
 f(int x, int y) {
   assert(() => x + 3 > y + 4);
 }
@@ -154,9 +140,7 @@
 class _ForTest extends PostfixCompletionTest {
   @failingTest
   test_for_invalid() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   {}.for
 }
@@ -164,16 +148,12 @@
   }
 
   test_forEmptyDynamic() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   [].for
 }
 ''');
-    _assertHasChange(
-        'Expand .for',
-        '''
+    _assertHasChange('Expand .for', '''
 f() {
   for (var value in []) {
     /*caret*/
@@ -183,16 +163,12 @@
   }
 
   test_forEmptyString() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   <String>[].for
 }
 ''');
-    _assertHasChange(
-        'Expand .for',
-        '''
+    _assertHasChange('Expand .for', '''
 f() {
   for (var value in <String>[]) {
     /*caret*/
@@ -202,16 +178,12 @@
   }
 
   test_fori() async {
-    await _prepareCompletion(
-        '.fori',
-        '''
+    await _prepareCompletion('.fori', '''
 f() {
   100.fori
 }
 ''');
-    _assertHasChange(
-        'Expand .fori',
-        '''
+    _assertHasChange('Expand .fori', '''
 f() {
   for (int i = 0; i < 100; i++) {
     /*caret*/
@@ -222,9 +194,7 @@
 
   @failingTest
   test_fori_invalid() async {
-    await _prepareCompletion(
-        '.fori',
-        '''
+    await _prepareCompletion('.fori', '''
 f() {
   [].fori
 }
@@ -232,16 +202,12 @@
   }
 
   test_forIntList() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   [1,2,3].for
 }
 ''');
-    _assertHasChange(
-        'Expand .for',
-        '''
+    _assertHasChange('Expand .for', '''
 f() {
   for (var value in [1,2,3]) {
     /*caret*/
@@ -251,17 +217,13 @@
   }
 
   test_foriVar() async {
-    await _prepareCompletion(
-        '.fori',
-        '''
+    await _prepareCompletion('.fori', '''
 f() {
   var n = 100;
   n.fori
 }
 ''');
-    _assertHasChange(
-        'Expand .fori',
-        '''
+    _assertHasChange('Expand .fori', '''
 f() {
   var n = 100;
   for (int i = 0; i < n; i++) {
@@ -272,16 +234,12 @@
   }
 
   test_iterList() async {
-    await _prepareCompletion(
-        '.iter',
-        '''
+    await _prepareCompletion('.iter', '''
 f() {
   [1,2,3].iter
 }
 ''');
-    _assertHasChange(
-        'Expand .iter',
-        '''
+    _assertHasChange('Expand .iter', '''
 f() {
   for (var value in [1,2,3]) {
     /*caret*/
@@ -291,17 +249,13 @@
   }
 
   test_iterName() async {
-    await _prepareCompletion(
-        '.iter',
-        '''
+    await _prepareCompletion('.iter', '''
 f() {
   var value = [1,2,3];
   value.iter
 }
 ''');
-    _assertHasChange(
-        'Expand .iter',
-        '''
+    _assertHasChange('Expand .iter', '''
 f() {
   var value = [1,2,3];
   for (var value1 in value) {
@@ -315,16 +269,12 @@
 @reflectiveTest
 class _IfTest extends PostfixCompletionTest {
   test_Else() async {
-    await _prepareCompletion(
-        '.else',
-        '''
+    await _prepareCompletion('.else', '''
 f(bool val) {
   val.else
 }
 ''');
-    _assertHasChange(
-        'Expand .else',
-        '''
+    _assertHasChange('Expand .else', '''
 f(bool val) {
   if (!val) {
     /*caret*/
@@ -334,16 +284,12 @@
   }
 
   test_if() async {
-    await _prepareCompletion(
-        '.if',
-        '''
+    await _prepareCompletion('.if', '''
 f() {
   3 < 4.if
 }
 ''');
-    _assertHasChange(
-        'Expand .if',
-        '''
+    _assertHasChange('Expand .if', '''
 f() {
   if (3 < 4) {
     /*caret*/
@@ -354,9 +300,7 @@
 
   @failingTest
   test_if_invalid() async {
-    await _prepareCompletion(
-        '.if',
-        '''
+    await _prepareCompletion('.if', '''
 f(List expr) {
   expr.if
 }
@@ -364,16 +308,12 @@
   }
 
   test_ifDynamic() async {
-    await _prepareCompletion(
-        '.if',
-        '''
+    await _prepareCompletion('.if', '''
 f(expr) {
   expr.if
 }
 ''');
-    _assertHasChange(
-        'Expand .if',
-        '''
+    _assertHasChange('Expand .if', '''
 f(expr) {
   if (expr) {
     /*caret*/
@@ -386,16 +326,12 @@
 @reflectiveTest
 class _NegateTest extends PostfixCompletionTest {
   test_negate() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(expr) {
   if (expr.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(expr) {
   if (!expr)
 }
@@ -404,9 +340,7 @@
 
   @failingTest
   test_negate_invalid() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(int expr) {
   if (expr.not)
 }
@@ -414,16 +348,12 @@
   }
 
   test_negateCascade() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(expr) {
   if (expr..a..b..c.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(expr) {
   if (!expr..a..b..c)
 }
@@ -431,16 +361,12 @@
   }
 
   test_negateExpr() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(int i, int j) {
   if (i + 3 < j - 4.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(int i, int j) {
   if (i + 3 >= j - 4)
 }
@@ -448,16 +374,12 @@
   }
 
   test_negateProperty() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(expr) {
   if (expr.a.b.c.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(expr) {
   if (!expr.a.b.c)
 }
@@ -465,16 +387,12 @@
   }
 
   test_notFalse() async {
-    await _prepareCompletion(
-        '!',
-        '''
+    await _prepareCompletion('!', '''
 f() {
   if (false!)
 }
 ''');
-    _assertHasChange(
-        'Expand !',
-        '''
+    _assertHasChange('Expand !', '''
 f() {
   if (true)
 }
@@ -482,16 +400,12 @@
   }
 
   test_notFunc() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 bool f() {
   if (f().not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 bool f() {
   if (!f())
 }
@@ -499,16 +413,12 @@
   }
 
   test_notTrue() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f() {
   if (true.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f() {
   if (false)
 }
@@ -519,17 +429,13 @@
 @reflectiveTest
 class _NotNullTest extends PostfixCompletionTest {
   test_nn() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f(expr) {
   var list = [1,2,3];
   list.nn
 }
 ''');
-    _assertHasChange(
-        'Expand .nn',
-        '''
+    _assertHasChange('Expand .nn', '''
 f(expr) {
   var list = [1,2,3];
   if (list != null) {
@@ -541,9 +447,7 @@
 
   @failingTest
   test_nn_invalid() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f(expr) {
   var list = [1,2,3];
 }.nn
@@ -551,16 +455,12 @@
   }
 
   test_nnDynamic() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f(expr) {
   expr.nn
 }
 ''');
-    _assertHasChange(
-        'Expand .nn',
-        '''
+    _assertHasChange('Expand .nn', '''
 f(expr) {
   if (expr != null) {
     /*caret*/
@@ -570,17 +470,13 @@
   }
 
   test_notnull() async {
-    await _prepareCompletion(
-        '.notnull',
-        '''
+    await _prepareCompletion('.notnull', '''
 f(expr) {
   var list = [1,2,3];
   list.notnull
 }
 ''');
-    _assertHasChange(
-        'Expand .notnull',
-        '''
+    _assertHasChange('Expand .notnull', '''
 f(expr) {
   var list = [1,2,3];
   if (list != null) {
@@ -591,17 +487,13 @@
   }
 
   test_null() async {
-    await _prepareCompletion(
-        '.null',
-        '''
+    await _prepareCompletion('.null', '''
 f(expr) {
   var list = [1,2,3];
   list.null
 }
 ''');
-    _assertHasChange(
-        'Expand .null',
-        '''
+    _assertHasChange('Expand .null', '''
 f(expr) {
   var list = [1,2,3];
   if (list == null) {
@@ -612,16 +504,12 @@
   }
 
   test_nullnn() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f() {
   null.nn
 }
 ''');
-    _assertHasChange(
-        'Expand .nn',
-        '''
+    _assertHasChange('Expand .nn', '''
 f() {
   if (false) {
     /*caret*/
@@ -631,16 +519,12 @@
   }
 
   test_nullnull() async {
-    await _prepareCompletion(
-        '.null',
-        '''
+    await _prepareCompletion('.null', '''
 f() {
   null.null
 }
 ''');
-    _assertHasChange(
-        'Expand .null',
-        '''
+    _assertHasChange('Expand .null', '''
 f() {
   if (true) {
     /*caret*/
@@ -653,16 +537,12 @@
 @reflectiveTest
 class _ParenTest extends PostfixCompletionTest {
   test_paren() async {
-    await _prepareCompletion(
-        '.par',
-        '''
+    await _prepareCompletion('.par', '''
 f(expr) {
   expr.par
 }
 ''');
-    _assertHasChange(
-        'Expand .par',
-        '''
+    _assertHasChange('Expand .par', '''
 f(expr) {
   (expr)
 }
@@ -673,16 +553,12 @@
 @reflectiveTest
 class _ReturnTest extends PostfixCompletionTest {
   test_return() async {
-    await _prepareCompletion(
-        '.return',
-        '''
+    await _prepareCompletion('.return', '''
 f(expr) {
   expr.return
 }
 ''');
-    _assertHasChange(
-        'Expand .return',
-        '''
+    _assertHasChange('Expand .return', '''
 f(expr) {
   return expr;
 }
@@ -693,16 +569,12 @@
 @reflectiveTest
 class _SwitchTest extends PostfixCompletionTest {
   test_return() async {
-    await _prepareCompletion(
-        '.switch',
-        '''
+    await _prepareCompletion('.switch', '''
 f(expr) {
   expr.switch
 }
 ''');
-    _assertHasChange(
-        'Expand .switch',
-        '''
+    _assertHasChange('Expand .switch', '''
 f(expr) {
   switch (expr) {
     /*caret*/
@@ -715,16 +587,12 @@
 @reflectiveTest
 class _TryTest extends PostfixCompletionTest {
   test_try() async {
-    await _prepareCompletion(
-        '.try',
-        '''
+    await _prepareCompletion('.try', '''
 f() {
   var x = 1.try
 }
 ''');
-    _assertHasChange(
-        'Expand .try',
-        '''
+    _assertHasChange('Expand .try', '''
 f() {
   try {
     var x = 1/*caret*/
@@ -738,9 +606,7 @@
   @failingTest
   test_try_invalid() async {
     // The semicolon is fine; this fails because of the do-statement.
-    await _prepareCompletion(
-        '.try',
-        '''
+    await _prepareCompletion('.try', '''
 f() {
   do {} while (true);.try
 }
@@ -748,9 +614,7 @@
   }
 
   test_tryMultiline() async {
-    await _prepareCompletion(
-        '.try',
-        '''
+    await _prepareCompletion('.try', '''
 f(arg) {
   arg
     ..first
@@ -759,9 +623,7 @@
     ..fourth.try
 }
 ''');
-    _assertHasChange(
-        'Expand .try',
-        '''
+    _assertHasChange('Expand .try', '''
 f(arg) {
   try {
     arg
@@ -777,16 +639,12 @@
   }
 
   test_tryon() async {
-    await _prepareCompletion(
-        '.tryon',
-        '''
+    await _prepareCompletion('.tryon', '''
 f() {
   var x = 1.tryon
 }
 ''');
-    _assertHasChange(
-        'Expand .tryon',
-        '''
+    _assertHasChange('Expand .tryon', '''
 f() {
   try {
     var x = 1/*caret*/
@@ -798,16 +656,12 @@
   }
 
   test_tryonThrowStatement() async {
-    await _prepareCompletion(
-        '.tryon',
-        '''
+    await _prepareCompletion('.tryon', '''
 f() {
   throw 'error';.tryon
 }
 ''');
-    _assertHasChange(
-        'Expand .tryon',
-        '''
+    _assertHasChange('Expand .tryon', '''
 f() {
   try {
     throw 'error';/*caret*/
@@ -819,16 +673,12 @@
   }
 
   test_tryonThrowString() async {
-    await _prepareCompletion(
-        '.tryon',
-        '''
+    await _prepareCompletion('.tryon', '''
 f() {
   throw 'error'.tryon
 }
 ''');
-    _assertHasChange(
-        'Expand .tryon',
-        '''
+    _assertHasChange('Expand .tryon', '''
 f() {
   try {
     throw 'error'/*caret*/
@@ -843,16 +693,12 @@
 @reflectiveTest
 class _WhileTest extends PostfixCompletionTest {
   test_while() async {
-    await _prepareCompletion(
-        '.while',
-        '''
+    await _prepareCompletion('.while', '''
 f(expr) {
   expr.while
 }
 ''');
-    _assertHasChange(
-        'Expand .while',
-        '''
+    _assertHasChange('Expand .while', '''
 f(expr) {
   while (expr) {
     /*caret*/
diff --git a/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart b/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart
index 01f3160..c3ddced 100644
--- a/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart
+++ b/pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart
@@ -1336,9 +1336,7 @@
 }
 ''',
         atEnd: true);
-    _assertHasChange(
-        'Insert a newline at the end of the current line',
-        '''
+    _assertHasChange('Insert a newline at the end of the current line', '''
 main() {
   int v = 1;
   ////
diff --git a/pkg/analysis_server/test/services/correction/assist_test.dart b/pkg/analysis_server/test/services/correction/assist_test.dart
index bdcdda7..7cab51e 100644
--- a/pkg/analysis_server/test/services/correction/assist_test.dart
+++ b/pkg/analysis_server/test/services/correction/assist_test.dart
@@ -128,9 +128,7 @@
   }
 
   test_addTypeAnnotation_BAD_privateType_closureParameter() async {
-    addSource(
-        '/my_lib.dart',
-        '''
+    addSource('/my_lib.dart', '''
 library my_lib;
 class A {}
 class _B extends A {}
@@ -146,9 +144,7 @@
   }
 
   test_addTypeAnnotation_BAD_privateType_declaredIdentifier() async {
-    addSource(
-        '/my_lib.dart',
-        '''
+    addSource('/my_lib.dart', '''
 library my_lib;
 class A {}
 class _B extends A {}
@@ -169,9 +165,7 @@
   test_addTypeAnnotation_BAD_privateType_list() async {
     // This is now failing because we're suggesting "List" rather than nothing.
     // Is it really better to produce nothing?
-    addSource(
-        '/my_lib.dart',
-        '''
+    addSource('/my_lib.dart', '''
 library my_lib;
 class A {}
 class _B extends A {}
@@ -183,10 +177,7 @@
   var v = getValues();
 }
 ''');
-    await assertHasAssistAt(
-        'var ',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 import 'my_lib.dart';
 main() {
   List v = getValues();
@@ -195,9 +186,7 @@
   }
 
   test_addTypeAnnotation_BAD_privateType_variable() async {
-    addSource(
-        '/my_lib.dart',
-        '''
+    addSource('/my_lib.dart', '''
 library my_lib;
 class A {}
 class _B extends A {}
@@ -218,10 +207,7 @@
   final f = 0;
 }
 ''');
-    await assertHasAssistAt(
-        'final ',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('final ', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 class A {
   final int f = 0;
 }
@@ -235,9 +221,7 @@
 }
 ''');
     await await assertHasAssistAt(
-        'var ',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+        'var ', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 class A {
   int f = 0;
 }
@@ -285,10 +269,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'item in',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('item in', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 class A<T> {
   main(List<List<T>> items) {
     for (List<T> item in items) {
@@ -306,20 +287,14 @@
 }
 ''');
     // on identifier
-    await assertHasAssistAt(
-        'item in',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('item in', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main(List<String> items) {
   for (String item in items) {
   }
 }
 ''');
     // on "for"
-    await assertHasAssistAt(
-        'for (',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('for (', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main(List<String> items) {
   for (String item in items) {
   }
@@ -328,9 +303,7 @@
   }
 
   test_addTypeAnnotation_declaredIdentifier_OK_addImport_dartUri() async {
-    addSource(
-        '/my_lib.dart',
-        r'''
+    addSource('/my_lib.dart', r'''
 import 'dart:async';
 List<Future<int>> getFutures() => null;
 ''');
@@ -341,10 +314,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'future in',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('future in', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 import 'dart:async';
 
 import 'my_lib.dart';
@@ -362,10 +332,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'item in',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('item in', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main(List<String> items) {
   for (final String item in items) {
   }
@@ -446,10 +413,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 class A {
   main(List<int> items) {
     List<int> v = items;
@@ -466,10 +430,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 class A<T> {
   main(List<T> items) {
     List<T> v = items;
@@ -479,9 +440,7 @@
   }
 
   test_addTypeAnnotation_local_OK_addImport_dartUri() async {
-    addSource(
-        '/my_lib.dart',
-        r'''
+    addSource('/my_lib.dart', r'''
 import 'dart:async';
 Future<int> getFutureInt() => null;
 ''');
@@ -491,10 +450,7 @@
   var v = getFutureInt();
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 import 'dart:async';
 
 import 'my_lib.dart';
@@ -506,9 +462,7 @@
 
   test_addTypeAnnotation_local_OK_addImport_notLibraryUnit() async {
     // prepare library
-    addSource(
-        '/my_lib.dart',
-        r'''
+    addSource('/my_lib.dart', r'''
 import 'dart:async';
 Future<int> getFutureInt() => null;
 ''');
@@ -537,9 +491,7 @@
     {
       var testFileEdit = change.getFileEdit('/app.dart');
       var resultCode = SourceEdit.applySequence(appCode, testFileEdit.edits);
-      expect(
-          resultCode,
-          '''
+      expect(resultCode, '''
 library my_app;
 import 'dart:async';
 
@@ -550,9 +502,7 @@
     {
       var testFileEdit = change.getFileEdit('/test.dart');
       var resultCode = SourceEdit.applySequence(testCode, testFileEdit.edits);
-      expect(
-          resultCode,
-          '''
+      expect(resultCode, '''
 part of my_app;
 main() {
   Future<int> v = getFutureInt();
@@ -562,14 +512,10 @@
   }
 
   test_addTypeAnnotation_local_OK_addImport_relUri() async {
-    addSource(
-        '/aa/bbb/lib_a.dart',
-        r'''
+    addSource('/aa/bbb/lib_a.dart', r'''
 class MyClass {}
 ''');
-    addSource(
-        '/ccc/lib_b.dart',
-        r'''
+    addSource('/ccc/lib_b.dart', r'''
 import '../aa/bbb/lib_a.dart';
 MyClass newMyClass() => null;
 ''');
@@ -579,10 +525,7 @@
   var v = newMyClass();
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 import 'aa/bbb/lib_a.dart';
 import 'ccc/lib_b.dart';
 main() {
@@ -597,10 +540,7 @@
   var v = () => 1;
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main() {
   Function v = () => 1;
 }
@@ -613,10 +553,7 @@
   var v = 0;
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main() {
   int v = 0;
 }
@@ -629,10 +566,7 @@
   var v = <String>[];
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main() {
   List<String> v = <String>[];
 }
@@ -647,10 +581,7 @@
   var x = f();
 }
 ''');
-    await assertHasAssistAt(
-        'x =',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('x =', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 class C {}
 C f() => null;
 main() {
@@ -665,10 +596,7 @@
   var abc = 0;
 }
 ''');
-    await assertHasAssistAt(
-        'bc',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('bc', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main() {
   int abc = 0;
 }
@@ -681,10 +609,7 @@
   var v = 0;
 }
 ''');
-    await assertHasAssistAt(
-        'var ',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 main() {
   int v = 0;
 }
@@ -699,10 +624,7 @@
   var v = getValue();
 }
 ''');
-    await assertHasAssistAt(
-        'var ',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 class _A {}
 _A getValue() => new _A();
 main() {
@@ -738,10 +660,7 @@
   foo((test) {});
 }
 ''');
-    await assertHasAssistAt(
-        'test',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('test', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 foo(f(int p)) {}
 main() {
   foo((int test) {});
@@ -767,10 +686,7 @@
     await resolveTestUnit('''
 var V = 0;
 ''');
-    await assertHasAssistAt(
-        'var ',
-        DartAssistKind.ADD_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION, '''
 int V = 0;
 ''');
   }
@@ -784,9 +700,7 @@
 List<int> readBytes() => <int>[];
 ''');
     await assertHasAssistAt(
-        'readBytes();',
-        DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE,
-        '''
+        'readBytes();', DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE, '''
 main() {
   List<int> bytes;
   var readBytes = readBytes();
@@ -818,10 +732,7 @@
   });
 }
 ''');
-    await assertHasAssistAt(
-        '345',
-        DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE,
-        '''
+    await assertHasAssistAt('345', DartAssistKind.ASSIGN_TO_LOCAL_VARIABLE, '''
 main() {
   print(() {
     var i = 12345;
@@ -890,9 +801,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'AAAAA',
-        DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK,
-        '''
+        'AAAAA', DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK, '''
 class A {
   /**
    * AAAAA
@@ -911,9 +820,7 @@
 class A {}
 ''');
     await assertHasAssistAt(
-        'nt]',
-        DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK,
-        '''
+        'nt]', DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK, '''
 /**
  * AAAAAAA [int] AAAAAAA
  */
@@ -931,9 +838,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'AAA [',
-        DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK,
-        '''
+        'AAA [', DartAssistKind.CONVERT_DOCUMENTATION_INTO_BLOCK, '''
 class A {
   /**
    * AAAAAAA [int] AAAAAAA
@@ -971,9 +876,7 @@
 class A {}
 ''');
     await assertHasAssistAt(
-        'nt]',
-        DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE,
-        '''
+        'nt]', DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE, '''
 /// AAAAAAA [int] AAAAAAA
 class A {}
 ''');
@@ -991,9 +894,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'AAA [',
-        DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE,
-        '''
+        'AAA [', DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE, '''
 class A {
   /// AAAAAAA [int] AAAAAAA
   /// BBBBBBBB BBBB BBBB
@@ -1014,9 +915,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'AAA [',
-        DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE,
-        '''
+        'AAA [', DartAssistKind.CONVERT_DOCUMENTATION_INTO_LINE, '''
 class A {
   /// AAAAAAA [int] AAAAAAA
   /// BBBBBBBB BBBB BBBB
@@ -1047,9 +946,7 @@
 }
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.CONVERT_FLUTTER_CHILD,
-        '''
+    await assertHasAssist(DartAssistKind.CONVERT_FLUTTER_CHILD, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Scaffold(
@@ -1092,9 +989,7 @@
 }
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.CONVERT_FLUTTER_CHILD,
-        '''
+    await assertHasAssist(DartAssistKind.CONVERT_FLUTTER_CHILD, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Scaffold(
@@ -1132,9 +1027,7 @@
 }
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.CONVERT_FLUTTER_CHILD,
-        '''
+    await assertHasAssist(DartAssistKind.CONVERT_FLUTTER_CHILD, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Scaffold(
@@ -1171,10 +1064,7 @@
   mmm() async => 123;
 }
 ''');
-    await assertHasAssistAt(
-        'mmm()',
-        DartAssistKind.CONVERT_INTO_BLOCK_BODY,
-        '''
+    await assertHasAssistAt('mmm()', DartAssistKind.CONVERT_INTO_BLOCK_BODY, '''
 class A {
   mmm() async {
     return 123;
@@ -1191,9 +1081,7 @@
 }
 ''');
     await assertHasAssistAt(
-        '() => 42',
-        DartAssistKind.CONVERT_INTO_BLOCK_BODY,
-        '''
+        '() => 42', DartAssistKind.CONVERT_INTO_BLOCK_BODY, '''
 setup(x) {}
 main() {
   setup(() {
@@ -1217,9 +1105,7 @@
 }
 ''');
     await assertHasAssistAt(
-        '() => print',
-        DartAssistKind.CONVERT_INTO_BLOCK_BODY,
-        '''
+        '() => print', DartAssistKind.CONVERT_INTO_BLOCK_BODY, '''
 setup(x) {}
 main() {
   setup(() {
@@ -1241,10 +1127,7 @@
   factory A() => null;
 }
 ''');
-    await assertHasAssistAt(
-        'A()',
-        DartAssistKind.CONVERT_INTO_BLOCK_BODY,
-        '''
+    await assertHasAssistAt('A()', DartAssistKind.CONVERT_INTO_BLOCK_BODY, '''
 class A {
   factory A() {
     return null;
@@ -1259,10 +1142,7 @@
   mmm() => 123;
 }
 ''');
-    await assertHasAssistAt(
-        'mmm()',
-        DartAssistKind.CONVERT_INTO_BLOCK_BODY,
-        '''
+    await assertHasAssistAt('mmm()', DartAssistKind.CONVERT_INTO_BLOCK_BODY, '''
 class A {
   mmm() {
     return 123;
@@ -1275,10 +1155,7 @@
     await resolveTestUnit('''
 fff() => 123;
 ''');
-    await assertHasAssistAt(
-        'fff()',
-        DartAssistKind.CONVERT_INTO_BLOCK_BODY,
-        '''
+    await assertHasAssistAt('fff()', DartAssistKind.CONVERT_INTO_BLOCK_BODY, '''
 fff() {
   return 123;
 }
@@ -1289,10 +1166,7 @@
     await resolveTestUnit('''
 fff() => 123;
 ''');
-    await assertHasAssistAt(
-        '23;',
-        DartAssistKind.CONVERT_INTO_BLOCK_BODY,
-        '''
+    await assertHasAssistAt('23;', DartAssistKind.CONVERT_INTO_BLOCK_BODY, '''
 fff() {
   return 123;
 }
@@ -1354,9 +1228,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'mmm',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        'mmm', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 class A {
   mmm() async => 42;
 }
@@ -1373,9 +1245,7 @@
 }
 ''');
     await assertHasAssistAt(
-        '42;',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        '42;', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 setup(x) {}
 main() {
   setup(() => 42);
@@ -1393,9 +1263,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'print(',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        'print(', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 setup(x) {}
 main() {
   setup(() => print('test'));
@@ -1412,9 +1280,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'A()',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        'A()', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 class A {
   factory A() => null;
 }
@@ -1428,9 +1294,7 @@
 }
 ''');
     await assertHasAssistAt(
-        '{',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        '{', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 fff() => 42;
 ''');
   }
@@ -1442,9 +1306,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'ff()',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        'ff()', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 fff() => 42;
 ''');
   }
@@ -1458,9 +1320,7 @@
 }
 ''');
     await assertHasAssistAt(
-        '{ // marker',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        '{ // marker', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 class A {
   m() => 42;
 }
@@ -1474,9 +1334,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'return',
-        DartAssistKind.CONVERT_INTO_EXPRESSION_BODY,
-        '''
+        'return', DartAssistKind.CONVERT_INTO_EXPRESSION_BODY, '''
 fff() => 42;
 ''');
   }
@@ -1511,9 +1369,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'aaa, ',
-        DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
-        '''
+        'aaa, ', DartAssistKind.CONVERT_TO_FIELD_PARAMETER, '''
 class A {
   int aaa2;
   int bbb2;
@@ -1531,9 +1387,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'test {',
-        DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
-        '''
+        'test {', DartAssistKind.CONVERT_TO_FIELD_PARAMETER, '''
 class A {
   int test2;
   A(this.test2) {
@@ -1551,9 +1405,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'test)',
-        DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
-        '''
+        'test)', DartAssistKind.CONVERT_TO_FIELD_PARAMETER, '''
 class A {
   int test;
   A(this.test) {
@@ -1571,9 +1423,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'bbb)',
-        DartAssistKind.CONVERT_TO_FIELD_PARAMETER,
-        '''
+        'bbb)', DartAssistKind.CONVERT_TO_FIELD_PARAMETER, '''
 class A {
   int aaa2;
   int bbb2;
@@ -1622,9 +1472,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'get foo',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+        'get foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 class A {
   final int foo = 1 + 2;
 }
@@ -1640,9 +1488,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'get foo',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+        'get foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 const myAnnotation = const Object();
 class A {
   @myAnnotation
@@ -1661,9 +1507,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'get foo',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+        'get foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 class A {
   void set foo(_) {}
 }
@@ -1680,9 +1524,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'get foo',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+        'get foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 class A {
   final int foo = 1 + 2;
 }
@@ -1696,9 +1538,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'get foo',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+        'get foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 class A {
   final int foo;
 }
@@ -1711,10 +1551,7 @@
   int get foo => 42;
 }
 ''');
-    await assertHasAssistAt(
-        'foo',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+    await assertHasAssistAt('foo', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 class A {
   final int foo = 42;
 }
@@ -1728,9 +1565,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'nt> get',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+        'nt> get', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 class A {
   final List<int> foo;
 }
@@ -1744,9 +1579,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'int get',
-        DartAssistKind.CONVERT_INTO_FINAL_FIELD,
-        '''
+        'int get', DartAssistKind.CONVERT_INTO_FINAL_FIELD, '''
 class A {
   final int foo = 42;
 }
@@ -1821,9 +1654,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'item in',
-        DartAssistKind.CONVERT_INTO_FOR_INDEX,
-        '''
+        'item in', DartAssistKind.CONVERT_INTO_FOR_INDEX, '''
 main(List<String> items) {
   for (int i = 0; i < items.length; i++) {
     String item = items[i];
@@ -1842,9 +1673,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'tring item',
-        DartAssistKind.CONVERT_INTO_FOR_INDEX,
-        '''
+        'tring item', DartAssistKind.CONVERT_INTO_FOR_INDEX, '''
 main(List<String> items) {
   for (int i = 0; i < items.length; i++) {
     String item = items[i];
@@ -1863,9 +1692,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'for (String',
-        DartAssistKind.CONVERT_INTO_FOR_INDEX,
-        '''
+        'for (String', DartAssistKind.CONVERT_INTO_FOR_INDEX, '''
 main(List<String> items) {
   for (int i = 0; i < items.length; i++) {
     String item = items[i];
@@ -1884,9 +1711,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'for (String',
-        DartAssistKind.CONVERT_INTO_FOR_INDEX,
-        '''
+        'for (String', DartAssistKind.CONVERT_INTO_FOR_INDEX, '''
 main(List<String> items) {
   for (int j = 0; j < items.length; j++) {
     String item = items[j];
@@ -1906,9 +1731,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'for (String',
-        DartAssistKind.CONVERT_INTO_FOR_INDEX,
-        '''
+        'for (String', DartAssistKind.CONVERT_INTO_FOR_INDEX, '''
 main(List<String> items) {
   for (int k = 0; k < items.length; k++) {
     String item = items[k];
@@ -1955,10 +1778,7 @@
   final int foo = 1 + 2;
 }
 ''');
-    await assertHasAssistAt(
-        'foo =',
-        DartAssistKind.CONVERT_INTO_GETTER,
-        '''
+    await assertHasAssistAt('foo =', DartAssistKind.CONVERT_INTO_GETTER, '''
 const myAnnotation = const Object();
 class A {
   @myAnnotation
@@ -1973,10 +1793,7 @@
   final foo = 42;
 }
 ''');
-    await assertHasAssistAt(
-        'foo =',
-        DartAssistKind.CONVERT_INTO_GETTER,
-        '''
+    await assertHasAssistAt('foo =', DartAssistKind.CONVERT_INTO_GETTER, '''
 class A {
   get foo => 42;
 }
@@ -2072,10 +1889,7 @@
   !(p is String);
 }
 ''');
-    await assertHasAssistAt(
-        'p is',
-        DartAssistKind.CONVERT_INTO_IS_NOT,
-        '''
+    await assertHasAssistAt('p is', DartAssistKind.CONVERT_INTO_IS_NOT, '''
 main(p) {
   p is! String;
 }
@@ -2088,10 +1902,7 @@
   !(p is String);
 }
 ''');
-    await assertHasAssistAt(
-        'String)',
-        DartAssistKind.CONVERT_INTO_IS_NOT,
-        '''
+    await assertHasAssistAt('String)', DartAssistKind.CONVERT_INTO_IS_NOT, '''
 main(p) {
   p is! String;
 }
@@ -2104,10 +1915,7 @@
   !(p is String);
 }
 ''');
-    await assertHasAssistAt(
-        'is String',
-        DartAssistKind.CONVERT_INTO_IS_NOT,
-        '''
+    await assertHasAssistAt('is String', DartAssistKind.CONVERT_INTO_IS_NOT, '''
 main(p) {
   p is! String;
 }
@@ -2120,10 +1928,7 @@
   !!(p is String);
 }
 ''');
-    await assertHasAssistAt(
-        'is String',
-        DartAssistKind.CONVERT_INTO_IS_NOT,
-        '''
+    await assertHasAssistAt('is String', DartAssistKind.CONVERT_INTO_IS_NOT, '''
 main(p) {
   !(p is! String);
 }
@@ -2136,10 +1941,7 @@
   !!(p is String);
 }
 ''');
-    await assertHasAssistAt(
-        '!(p',
-        DartAssistKind.CONVERT_INTO_IS_NOT,
-        '''
+    await assertHasAssistAt('!(p', DartAssistKind.CONVERT_INTO_IS_NOT, '''
 main(p) {
   !(p is! String);
 }
@@ -2152,10 +1954,7 @@
   !(p is String);
 }
 ''');
-    await assertHasAssistAt(
-        '!(p',
-        DartAssistKind.CONVERT_INTO_IS_NOT,
-        '''
+    await assertHasAssistAt('!(p', DartAssistKind.CONVERT_INTO_IS_NOT, '''
 main(p) {
   p is! String;
 }
@@ -2168,10 +1967,7 @@
   !(p is String);
 }
 ''');
-    await assertHasAssistAt(
-        '(p is',
-        DartAssistKind.CONVERT_INTO_IS_NOT,
-        '''
+    await assertHasAssistAt('(p is', DartAssistKind.CONVERT_INTO_IS_NOT, '''
 main(p) {
   p is! String;
 }
@@ -2228,9 +2024,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'isEmpty',
-        DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY,
-        '''
+        'isEmpty', DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY, '''
 main(String str) {
   str.isNotEmpty;
 }
@@ -2244,9 +2038,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'str.',
-        DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY,
-        '''
+        'str.', DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY, '''
 main(String str) {
   str.isNotEmpty;
 }
@@ -2260,9 +2052,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'isEmpty',
-        DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY,
-        '''
+        'isEmpty', DartAssistKind.CONVERT_INTO_IS_NOT_EMPTY, '''
 main(String str) {
   'text'.isNotEmpty;
 }
@@ -2278,9 +2068,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'test)',
-        DartAssistKind.CONVERT_TO_NORMAL_PARAMETER,
-        '''
+        'test)', DartAssistKind.CONVERT_TO_NORMAL_PARAMETER, '''
 class A {
   var test;
   A(test) : test = test {
@@ -2298,9 +2086,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'test)',
-        DartAssistKind.CONVERT_TO_NORMAL_PARAMETER,
-        '''
+        'test)', DartAssistKind.CONVERT_TO_NORMAL_PARAMETER, '''
 class A {
   int test;
   A(int test) : test = test {
@@ -2318,9 +2104,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'bbb)',
-        DartAssistKind.CONVERT_TO_NORMAL_PARAMETER,
-        '''
+        'bbb)', DartAssistKind.CONVERT_TO_NORMAL_PARAMETER, '''
 class A {
   double aaa;
   int bbb;
@@ -2403,10 +2187,7 @@
   print(a.test);
 }
 ''');
-    await assertHasAssistAt(
-        'test = 42',
-        DartAssistKind.ENCAPSULATE_FIELD,
-        '''
+    await assertHasAssistAt('test = 42', DartAssistKind.ENCAPSULATE_FIELD, '''
 class A {
   int _test = 42;
 
@@ -2432,10 +2213,7 @@
   print(a.test);
 }
 ''');
-    await assertHasAssistAt(
-        'test = 42',
-        DartAssistKind.ENCAPSULATE_FIELD,
-        '''
+    await assertHasAssistAt('test = 42', DartAssistKind.ENCAPSULATE_FIELD, '''
 class A {
   var _test = 42;
 
@@ -2493,9 +2271,7 @@
 }
 ''');
       await assertHasAssistAt(
-          initialOperator,
-          DartAssistKind.EXCHANGE_OPERANDS,
-          '''
+          initialOperator, DartAssistKind.EXCHANGE_OPERANDS, '''
 bool main(int a, int b) {
   return b $resultOperator a;
 }
@@ -2509,10 +2285,7 @@
   1 * 2 * 3 + 4;
 }
 ''');
-    await assertHasAssistAt(
-        '* 2',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt('* 2', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 * 3 * 1 + 4;
 }
@@ -2525,10 +2298,7 @@
   1 + 2 - 3 + 4;
 }
 ''');
-    await assertHasAssistAt(
-        '+ 2',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt('+ 2', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 1 - 3 + 4;
 }
@@ -2541,10 +2311,7 @@
   1 + 2 + 3;
 }
 ''');
-    await assertHasAssistAt(
-        '+ 2',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt('+ 2', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 3 + 1;
 }
@@ -2557,10 +2324,7 @@
   1 + 2 + 3;
 }
 ''');
-    await assertHasAssistAt(
-        '+ 3',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt('+ 3', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   3 + 1 + 2;
 }
@@ -2573,10 +2337,7 @@
   1 + 2;
 }
 ''');
-    await assertHasAssistAt(
-        ' 2',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt(' 2', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 1;
 }
@@ -2589,10 +2350,7 @@
   1 + 2;
 }
 ''');
-    await assertHasAssistAt(
-        '+ 2',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt('+ 2', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 1;
 }
@@ -2606,10 +2364,7 @@
 }
 ''');
     length = '1 + 2'.length;
-    await assertHasAssistAt(
-        '1 + 2',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt('1 + 2', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 1;
 }
@@ -2623,10 +2378,7 @@
 }
 ''');
     length = 2;
-    await assertHasAssistAt(
-        '+ 2',
-        DartAssistKind.EXCHANGE_OPERANDS,
-        '''
+    await assertHasAssistAt('+ 2', DartAssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 1;
 }
@@ -2666,10 +2418,7 @@
   return x.foo();
 }
 ''');
-    await assertHasAssistAt(
-        'import ',
-        DartAssistKind.IMPORT_ADD_SHOW,
-        '''
+    await assertHasAssistAt('import ', DartAssistKind.IMPORT_ADD_SHOW, '''
 import 'dart:math' show PI;
 main(x) {
   PI;
@@ -2687,10 +2436,7 @@
   max(1, 2);
 }
 ''');
-    await assertHasAssistAt(
-        'import ',
-        DartAssistKind.IMPORT_ADD_SHOW,
-        '''
+    await assertHasAssistAt('import ', DartAssistKind.IMPORT_ADD_SHOW, '''
 import 'dart:math' show E, PI, max;
 main() {
   PI;
@@ -2709,10 +2455,7 @@
   max(1, 2);
 }
 ''');
-    await assertHasAssistAt(
-        'art:math',
-        DartAssistKind.IMPORT_ADD_SHOW,
-        '''
+    await assertHasAssistAt('art:math', DartAssistKind.IMPORT_ADD_SHOW, '''
 import 'dart:math' show E, PI, max;
 main() {
   PI;
@@ -2851,10 +2594,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (',
-        DartAssistKind.INVERT_IF_STATEMENT,
-        '''
+    await assertHasAssistAt('if (', DartAssistKind.INVERT_IF_STATEMENT, '''
 main() {
   if (false) {
     1;
@@ -2874,10 +2614,7 @@
     1;
 }
 ''');
-    await assertHasAssistAt(
-        'if (',
-        DartAssistKind.INVERT_IF_STATEMENT,
-        '''
+    await assertHasAssistAt('if (', DartAssistKind.INVERT_IF_STATEMENT, '''
 main() {
   if (false)
     1;
@@ -2975,10 +2712,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (1 ==',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+    await assertHasAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if (1 == 1 && (2 == 2 || 3 == 3)) {
     print(0);
@@ -2999,9 +2733,7 @@
 bool isCheck() => false;
 ''');
     await assertHasAssistAt(
-        'if (isCheck',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+        'if (isCheck', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if (isCheck() && 2 == 2) {
     print(0);
@@ -3021,10 +2753,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (1 ==',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+    await assertHasAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if ((1 == 1 || 2 == 2) && 3 == 3) {
     print(0);
@@ -3043,10 +2772,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        '1 ==',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+    await assertHasAssistAt('1 ==', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3065,10 +2791,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (1 ==',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+    await assertHasAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3086,10 +2809,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (1 ==',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+    await assertHasAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3110,10 +2830,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (1 ==',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+    await assertHasAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(1);
@@ -3133,10 +2850,7 @@
     }
 }
 ''');
-    await assertHasAssistAt(
-        'if (1 ==',
-        DartAssistKind.JOIN_IF_WITH_INNER,
-        '''
+    await assertHasAssistAt('if (1 ==', DartAssistKind.JOIN_IF_WITH_INNER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3233,10 +2947,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (2 ==',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+    await assertHasAssistAt('if (2 ==', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if (1 == 1 && (2 == 2 || 3 == 3)) {
     print(0);
@@ -3257,9 +2968,7 @@
 bool isCheck() => false;
 ''');
     await assertHasAssistAt(
-        'if (isCheck',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+        'if (isCheck', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if (1 == 1 && isCheck()) {
     print(0);
@@ -3279,10 +2988,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (3 == 3',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+    await assertHasAssistAt('if (3 == 3', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if ((1 == 1 || 2 == 2) && 3 == 3) {
     print(0);
@@ -3301,10 +3007,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (2 == 2',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+    await assertHasAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3323,10 +3026,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (2 == 2',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+    await assertHasAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3344,10 +3044,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (2 == 2',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+    await assertHasAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3368,10 +3065,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        'if (2 == 2',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+    await assertHasAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(1);
@@ -3391,10 +3085,7 @@
     }
 }
 ''');
-    await assertHasAssistAt(
-        'if (2 == 2',
-        DartAssistKind.JOIN_IF_WITH_OUTER,
-        '''
+    await assertHasAssistAt('if (2 == 2', DartAssistKind.JOIN_IF_WITH_OUTER, '''
 main() {
   if (1 == 1 && 2 == 2) {
     print(0);
@@ -3494,10 +3185,7 @@
   v = 1;
 }
 ''');
-    await assertHasAssistAt(
-        'v =',
-        DartAssistKind.JOIN_VARIABLE_DECLARATION,
-        '''
+    await assertHasAssistAt('v =', DartAssistKind.JOIN_VARIABLE_DECLARATION, '''
 main() {
   var v = 1;
 }
@@ -3571,10 +3259,7 @@
   v = 1;
 }
 ''');
-    await assertHasAssistAt(
-        'v;',
-        DartAssistKind.JOIN_VARIABLE_DECLARATION,
-        '''
+    await assertHasAssistAt('v;', DartAssistKind.JOIN_VARIABLE_DECLARATION, '''
 main() {
   var v = 1;
 }
@@ -3589,9 +3274,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'int v',
-        DartAssistKind.JOIN_VARIABLE_DECLARATION,
-        '''
+        'int v', DartAssistKind.JOIN_VARIABLE_DECLARATION, '''
 main() {
   int v = 1;
 }
@@ -3606,9 +3289,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'var v',
-        DartAssistKind.JOIN_VARIABLE_DECLARATION,
-        '''
+        'var v', DartAssistKind.JOIN_VARIABLE_DECLARATION, '''
 main() {
   var v = 1;
 }
@@ -3640,9 +3321,7 @@
 startResize() {}
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.MOVE_FLUTTER_WIDGET_DOWN,
-        '''
+    await assertHasAssist(DartAssistKind.MOVE_FLUTTER_WIDGET_DOWN, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Scaffold(
@@ -3689,9 +3368,7 @@
 startResize() {}
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.MOVE_FLUTTER_WIDGET_UP,
-        '''
+    await assertHasAssist(DartAssistKind.MOVE_FLUTTER_WIDGET_UP, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Scaffold(
@@ -3719,10 +3396,7 @@
   int v = 1;
 }
 ''');
-    await assertHasAssistAt(
-        'v = ',
-        DartAssistKind.REMOVE_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v = ', DartAssistKind.REMOVE_TYPE_ANNOTATION, '''
 class A {
   var v = 1;
 }
@@ -3735,10 +3409,7 @@
   final int v = 1;
 }
 ''');
-    await assertHasAssistAt(
-        'v = ',
-        DartAssistKind.REMOVE_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('v = ', DartAssistKind.REMOVE_TYPE_ANNOTATION, '''
 class A {
   final v = 1;
 }
@@ -3760,10 +3431,7 @@
   int a = 1, b = 2;
 }
 ''');
-    await assertHasAssistAt(
-        'int ',
-        DartAssistKind.REMOVE_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('int ', DartAssistKind.REMOVE_TYPE_ANNOTATION, '''
 main() {
   var a = 1, b = 2;
 }
@@ -3776,10 +3444,7 @@
   const int v = 1;
 }
 ''');
-    await assertHasAssistAt(
-        'int ',
-        DartAssistKind.REMOVE_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('int ', DartAssistKind.REMOVE_TYPE_ANNOTATION, '''
 main() {
   const v = 1;
 }
@@ -3792,10 +3457,7 @@
   final int v = 1;
 }
 ''');
-    await assertHasAssistAt(
-        'int ',
-        DartAssistKind.REMOVE_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('int ', DartAssistKind.REMOVE_TYPE_ANNOTATION, '''
 main() {
   final v = 1;
 }
@@ -3814,10 +3476,7 @@
     await resolveTestUnit('''
 int V = 1;
 ''');
-    await assertHasAssistAt(
-        'int ',
-        DartAssistKind.REMOVE_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('int ', DartAssistKind.REMOVE_TYPE_ANNOTATION, '''
 var V = 1;
 ''');
   }
@@ -3826,10 +3485,7 @@
     await resolveTestUnit('''
 final int V = 1;
 ''');
-    await assertHasAssistAt(
-        'int ',
-        DartAssistKind.REMOVE_TYPE_ANNOTATION,
-        '''
+    await assertHasAssistAt('int ', DartAssistKind.REMOVE_TYPE_ANNOTATION, '''
 final V = 1;
 ''');
   }
@@ -3899,9 +3555,7 @@
 }
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.REPARENT_FLUTTER_LIST,
-        '''
+    await assertHasAssist(DartAssistKind.REPARENT_FLUTTER_LIST, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Container(
@@ -3977,9 +3631,7 @@
 }
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.REPARENT_FLUTTER_WIDGET,
-        '''
+    await assertHasAssist(DartAssistKind.REPARENT_FLUTTER_WIDGET, '''
 import 'package:flutter/src/widgets/framework.dart';
 class FakeFlutter {
   main() {
@@ -4026,9 +3678,7 @@
 }\r
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.REPARENT_FLUTTER_WIDGET,
-        '''
+    await assertHasAssist(DartAssistKind.REPARENT_FLUTTER_WIDGET, '''
 import 'package:flutter/src/widgets/framework.dart';\r
 class FakeFlutter {\r
   main() {\r
@@ -4066,9 +3716,7 @@
 }
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.REPARENT_FLUTTER_WIDGET,
-        '''
+    await assertHasAssist(DartAssistKind.REPARENT_FLUTTER_WIDGET, '''
 import 'package:flutter/src/widgets/framework.dart';
 class FakeFlutter {
   main() {
@@ -4095,9 +3743,7 @@
 }
 ''');
     _setCaretLocation();
-    await assertHasAssist(
-        DartAssistKind.REPARENT_FLUTTER_WIDGET,
-        '''
+    await assertHasAssist(DartAssistKind.REPARENT_FLUTTER_WIDGET, '''
 import 'package:flutter/src/widgets/framework.dart';
 class FakeFlutter {
   main() {
@@ -4136,9 +3782,7 @@
 ''');
     // on conditional
     await assertHasAssistAt(
-        '11 :',
-        DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
-        '''
+        '11 :', DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE, '''
 main() {
   var v;
   if (true) {
@@ -4150,9 +3794,7 @@
 ''');
     // on variable
     await assertHasAssistAt(
-        'v =',
-        DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
-        '''
+        'v =', DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE, '''
 main() {
   var v;
   if (true) {
@@ -4171,9 +3813,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'return ',
-        DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
-        '''
+        'return ', DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE, '''
 main() {
   if (true) {
     return 111;
@@ -4191,9 +3831,7 @@
 }
 ''');
     await assertHasAssistAt(
-        '11 :',
-        DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
-        '''
+        '11 :', DartAssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE, '''
 main() {
   int a = 1, vvv, b = 2;
   if (true) {
@@ -4258,9 +3896,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'if (true)',
-        DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
-        '''
+        'if (true)', DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL, '''
 main() {
   int vvv;
   vvv = true ? 111 : 222;
@@ -4279,9 +3915,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'if (true)',
-        DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
-        '''
+        'if (true)', DartAssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL, '''
 main() {
   return true ? 111 : 222;
 }
@@ -4344,10 +3978,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        '&& 2 == 2',
-        DartAssistKind.SPLIT_AND_CONDITION,
-        '''
+    await assertHasAssistAt('&& 2 == 2', DartAssistKind.SPLIT_AND_CONDITION, '''
 main() {
   if (1 == 1) {
     if (2 == 2 && 3 == 3) {
@@ -4369,10 +4000,7 @@
   }
 }
 ''');
-    await assertHasAssistAt(
-        '&& false',
-        DartAssistKind.SPLIT_AND_CONDITION,
-        '''
+    await assertHasAssistAt('&& false', DartAssistKind.SPLIT_AND_CONDITION, '''
 main() {
   if (true) {
     if (false) {
@@ -4393,10 +4021,7 @@
     print(0);
 }
 ''');
-    await assertHasAssistAt(
-        '&& false',
-        DartAssistKind.SPLIT_AND_CONDITION,
-        '''
+    await assertHasAssistAt('&& false', DartAssistKind.SPLIT_AND_CONDITION, '''
 main() {
   if (true)
     if (false)
@@ -4439,9 +4064,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'v =',
-        DartAssistKind.SPLIT_VARIABLE_DECLARATION,
-        '''
+        'v =', DartAssistKind.SPLIT_VARIABLE_DECLARATION, '''
 main() {
   var v;
   v = 1;
@@ -4456,9 +4079,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'int ',
-        DartAssistKind.SPLIT_VARIABLE_DECLARATION,
-        '''
+        'int ', DartAssistKind.SPLIT_VARIABLE_DECLARATION, '''
 main() {
   int v;
   v = 1;
@@ -4473,9 +4094,7 @@
 }
 ''');
     await assertHasAssistAt(
-        'var ',
-        DartAssistKind.SPLIT_VARIABLE_DECLARATION,
-        '''
+        'var ', DartAssistKind.SPLIT_VARIABLE_DECLARATION, '''
 main() {
   var v;
   v = 1;
@@ -4493,9 +4112,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_BLOCK,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_BLOCK, '''
 main() {
 // start
   {
@@ -4517,9 +4134,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_DO_WHILE,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_DO_WHILE, '''
 main() {
 // start
   do {
@@ -4541,9 +4156,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_FOR,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_FOR, '''
 main() {
 // start
   for (var v = init; condition; increment) {
@@ -4565,9 +4178,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_FOR_IN,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_FOR_IN, '''
 main() {
 // start
   for (var item in iterable) {
@@ -4589,9 +4200,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_IF,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_IF, '''
 main() {
 // start
   if (condition) {
@@ -4613,9 +4222,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_TRY_CATCH,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_TRY_CATCH, '''
 main() {
 // start
   try {
@@ -4639,9 +4246,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_TRY_FINALLY,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_TRY_FINALLY, '''
 main() {
 // start
   try {
@@ -4665,9 +4270,7 @@
 }
 ''');
     _setStartEndSelection();
-    await assertHasAssist(
-        DartAssistKind.SURROUND_WITH_WHILE,
-        '''
+    await assertHasAssist(DartAssistKind.SURROUND_WITH_WHILE, '''
 main() {
 // start
   while (condition) {
diff --git a/pkg/analysis_server/test/services/correction/fix_test.dart b/pkg/analysis_server/test/services/correction/fix_test.dart
index 18b6a7a..8f3d30e 100644
--- a/pkg/analysis_server/test/services/correction/fix_test.dart
+++ b/pkg/analysis_server/test/services/correction/fix_test.dart
@@ -65,9 +65,7 @@
   $lineWithTest
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   bool b = true;
   $lineWithTest
@@ -220,9 +218,7 @@
   Test(this.a);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_FIELD_FORMAL_PARAMETERS,
-        '''
+    await assertHasFix(DartFixKind.ADD_FIELD_FORMAL_PARAMETERS, '''
 class Test {
   final int a;
   final int b;
@@ -241,9 +237,7 @@
   Test();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_FIELD_FORMAL_PARAMETERS,
-        '''
+    await assertHasFix(DartFixKind.ADD_FIELD_FORMAL_PARAMETERS, '''
 class Test {
   final int a;
   final int b;
@@ -262,9 +256,7 @@
   Test([this.c]);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_FIELD_FORMAL_PARAMETERS,
-        '''
+    await assertHasFix(DartFixKind.ADD_FIELD_FORMAL_PARAMETERS, '''
 class Test {
   final int a;
   final int b;
@@ -291,9 +283,7 @@
   test(1);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_PARAMETER_POSITIONAL,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_PARAMETER_POSITIONAL, '''
 test([int i]) {}
 main() {
   test(1);
@@ -308,9 +298,7 @@
   test(1);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_PARAMETER_REQUIRED,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_PARAMETER_REQUIRED, '''
 test(int i, {int a}) {}
 main() {
   test(1);
@@ -325,9 +313,7 @@
   test(1, 2.0);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_PARAMETER_REQUIRED,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_PARAMETER_REQUIRED, '''
 test(int a, double d) {}
 main() {
   test(1, 2.0);
@@ -342,9 +328,7 @@
   test(1);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_PARAMETER_REQUIRED,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_PARAMETER_REQUIRED, '''
 test(int i) {}
 main() {
   test(1);
@@ -361,9 +345,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_PARAMETER_POSITIONAL,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_PARAMETER_POSITIONAL, '''
 class A {
   test(int a, [double d]) {}
   main() {
@@ -382,9 +364,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_PARAMETER_REQUIRED,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_PARAMETER_REQUIRED, '''
 class A {
   test(int a, double d) {}
   main() {
@@ -403,9 +383,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_PARAMETER_REQUIRED,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_PARAMETER_REQUIRED, '''
 class A {
   test(int i) {}
   main() {
@@ -453,9 +431,7 @@
 
   test_addMissingRequiredArg_cons_single() async {
     _addMetaPackageSource();
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 import 'package:meta/meta.dart';
 
@@ -486,9 +462,7 @@
   test_addMissingRequiredArg_cons_single_closure() async {
     _addMetaPackageSource();
 
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 import 'package:meta/meta.dart';
 
@@ -521,9 +495,7 @@
   test_addMissingRequiredArg_cons_single_closure_2() async {
     _addMetaPackageSource();
 
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 import 'package:meta/meta.dart';
 
@@ -556,9 +528,7 @@
   test_addMissingRequiredArg_cons_single_closure_3() async {
     _addMetaPackageSource();
 
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 import 'package:meta/meta.dart';
 
@@ -591,9 +561,7 @@
   test_addMissingRequiredArg_cons_single_closure_4() async {
     _addMetaPackageSource();
 
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 import 'package:meta/meta.dart';
 
@@ -626,9 +594,7 @@
   test_addMissingRequiredArg_cons_single_list() async {
     _addMetaPackageSource();
 
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 import 'package:meta/meta.dart';
 
@@ -667,9 +633,7 @@
   test(a: 3);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT, '''
 import 'package:meta/meta.dart';
 
 test({@required int a, @required int bcd}) {}
@@ -709,9 +673,7 @@
     change = filteredFixes.first.change;
     resultCode = SourceEdit.applySequence(testCode, change.edits[0].edits);
     // verify
-    expect(
-        resultCode,
-        '''
+    expect(resultCode, '''
 import 'package:meta/meta.dart';
 
 test({@required int a, @required int bcd}) {}
@@ -732,9 +694,7 @@
   test();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT, '''
 import 'package:meta/meta.dart';
 
 test({@required int abc}) {}
@@ -755,9 +715,7 @@
   test("foo");
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT, '''
 import 'package:meta/meta.dart';
 
 test(String x, {@required int abc}) {}
@@ -778,9 +736,7 @@
   test();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT,
-        '''
+    await assertHasFix(DartFixKind.ADD_MISSING_REQUIRED_ARGUMENT, '''
 import 'package:meta/meta.dart';
 
 test({@Required("Really who doesn't need an abc?") int abc}) {}
@@ -799,9 +755,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_ASYNC,
-        '''
+    await assertHasFix(DartFixKind.ADD_ASYNC, '''
 import 'dart:async';
 Future main(Stream<String> names) async {
   await for (String name in names) {
@@ -849,9 +803,7 @@
       expect(fileEdits, hasLength(1));
       resultCode = SourceEdit.applySequence(testCode, fileEdits[0].edits);
       // verify
-      expect(
-          resultCode,
-          '''
+      expect(resultCode, '''
 foo() {}
 main() async {
   await foo();
@@ -868,9 +820,7 @@
 foo() {}
 main() => await foo();
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_ASYNC,
-        '''
+    await assertHasFix(DartFixKind.ADD_ASYNC, '''
 foo() {}
 main() async => await foo();
 ''');
@@ -887,9 +837,7 @@
   return 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_ASYNC,
-        '''
+    await assertHasFix(DartFixKind.ADD_ASYNC, '''
 import 'dart:async';
 
 foo() {}
@@ -912,9 +860,7 @@
   return 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_ASYNC,
-        '''
+    await assertHasFix(DartFixKind.ADD_ASYNC, '''
 import 'dart:async';
 foo() {}
 Future<int> main() async {
@@ -935,9 +881,7 @@
   return 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_ASYNC,
-        '''
+    await assertHasFix(DartFixKind.ADD_ASYNC, '''
 foo() {}
 dynamic main() async {
   await foo();
@@ -957,9 +901,7 @@
   return 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_ASYNC,
-        '''
+    await assertHasFix(DartFixKind.ADD_ASYNC, '''
 foo() {}
 main() async {
   await foo();
@@ -974,9 +916,7 @@
   boolean v;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_BOOLEAN_WITH_BOOL,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_BOOLEAN_WITH_BOOL, '''
 main() {
   bool v;
 }
@@ -989,9 +929,7 @@
   x?.a.b.c;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_WITH_NULL_AWARE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_WITH_NULL_AWARE, '''
 main(x) {
   x?.a?.b?.c;
 }
@@ -1004,9 +942,7 @@
   x?.a.b();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_WITH_NULL_AWARE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_WITH_NULL_AWARE, '''
 main(x) {
   x?.a?.b();
 }
@@ -1019,9 +955,7 @@
   x?.a().b;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_WITH_NULL_AWARE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_WITH_NULL_AWARE, '''
 main(x) {
   x?.a()?.b;
 }
@@ -1037,9 +971,7 @@
   a.foo();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO_STATIC_ACCESS,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO_STATIC_ACCESS, '''
 class A {
   static foo() {}
 }
@@ -1050,17 +982,13 @@
   }
 
   test_changeToStaticAccess_method_importType() async {
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 class A {
   static foo() {}
 }
 ''');
-    addSource(
-        '/libB.dart',
-        r'''
+    addSource('/libB.dart', r'''
 library libB;
 import 'libA.dart';
 class B extends A {}
@@ -1071,9 +999,7 @@
   b.foo();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO_STATIC_ACCESS,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO_STATIC_ACCESS, '''
 import 'libA.dart';
 import 'libB.dart';
 main(B b) {
@@ -1089,9 +1015,7 @@
   f.wait([]);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO_STATIC_ACCESS,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO_STATIC_ACCESS, '''
 import 'dart:async' as pref;
 main(pref.Future f) {
   pref.Future.wait([]);
@@ -1108,9 +1032,7 @@
   a.foo;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO_STATIC_ACCESS,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO_STATIC_ACCESS, '''
 class A {
   static get foo => 42;
 }
@@ -1121,17 +1043,13 @@
   }
 
   test_changeToStaticAccess_property_importType() async {
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 class A {
   static get foo => null;
 }
 ''');
-    addSource(
-        '/libB.dart',
-        r'''
+    addSource('/libB.dart', r'''
 library libB;
 import 'libA.dart';
 class B extends A {}
@@ -1142,9 +1060,7 @@
   b.foo;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO_STATIC_ACCESS,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO_STATIC_ACCESS, '''
 import 'libA.dart';
 import 'libB.dart';
 main(B b) {
@@ -1178,9 +1094,7 @@
   String v = <int>[];
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TYPE_ANNOTATION,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TYPE_ANNOTATION, '''
 main() {
   List<int> v = <int>[];
 }
@@ -1193,9 +1107,7 @@
   String v = 'abc'.length;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TYPE_ANNOTATION,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TYPE_ANNOTATION, '''
 main() {
   int v = 'abc'.length;
 }
@@ -1208,9 +1120,7 @@
   Test v = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CLASS,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CLASS, '''
 main() {
   Test v = null;
 }
@@ -1253,9 +1163,7 @@
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/lib.dart');
-    expect(
-        SourceEdit.applySequence(libCode, fileEdit.edits),
-        r'''
+    expect(SourceEdit.applySequence(libCode, fileEdit.edits), r'''
 library my.lib;
 
 class A {}
@@ -1274,9 +1182,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CLASS,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CLASS, '''
 f() {
   g() {
     Test v = null;
@@ -1295,9 +1201,7 @@
   var a = [Test];
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CLASS,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CLASS, '''
 main() {
   var a = [Test];
 }
@@ -1319,9 +1223,7 @@
 @MyAnnotation(int, const [Test])
 main() {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CLASS,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CLASS, '''
 class MyAnnotation {
   const MyAnnotation(a, b);
 }
@@ -1345,9 +1247,7 @@
   final int c;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR_FOR_FINAL_FIELDS,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR_FOR_FINAL_FIELDS, '''
 class Test {
   final int a;
   final int b = 2;
@@ -1369,9 +1269,7 @@
   new A(1, 2.0);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR, '''
 class A {
   int field;
 
@@ -1394,9 +1292,7 @@
   new A.named(1, 2.0);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR, '''
 class A {
   A.named(int i, double d);
 
@@ -1416,9 +1312,7 @@
   new A.named(1);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR, '''
 class A {
   A.named(int i);
 }
@@ -1454,9 +1348,7 @@
   B() {}
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION,
-        '''
+    await assertHasFix(DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION, '''
 class A {
   A(bool p1, int p2, double p3, String p4, {p5});
 }
@@ -1476,9 +1368,7 @@
   B() : field = 42 {}
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION,
-        '''
+    await assertHasFix(DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION, '''
 class A {
   A(int p);
 }
@@ -1498,9 +1388,7 @@
   B() {}
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION,
-        '''
+    await assertHasFix(DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION, '''
 class A {
   A.named(int p);
 }
@@ -1531,9 +1419,7 @@
   B();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION,
-        '''
+    await assertHasFix(DartFixKind.ADD_SUPER_CONSTRUCTOR_INVOCATION, '''
 class A<T> {
   A(T p);
 }
@@ -1554,9 +1440,7 @@
   void existingMethod() {}
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR_SUPER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR_SUPER, '''
 class A {
   A(p1, int p2, List<String> p3, [int p4]);
 }
@@ -1582,9 +1466,7 @@
   void existingMethod() {}
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR_SUPER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR_SUPER, '''
 class A {
   int _field;
   A(this._field);
@@ -1600,15 +1482,11 @@
   }
 
   test_createConstructorSuperImplicit_importType() async {
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 class A {}
 ''');
-    addSource(
-        '/libB.dart',
-        r'''
+    addSource('/libB.dart', r'''
 library libB;
 import 'libA.dart';
 class B {
@@ -1620,9 +1498,7 @@
 class C extends B {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR_SUPER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR_SUPER, '''
 import 'libA.dart';
 import 'libB.dart';
 class C extends B {
@@ -1642,9 +1518,7 @@
   void existingMethod() {}
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR_SUPER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR_SUPER, '''
 class A {
   A.named(p1, int p2);
 }
@@ -1677,9 +1551,7 @@
 }
 class D extends C<int> {
 }''');
-    await assertHasFix(
-        DartFixKind.CREATE_CONSTRUCTOR_SUPER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_CONSTRUCTOR_SUPER, '''
 class C<T> {
   final T x;
   C(this.x);
@@ -1724,9 +1596,7 @@
   int v = c.b.a.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 }
@@ -1750,9 +1620,7 @@
   int v = a.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 }
@@ -1773,9 +1641,7 @@
 class B {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   B b;
   void f(Object p) {
@@ -1798,9 +1664,7 @@
   int v = a.self.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 
@@ -1822,9 +1686,7 @@
 }
 f(String s) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   String test;
 
@@ -1844,9 +1706,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 
@@ -1865,9 +1725,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   var test;
 
@@ -1887,9 +1745,7 @@
   int v = x.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 }
@@ -1909,9 +1765,7 @@
   x.test = 0;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 }
@@ -1923,15 +1777,11 @@
   }
 
   test_createField_importType() async {
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 class A {}
 ''');
-    addSource(
-        '/libB.dart',
-        r'''
+    addSource('/libB.dart', r'''
 library libB;
 import 'libA.dart';
 A getA() => null;
@@ -1944,9 +1794,7 @@
   c.test = getA();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 import 'libA.dart';
 import 'libB.dart';
 class C {
@@ -1964,9 +1812,7 @@
   C(this.text);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class C {
   var text;
 
@@ -1981,9 +1827,7 @@
   C(String this.text);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class C {
   String text;
 
@@ -2003,9 +1847,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   List test;
 }
@@ -2028,9 +1870,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A<T> {
   List<T> items;
 
@@ -2055,9 +1895,7 @@
   a.test = 5;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int aaa;
   int zzz;
@@ -2081,9 +1919,7 @@
   a.test = 5;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 
@@ -2103,9 +1939,7 @@
   A.test = 5;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   static int test;
 }
@@ -2123,9 +1957,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   int test;
 
@@ -2144,9 +1976,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FIELD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FIELD, '''
 class A {
   static int test;
 
@@ -2253,18 +2083,14 @@
   }
 
   test_createFile_forPart_inPackageLib() async {
-    provider.newFile(
-        '/my/pubspec.yaml',
-        r'''
+    provider.newFile('/my/pubspec.yaml', r'''
 name: my_test
 ''');
     testFile = '/my/lib/test.dart';
-    addTestSource(
-        '''
+    addTestSource('''
 library my.lib;
 part 'my_part.dart';
-''',
-        Uri.parse('package:my/test.dart'));
+''', Uri.parse('package:my/test.dart'));
     // configure SourceFactory
     UriResolver pkgResolver = new PackageMapUriResolver(provider, {
       'my': <Folder>[provider.getResource('/my/lib')],
@@ -2305,9 +2131,7 @@
   int v = x.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   int get test => null;
 }
@@ -2331,9 +2155,7 @@
   int v = a.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   int existingField;
 
@@ -2363,9 +2185,7 @@
   int v = c.b.a.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   int get test => null;
 }
@@ -2389,9 +2209,7 @@
   int v = a.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   int get test => null;
 }
@@ -2412,9 +2230,7 @@
 class B {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   B b;
   void f(Object p) {
@@ -2437,9 +2253,7 @@
   int v = a.self.test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   A get self => this;
 
@@ -2472,9 +2286,7 @@
 }
 f(String s) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   String get test => null;
 
@@ -2505,9 +2317,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   int get test => null;
 
@@ -2526,9 +2336,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_GETTER,
-        '''
+    await assertHasFix(DartFixKind.CREATE_GETTER, '''
 class A {
   get test => null;
 
@@ -2547,9 +2355,7 @@
   foo(bar);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_LOCAL_VARIABLE,
-        '''
+    await assertHasFix(DartFixKind.CREATE_LOCAL_VARIABLE, '''
 typedef MY_FUNCTION(int p);
 foo(MY_FUNCTION f) {}
 main() {
@@ -2575,9 +2381,7 @@
   int a = test;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_LOCAL_VARIABLE,
-        '''
+    await assertHasFix(DartFixKind.CREATE_LOCAL_VARIABLE, '''
 main() {
   int test;
   int a = test;
@@ -2593,9 +2397,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_LOCAL_VARIABLE,
-        '''
+    await assertHasFix(DartFixKind.CREATE_LOCAL_VARIABLE, '''
 main() {
   bool test;
   if (!test) {
@@ -2612,9 +2414,7 @@
 }
 f(String p) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_LOCAL_VARIABLE,
-        '''
+    await assertHasFix(DartFixKind.CREATE_LOCAL_VARIABLE, '''
 main() {
   String test;
   f(test);
@@ -2631,9 +2431,7 @@
   test.add('hello');
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_LOCAL_VARIABLE,
-        '''
+    await assertHasFix(DartFixKind.CREATE_LOCAL_VARIABLE, '''
 main() {
   var test;
   test.add('hello');
@@ -2648,9 +2446,7 @@
   test = 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_LOCAL_VARIABLE,
-        '''
+    await assertHasFix(DartFixKind.CREATE_LOCAL_VARIABLE, '''
 main() {
   var test = 42;
 }
@@ -2663,9 +2459,7 @@
   test += 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_LOCAL_VARIABLE,
-        '''
+    await assertHasFix(DartFixKind.CREATE_LOCAL_VARIABLE, '''
 main() {
   int test;
   test += 42;
@@ -2678,9 +2472,7 @@
 class C implements Function {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_METHOD_CALL,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_METHOD_CALL, '''
 class C implements Function {
   call() {
     // TODO: implement call
@@ -2698,9 +2490,7 @@
 class B implements A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 class A {
   var f;
 }
@@ -2723,9 +2513,7 @@
 class MyEmulator extends Emulator {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 typedef int Binary(int left, int right);
 
 abstract class Emulator {
@@ -2750,9 +2538,7 @@
 class B extends A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 abstract class A {
   forEach(int f(double p1, String p2));
 }
@@ -2778,9 +2564,7 @@
 class Test extends IterableMixin<int> {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 class Iterator<T> {
 }
 
@@ -2805,9 +2589,7 @@
 class Test<V> extends ItemProvider<V> {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 abstract class ItemProvider<T> {
   List<T> getItems();
 }
@@ -2831,9 +2613,7 @@
 class B extends A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 abstract class A {
   get g1;
   int get g2;
@@ -2861,9 +2641,7 @@
 class B extends A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 import 'dart:async' as aaa;
 abstract class A {
   Map<aaa.Future, List<aaa.Future>> g(aaa.Future p);
@@ -2889,9 +2667,7 @@
 class B implements A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 class A {
   int ma;
   void mb() {}
@@ -2994,9 +2770,7 @@
 
 class B extends A {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 abstract class A {
   void foo();
 }
@@ -3022,9 +2796,7 @@
 class B implements A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 class C<T> {}
 class V<E> {}
 
@@ -3051,9 +2823,7 @@
 class B extends A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 abstract class A {
   int operator [](int index);
   void operator []=(int index, String value);
@@ -3084,9 +2854,7 @@
 class B extends A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_MISSING_OVERRIDES,
-        '''
+    await assertHasFix(DartFixKind.CREATE_MISSING_OVERRIDES, '''
 abstract class A {
   set s1(x);
   set s2(int x);
@@ -3123,9 +2891,7 @@
   existing() {}
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_NO_SUCH_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_NO_SUCH_METHOD, '''
 abstract class A {
   m1();
   int m2();
@@ -3153,9 +2919,7 @@
   a..ma().useFunction(test);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 class A {
   B ma() => null;
 }
@@ -3180,9 +2944,7 @@
 }
 useFunction({Function g}) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   useFunction(g: test);
 }
@@ -3200,9 +2962,7 @@
 }
 useFunction(int g(a, b)) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   useFunction(test);
 }
@@ -3220,9 +2980,7 @@
 }
 useFunction(int g(double a, String b)) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   useFunction(test);
 }
@@ -3240,9 +2998,7 @@
 }
 useFunction({int g(double a, String b)}) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   useFunction(g: test);
 }
@@ -3254,15 +3010,11 @@
   }
 
   test_creationFunction_forFunctionType_importType() async {
-    addSource(
-        '/libA.dart',
-        r'''
+    addSource('/libA.dart', r'''
 library libA;
 class A {}
 ''');
-    addSource(
-        '/libB.dart',
-        r'''
+    addSource('/libB.dart', r'''
 library libB;
 import 'libA.dart';
 useFunction(int g(A a)) {}
@@ -3273,9 +3025,7 @@
   useFunction(test);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 import 'libA.dart';
 import 'libB.dart';
 main() {
@@ -3296,9 +3046,7 @@
 }
 useFunction(int g(double a, String b)) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   static foo() {
     useFunction(test);
@@ -3319,9 +3067,7 @@
 }
 useFunction(int g(double a, String b)) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   var f;
   A() : f = useFunction(test);
@@ -3342,9 +3088,7 @@
 }
 useFunction(int g(double a, String b)) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 main(A a) {
   useFunction(a.test);
 }
@@ -3366,9 +3110,7 @@
 }
 useFunction(int g(double a, String b)) {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 main(A a) {
   useFunction(a.test);
 }
@@ -3412,9 +3154,7 @@
   print(0)
 }
 ''');
-    await assertHasFix(
-        DartFixKind.INSERT_SEMICOLON,
-        '''
+    await assertHasFix(DartFixKind.INSERT_SEMICOLON, '''
 main() {
   print(0);
 }
@@ -3429,9 +3169,7 @@
 import 'dart:async';
 var v;int main() async => 0;
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_RETURN_TYPE_FUTURE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_RETURN_TYPE_FUTURE, '''
 import 'dart:async';
 var v;Future<int> main() async => 0;
 ''');
@@ -3446,9 +3184,7 @@
 int main() async {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_RETURN_TYPE_FUTURE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_RETURN_TYPE_FUTURE, '''
 library main;
 
 import 'dart:async';
@@ -3467,9 +3203,7 @@
 int main() async {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_RETURN_TYPE_FUTURE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_RETURN_TYPE_FUTURE, '''
 import 'dart:async' as al;
 al.Future<int> main() async {
 }
@@ -3485,9 +3219,7 @@
 List<int> main() async {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_RETURN_TYPE_FUTURE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_RETURN_TYPE_FUTURE, '''
 import 'dart:async';
 Future<List<int>> main() async {
 }
@@ -3503,9 +3235,7 @@
 void main() async {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_RETURN_TYPE_FUTURE,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_RETURN_TYPE_FUTURE, '''
 import 'dart:async';
 Future main() async {
 }
@@ -3519,18 +3249,14 @@
   Test test = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'package:my_pkg/b.dart';
 
 main() {
   Test test = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT2,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT2, '''
 import 'package:my_pkg/a.dart';
 
 main() {
@@ -3547,18 +3273,14 @@
   Test test = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'package:my_pkg/b.dart';
 
 main() {
   Test test = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT2,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT2, '''
 import 'package:my_pkg/a.dart';
 
 main() {
@@ -3575,18 +3297,14 @@
   Test test = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT2,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT2, '''
 import 'package:my_pkg/b.dart';
 
 main() {
   Test test = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT3,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT3, '''
 import 'package:my_pkg/src/a.dart';
 
 main() {
@@ -3622,9 +3340,7 @@
   }
 
   test_importLibraryProject_withClass_annotation() async {
-    addSource(
-        '/lib.dart',
-        '''
+    addSource('/lib.dart', '''
 library lib;
 class Test {
   const Test(int p);
@@ -3635,9 +3351,7 @@
 main() {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'lib.dart';
 
 @Test(0)
@@ -3647,9 +3361,7 @@
   }
 
   test_importLibraryProject_withClass_constInstanceCreation() async {
-    addSource(
-        '/lib.dart',
-        '''
+    addSource('/lib.dart', '''
 class Test {
   const Test();
 }
@@ -3659,9 +3371,7 @@
   const Test();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'lib.dart';
 
 main() {
@@ -3672,15 +3382,11 @@
 
   test_importLibraryProject_withClass_hasOtherLibraryWithPrefix() async {
     testFile = '/project/bin/test.dart';
-    addSource(
-        '/project/bin/a.dart',
-        '''
+    addSource('/project/bin/a.dart', '''
 library a;
 class One {}
 ''');
-    addSource(
-        '/project/bin/b.dart',
-        '''
+    addSource('/project/bin/b.dart', '''
 library b;
 class One {}
 class Two {}
@@ -3692,9 +3398,7 @@
   new One();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'a.dart';
 import 'b.dart' show Two;
 main () {
@@ -3706,9 +3410,7 @@
 
   test_importLibraryProject_withClass_inParentFolder() async {
     testFile = '/project/bin/test.dart';
-    addSource(
-        '/project/lib.dart',
-        '''
+    addSource('/project/lib.dart', '''
 library lib;
 class Test {}
 ''');
@@ -3717,9 +3419,7 @@
   Test t = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import '../lib.dart';
 
 main() {
@@ -3730,9 +3430,7 @@
 
   test_importLibraryProject_withClass_inRelativeFolder() async {
     testFile = '/project/bin/test.dart';
-    addSource(
-        '/project/lib/sub/folder/lib.dart',
-        '''
+    addSource('/project/lib/sub/folder/lib.dart', '''
 library lib;
 class Test {}
 ''');
@@ -3741,9 +3439,7 @@
   Test t = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import '../lib/sub/folder/lib.dart';
 
 main() {
@@ -3754,9 +3450,7 @@
 
   test_importLibraryProject_withClass_inSameFolder() async {
     testFile = '/project/bin/test.dart';
-    addSource(
-        '/project/bin/lib.dart',
-        '''
+    addSource('/project/bin/lib.dart', '''
 library lib;
 class Test {}
 ''');
@@ -3765,9 +3459,7 @@
   Test t = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'lib.dart';
 
 main() {
@@ -3777,9 +3469,7 @@
   }
 
   test_importLibraryProject_withFunction() async {
-    addSource(
-        '/lib.dart',
-        '''
+    addSource('/lib.dart', '''
 library lib;
 myFunction() {}
 ''');
@@ -3788,9 +3478,7 @@
   myFunction();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'lib.dart';
 
 main() {
@@ -3800,9 +3488,7 @@
   }
 
   test_importLibraryProject_withFunction_unresolvedMethod() async {
-    addSource(
-        '/lib.dart',
-        '''
+    addSource('/lib.dart', '''
 library lib;
 myFunction() {}
 ''');
@@ -3813,9 +3499,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'lib.dart';
 
 class A {
@@ -3828,9 +3512,7 @@
 
   test_importLibraryProject_withFunctionTypeAlias() async {
     testFile = '/project/bin/test.dart';
-    addSource(
-        '/project/bin/lib.dart',
-        '''
+    addSource('/project/bin/lib.dart', '''
 library lib;
 typedef MyFunction();
 ''');
@@ -3839,9 +3521,7 @@
   MyFunction t = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'lib.dart';
 
 main() {
@@ -3851,9 +3531,7 @@
   }
 
   test_importLibraryProject_withTopLevelVariable() async {
-    addSource(
-        '/lib.dart',
-        '''
+    addSource('/lib.dart', '''
 library lib;
 int MY_VAR = 42;
 ''');
@@ -3862,9 +3540,7 @@
   print(MY_VAR);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PROJECT1,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PROJECT1, '''
 import 'lib.dart';
 
 main() {
@@ -3879,9 +3555,7 @@
   p as Future;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 main(p) {
@@ -3896,9 +3570,7 @@
   Future.wait(null);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 main() {
@@ -3913,9 +3585,7 @@
   p is Future;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 main(p) {
@@ -3930,9 +3600,7 @@
   var a = [Future];
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 main() {
@@ -3952,9 +3620,7 @@
 @MyAnnotation(int, const [Future])
 main() {}
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 class MyAnnotation {
@@ -3971,9 +3637,7 @@
   Future f = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 main() {
@@ -3988,9 +3652,7 @@
   Future.wait;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 main() {
@@ -4005,9 +3667,7 @@
   List<Future> futures = [];
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:async';
 
 main() {
@@ -4022,9 +3682,7 @@
   print(PI);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:math';
 
 main() {
@@ -4039,9 +3697,7 @@
 main() {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SDK,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SDK, '''
 import 'dart:math';
 
 @PI
@@ -4052,9 +3708,7 @@
 
   test_importLibraryShow_project() async {
     testFile = '/project/bin/test.dart';
-    addSource(
-        '/project/bin/lib.dart',
-        '''
+    addSource('/project/bin/lib.dart', '''
 class A {}
 class B {}
 ''');
@@ -4066,9 +3720,7 @@
 }
 ''');
     await assertNoFix(DartFixKind.IMPORT_LIBRARY_PROJECT1);
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SHOW,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SHOW, '''
 import 'lib.dart' show A, B;
 main() {
   A a;
@@ -4086,9 +3738,7 @@
 }
 ''');
     await assertNoFix(DartFixKind.IMPORT_LIBRARY_SDK);
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_SHOW,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_SHOW, '''
 import 'dart:async' show Future, Stream;
 main() {
   Stream s = null;
@@ -4106,9 +3756,7 @@
   C c = C.c();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.INVOKE_CONSTRUCTOR_USING_NEW,
-        '''
+    await assertHasFix(DartFixKind.INVOKE_CONSTRUCTOR_USING_NEW, '''
 class C {
   C.c();
 }
@@ -4124,9 +3772,7 @@
   p is! Null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.USE_NOT_EQ_NULL,
-        '''
+    await assertHasFix(DartFixKind.USE_NOT_EQ_NULL, '''
 main(p) {
   p != null;
 }
@@ -4139,9 +3785,7 @@
   p is Null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.USE_EQ_EQ_NULL,
-        '''
+    await assertHasFix(DartFixKind.USE_EQ_EQ_NULL, '''
 main(p) {
   p == null;
 }
@@ -4154,9 +3798,7 @@
   m();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.MAKE_CLASS_ABSTRACT,
-        '''
+    await assertHasFix(DartFixKind.MAKE_CLASS_ABSTRACT, '''
 abstract class A {
   m();
 }
@@ -4171,9 +3813,7 @@
 class B extends A {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.MAKE_CLASS_ABSTRACT,
-        '''
+    await assertHasFix(DartFixKind.MAKE_CLASS_ABSTRACT, '''
 abstract class A {
   m();
 }
@@ -4191,9 +3831,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.MAKE_FIELD_NOT_FINAL,
-        '''
+    await assertHasFix(DartFixKind.MAKE_FIELD_NOT_FINAL, '''
 class A {
   int fff = 1;
   main() {
@@ -4212,9 +3850,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.MAKE_FIELD_NOT_FINAL,
-        '''
+    await assertHasFix(DartFixKind.MAKE_FIELD_NOT_FINAL, '''
 class A {
   var fff = 1;
   main() {
@@ -4243,9 +3879,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.ADD_NE_NULL,
-        '''
+    await assertHasFix(DartFixKind.ADD_NE_NULL, '''
 main(String p) {
   if (p != null) {
     print(p);
@@ -4262,9 +3896,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_DEAD_CODE,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_DEAD_CODE, '''
 main(int p) {
   if (true) {
     print(1);
@@ -4281,9 +3913,7 @@
   print(1);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_DEAD_CODE,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_DEAD_CODE, '''
 int main() {
   print(0);
   return 42;
@@ -4300,9 +3930,7 @@
   print(2);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_DEAD_CODE,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_DEAD_CODE, '''
 int main() {
   print(0);
   return 42;
@@ -4316,9 +3944,7 @@
   int get foo() => 0;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_PARAMETERS_IN_GETTER_DECLARATION,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_PARAMETERS_IN_GETTER_DECLARATION, '''
 class A {
   int get foo => 0;
 }
@@ -4334,9 +3960,7 @@
   a.foo();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_PARENTHESIS_IN_GETTER_INVOCATION,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_PARENTHESIS_IN_GETTER_INVOCATION, '''
 class A {
   int get foo => 0;
 }
@@ -4354,9 +3978,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_UNNECESSARY_CAST,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_UNNECESSARY_CAST, '''
 main(Object p) {
   if (p is String) {
     String v = p;
@@ -4375,9 +3997,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_UNUSED_CATCH_CLAUSE,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_UNUSED_CATCH_CLAUSE, '''
 main() {
   try {
     throw 42;
@@ -4397,9 +4017,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_UNUSED_CATCH_STACK,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_UNUSED_CATCH_STACK, '''
 main() {
   try {
     throw 42;
@@ -4415,9 +4033,7 @@
 main() {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_UNUSED_IMPORT,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_UNUSED_IMPORT, '''
 main() {
 }
 ''');
@@ -4431,9 +4047,7 @@
   Future f;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_UNUSED_IMPORT,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_UNUSED_IMPORT, '''
 import 'dart:async';
 
 main() {
@@ -4449,9 +4063,7 @@
 main() {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REMOVE_UNUSED_IMPORT,
-        '''
+    await assertHasFix(DartFixKind.REMOVE_UNUSED_IMPORT, '''
 main() {
 }
 ''');
@@ -4466,9 +4078,7 @@
   Map<String, var> m;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.REPLACE_VAR_WITH_DYNAMIC,
-        '''
+    await assertHasFix(DartFixKind.REPLACE_VAR_WITH_DYNAMIC, '''
 class A {
   Map<String, dynamic> m;
 }
@@ -4482,9 +4092,7 @@
 }
 const a = new A();
 ''');
-    await assertHasFix(
-        DartFixKind.USE_CONST,
-        '''
+    await assertHasFix(DartFixKind.USE_CONST, '''
 class A {
   const A();
 }
@@ -4499,9 +4107,7 @@
   c.Fture v = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 import 'dart:async' as c;
 main() {
   c.Future v = null;
@@ -4515,9 +4121,7 @@
   Stirng s = 'abc';
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 main() {
   String s = 'abc';
 }
@@ -4531,9 +4135,7 @@
   MyCalss v = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class MyClass {}
 main() {
   MyClass v = null;
@@ -4547,9 +4149,7 @@
   test(throw 42);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   test(throw 42);
 }
@@ -4569,9 +4169,7 @@
   bar(c1.x, c2.x);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 class C {
   int x;
 }
@@ -4592,9 +4190,7 @@
   test(v);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   dynamic v;
   test(v);
@@ -4611,9 +4207,7 @@
   dynamic v = test();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   dynamic v = test();
 }
@@ -4629,9 +4223,7 @@
   int v = myUndefinedFunction(1, 2.0, '3');
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   int v = myUndefinedFunction(1, 2.0, '3');
 }
@@ -4649,9 +4241,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 class A {
   main() {
     int v = myUndefinedFunction(1, 2.0, '3');
@@ -4672,9 +4262,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 class A<T> {
   Map<int, T> items;
   main() {
@@ -4696,9 +4284,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 class A {
   List<int> items;
   main() {
@@ -4717,9 +4303,7 @@
   }
 
   test_undefinedFunction_create_importType() async {
-    addSource(
-        '/lib.dart',
-        r'''
+    addSource('/lib.dart', r'''
 library lib;
 import 'dart:async';
 Future getFuture() => null;
@@ -4730,9 +4314,7 @@
   test(getFuture());
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 import 'dart:async';
 
 import 'lib.dart';
@@ -4751,9 +4333,7 @@
   test(null);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   test(null);
 }
@@ -4787,9 +4367,7 @@
   v = myUndefinedFunction();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   int v;
   v = myUndefinedFunction();
@@ -4807,9 +4385,7 @@
   v += myUndefinedFunction();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   int v;
   v += myUndefinedFunction();
@@ -4826,9 +4402,7 @@
   0 + myUndefinedFunction();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   0 + myUndefinedFunction();
 }
@@ -4844,9 +4418,7 @@
   int v = myUndefinedFunction();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   int v = myUndefinedFunction();
 }
@@ -4863,9 +4435,7 @@
   foo( myUndefinedFunction() );
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 foo(int p) {}
 main() {
   foo( myUndefinedFunction() );
@@ -4882,9 +4452,7 @@
   return myUndefinedFunction();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 int main() {
   return myUndefinedFunction();
 }
@@ -4900,9 +4468,7 @@
   myUndefinedFunction();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_FUNCTION,
-        '''
+    await assertHasFix(DartFixKind.CREATE_FUNCTION, '''
 main() {
   myUndefinedFunction();
 }
@@ -4918,9 +4484,7 @@
   pritn(0);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 main() {
   print(0);
 }
@@ -4934,9 +4498,7 @@
   c.prnt(42);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 import 'dart:core' as c;
 main() {
   c.print(42);
@@ -4961,9 +4523,7 @@
   myFuntcion();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 myFunction() {}
 main() {
   myFunction();
@@ -4981,9 +4541,7 @@
   print(x.myFild);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   int myField;
 }
@@ -5003,9 +4561,7 @@
   print(a.myFild);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   int myField;
 }
@@ -5024,9 +4580,7 @@
   A.MY_NAM;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   static int MY_NAME = 1;
 }
@@ -5045,9 +4599,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   int myField;
   main() {
@@ -5089,9 +4641,7 @@
 class B {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A<T> {
   B b;
   Map<int, T> items;
@@ -5117,9 +4667,7 @@
 class B {
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A<T> {
   main() {
     T t = new B().compute();
@@ -5144,9 +4692,7 @@
 
 class B {}
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   B b;
   List<int> items;
@@ -5170,9 +4716,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A<T> {
   List<T> items;
   main() {
@@ -5191,9 +4735,7 @@
   A.myUndefinedMethod();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   static void myUndefinedMethod() {}
 }
@@ -5211,9 +4753,7 @@
   A.myUndefinedMethod();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   static void myUndefinedMethod() {}
 }
@@ -5232,9 +4772,7 @@
   A.myUndefinedMethod();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   foo() {}
 
@@ -5254,9 +4792,7 @@
   a.myUndefinedMethod();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   void myUndefinedMethod() {}
 }
@@ -5296,9 +4832,7 @@
     bar(c1.x, c2.x);
   }
 }''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class C {
   int x;
 }
@@ -5320,9 +4854,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   main() {
     myUndefinedMethod(0, 1.0, '3');
@@ -5365,9 +4897,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   main() {
     myUndefinedMethod(0, bbb: 1.0, ccc: '2');
@@ -5408,9 +4938,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   main() {
     int v = myUndefinedMethod();
@@ -5431,9 +4959,7 @@
   static var f = myUndefinedMethod();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   static var f = myUndefinedMethod();
 
@@ -5450,9 +4976,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   static main() {
     myUndefinedMethod();
@@ -5472,9 +4996,7 @@
   a.myUndefinedMethod();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CREATE_METHOD,
-        '''
+    await assertHasFix(DartFixKind.CREATE_METHOD, '''
 class A {
   void myUndefinedMethod() {}
 }
@@ -5494,9 +5016,7 @@
 }
 ''';
     addSource('/test2.dart', code2);
-    addSource(
-        '/test3.dart',
-        r'''
+    addSource('/test3.dart', r'''
 library test3;
 class E {}
 ''');
@@ -5515,9 +5035,7 @@
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/test2.dart');
-    expect(
-        SourceEdit.applySequence(code2, fileEdit.edits),
-        r'''
+    expect(SourceEdit.applySequence(code2, fileEdit.edits), r'''
 library test2;
 import 'test3.dart' as bbb;
 export 'test3.dart';
@@ -5550,9 +5068,7 @@
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/test2.dart');
-    expect(
-        SourceEdit.applySequence(code2, fileEdit.edits),
-        r'''
+    expect(SourceEdit.applySequence(code2, fileEdit.edits), r'''
 library test2;
 class D {
   void foo(E e) {}
@@ -5580,9 +5096,7 @@
   a.myMehtod();
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   myMethod() {}
 }
@@ -5604,9 +5118,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   myMethod() {}
 }
@@ -5627,9 +5139,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   myMethod() {}
   main() {
@@ -5678,9 +5188,7 @@
   );
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CONVERT_FLUTTER_CHILD,
-        '''
+    await assertHasFix(DartFixKind.CONVERT_FLUTTER_CHILD, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Container(
@@ -5714,9 +5222,7 @@
   );
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CONVERT_FLUTTER_CHILD,
-        '''
+    await assertHasFix(DartFixKind.CONVERT_FLUTTER_CHILD, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Container(
@@ -5749,9 +5255,7 @@
   );
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CONVERT_FLUTTER_CHILD,
-        '''
+    await assertHasFix(DartFixKind.CONVERT_FLUTTER_CHILD, '''
 import 'package:flutter/src/widgets/framework.dart';
 build() {
   return new Scaffold(
@@ -5778,9 +5282,7 @@
   x.myFild = 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   int myField;
 }
@@ -5800,9 +5302,7 @@
   a.myFild = 42;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   int myField;
 }
@@ -5821,9 +5321,7 @@
   }
 }
 ''');
-    await assertHasFix(
-        DartFixKind.CHANGE_TO,
-        '''
+    await assertHasFix(DartFixKind.CHANGE_TO, '''
 class A {
   int myField;
   main() {
@@ -5841,9 +5339,7 @@
   print((a / b).toInt());
 }
 ''');
-    await assertHasFix(
-        DartFixKind.USE_EFFECTIVE_INTEGER_DIVISION,
-        '''
+    await assertHasFix(DartFixKind.USE_EFFECTIVE_INTEGER_DIVISION, '''
 main() {
   var a = 5;
   var b = 2;
@@ -5860,9 +5356,7 @@
   Future f = null;
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PREFIX,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PREFIX, '''
 import 'dart:async' as pref;
 main() {
   pref.Stream s = null;
@@ -5879,9 +5373,7 @@
   print(PI);
 }
 ''');
-    await assertHasFix(
-        DartFixKind.IMPORT_LIBRARY_PREFIX,
-        '''
+    await assertHasFix(DartFixKind.IMPORT_LIBRARY_PREFIX, '''
 import 'dart:math' as pref;
 main() {
   print(pref.E);
@@ -5891,10 +5383,7 @@
   }
 
   void _addMetaPackageSource() {
-    addPackageSource(
-        'meta',
-        'meta.dart',
-        r'''
+    addPackageSource('meta', 'meta.dart', r'''
 library meta;
 
 const Required required = const Required();
diff --git a/pkg/analysis_server/test/services/correction/organize_directives_test.dart b/pkg/analysis_server/test/services/correction/organize_directives_test.dart
index 8efa94e..665cad6 100644
--- a/pkg/analysis_server/test/services/correction/organize_directives_test.dart
+++ b/pkg/analysis_server/test/services/correction/organize_directives_test.dart
@@ -34,17 +34,14 @@
   async2.Stream s;
 }''');
     // validate change
-    _assertOrganize(
-        r'''
+    _assertOrganize(r'''
 import 'dart:async' as async1;
 import 'dart:async' as async2;
 
 main() {
   async1.Future f;
   async2.Stream s;
-}''',
-        removeUnresolved: true,
-        removeUnused: true);
+}''', removeUnresolved: true, removeUnused: true);
   }
 
   test_remove_duplicateImports() async {
@@ -56,15 +53,12 @@
   Future f;
 }''');
     // validate change
-    _assertOrganize(
-        r'''
+    _assertOrganize(r'''
 import 'dart:async';
 
 main() {
   Future f;
-}''',
-        removeUnresolved: true,
-        removeUnused: true);
+}''', removeUnresolved: true, removeUnused: true);
   }
 
   test_remove_duplicateImports_differentText_uri() async {
@@ -76,15 +70,12 @@
   async.Future f;
 }''');
     // validate change
-    _assertOrganize(
-        r'''
+    _assertOrganize(r'''
 import 'dart:async' as async;
 
 main() {
   async.Future f;
-}''',
-        removeUnresolved: true,
-        removeUnused: true);
+}''', removeUnresolved: true, removeUnused: true);
   }
 
   test_remove_duplicateImports_withSamePrefix() async {
@@ -96,15 +87,12 @@
   async.Future f;
 }''');
     // validate change
-    _assertOrganize(
-        r'''
+    _assertOrganize(r'''
 import 'dart:async' as async;
 
 main() {
   async.Future f;
-}''',
-        removeUnresolved: true,
-        removeUnused: true);
+}''', removeUnresolved: true, removeUnused: true);
   }
 
   test_remove_unresolvedDirectives() async {
@@ -131,8 +119,7 @@
 }
 ''');
     // validate change
-    _assertOrganize(
-        r'''
+    _assertOrganize(r'''
 library lib;
 
 import 'dart:async';
@@ -146,8 +133,7 @@
 
 main() {
 }
-''',
-        removeUnresolved: true);
+''', removeUnresolved: true);
   }
 
   test_remove_unusedImports() async {
@@ -165,8 +151,7 @@
 }
 ''');
     // validate change
-    _assertOrganize(
-        r'''
+    _assertOrganize(r'''
 library lib;
 
 import 'dart:collection';
@@ -176,8 +161,7 @@
   print(PI);
   new HashMap();
 }
-''',
-        removeUnused: true);
+''', removeUnused: true);
   }
 
   test_remove_unusedImports2() async {
@@ -191,17 +175,14 @@
   Future f;
 }''');
     // validate change
-    _assertOrganize(
-        r'''
+    _assertOrganize(r'''
 import 'dart:async';
 
 class A {}
 
 main() {
   Future f;
-}''',
-        removeUnresolved: true,
-        removeUnused: true);
+}''', removeUnresolved: true, removeUnused: true);
   }
 
   test_sort() async {
diff --git a/pkg/analysis_server/test/services/correction/util_test.dart b/pkg/analysis_server/test/services/correction/util_test.dart
index d698e07..1589df0 100644
--- a/pkg/analysis_server/test/services/correction/util_test.dart
+++ b/pkg/analysis_server/test/services/correction/util_test.dart
@@ -25,9 +25,7 @@
 import 'dart:math';
 ''');
     Source newLibrary = _getDartSource('dart:collection');
-    _assertAddLibraryImport(
-        <Source>[newLibrary],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary], '''
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math';
@@ -40,9 +38,7 @@
 import 'dart:math';
 ''');
     Source newLibrary = _getDartSource('dart:async');
-    _assertAddLibraryImport(
-        <Source>[newLibrary],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary], '''
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math';
@@ -55,9 +51,7 @@
 import 'dart:collection';
 ''');
     Source newLibrary = _getDartSource('dart:math');
-    _assertAddLibraryImport(
-        <Source>[newLibrary],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary], '''
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math';
@@ -71,9 +65,7 @@
 ''');
     Source newLibrary1 = _getDartSource('dart:async');
     Source newLibrary2 = _getDartSource('dart:html');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
@@ -88,9 +80,7 @@
 ''');
     Source newLibrary1 = _getDartSource('dart:async');
     Source newLibrary2 = _getDartSource('dart:collection');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
@@ -105,9 +95,7 @@
 ''');
     Source newLibrary1 = _getDartSource('dart:html');
     Source newLibrary2 = _getDartSource('dart:math');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
@@ -123,9 +111,7 @@
 ''');
     Source newLibrary1 = _getDartSource('dart:math');
     Source newLibrary2 = _getDartSource('dart:async');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 library test;
 
 import 'dart:async';
@@ -143,9 +129,7 @@
 ''');
     Source newLibrary1 = _getDartSource('dart:math');
     Source newLibrary2 = _getDartSource('dart:async');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 /// Comment.
 
 import 'dart:async';
@@ -163,9 +147,7 @@
 ''');
     Source newLibrary1 = _getDartSource('dart:math');
     Source newLibrary2 = _getDartSource('dart:async');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 #!/bin/dart
 
 import 'dart:async';
@@ -181,9 +163,7 @@
 ''');
     Source newLibrary1 = _getDartSource('dart:math');
     Source newLibrary2 = _getDartSource('dart:async');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 import 'dart:async';
 import 'dart:math';
 
@@ -199,9 +179,7 @@
 import 'package:aaa/aaa.dart';
 ''');
     Source newLibrary = _getSource('/lib/bbb.dart', 'package:bbb/bbb.dart');
-    _assertAddLibraryImport(
-        <Source>[newLibrary],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary], '''
 import 'dart:async';
 
 import 'package:aaa/aaa.dart';
@@ -217,9 +195,7 @@
 import 'package:bbb/bbb.dart';
 ''');
     Source newLibrary = _getSource('/lib/aaa.dart', 'package:aaa/aaa.dart');
-    _assertAddLibraryImport(
-        <Source>[newLibrary],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary], '''
 import 'dart:async';
 
 import 'package:aaa/aaa.dart';
@@ -236,9 +212,7 @@
 ''');
     Source newLibrary1 = _getSource('/lib/bbb.dart', 'package:bbb/bbb.dart');
     Source newLibrary2 = _getSource('/lib/ccc.dart', 'package:ccc/ccc.dart');
-    _assertAddLibraryImport(
-        <Source>[newLibrary1, newLibrary2],
-        '''
+    _assertAddLibraryImport(<Source>[newLibrary1, newLibrary2], '''
 import 'package:aaa/aaa.dart';
 import 'package:bbb/bbb.dart';
 import 'package:ccc/ccc.dart';
diff --git a/pkg/analysis_server/test/services/dependencies/reachable_source_collector_test.dart b/pkg/analysis_server/test/services/dependencies/reachable_source_collector_test.dart
index 1a82328..10ccfdd 100644
--- a/pkg/analysis_server/test/services/dependencies/reachable_source_collector_test.dart
+++ b/pkg/analysis_server/test/services/dependencies/reachable_source_collector_test.dart
@@ -38,9 +38,7 @@
   test_sources() {
     // See https://github.com/dart-lang/sdk/issues/29311
     fail('The analysis.getReachableSources is not implemented.');
-    Source lib1 = addSource(
-        '/lib1.dart',
-        '''
+    Source lib1 = addSource('/lib1.dart', '''
 import "lib2.dart";
 import "dart:html";''');
     Source lib2 = addSource('/lib2.dart', 'import "lib1.dart";');
diff --git a/pkg/analysis_server/test/services/linter/linter_test.dart b/pkg/analysis_server/test/services/linter/linter_test.dart
index 66d3404..c88c48a 100644
--- a/pkg/analysis_server/test/services/linter/linter_test.dart
+++ b/pkg/analysis_server/test/services/linter/linter_test.dart
@@ -34,43 +34,35 @@
   }
 
   test_linter_defined_rules() {
-    validate(
-        '''
+    validate('''
 linter:
   rules:
     - camel_case_types
-    ''',
-        []);
+    ''', []);
   }
 
   test_linter_no_rules() {
-    validate(
-        '''
+    validate('''
 linter:
   rules:
-    ''',
-        []);
+    ''', []);
   }
 
   test_linter_null_rule() {
-    validate(
-        '''
+    validate('''
 linter:
   rules:
     -
 
-    ''',
-        []);
+    ''', []);
   }
 
   test_linter_undefined_rule() {
-    validate(
-        '''
+    validate('''
 linter:
   rules:
     - undefined
-    ''',
-        [UNDEFINED_LINT_WARNING]);
+    ''', [UNDEFINED_LINT_WARNING]);
   }
 
   validate(String source, List<ErrorCode> expected) {
diff --git a/pkg/analysis_server/test/services/refactoring/convert_getter_to_method_test.dart b/pkg/analysis_server/test/services/refactoring/convert_getter_to_method_test.dart
index 40d946f..7712c7d 100644
--- a/pkg/analysis_server/test/services/refactoring/convert_getter_to_method_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/convert_getter_to_method_test.dart
@@ -87,9 +87,7 @@
   }
 
   test_change_multipleFiles() async {
-    await indexUnit(
-        '/other.dart',
-        r'''
+    await indexUnit('/other.dart', r'''
 class A {
   int get test => 1;
 }
diff --git a/pkg/analysis_server/test/services/refactoring/convert_method_to_getter_test.dart b/pkg/analysis_server/test/services/refactoring/convert_method_to_getter_test.dart
index cbef094..e9cb4d8 100644
--- a/pkg/analysis_server/test/services/refactoring/convert_method_to_getter_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/convert_method_to_getter_test.dart
@@ -89,9 +89,7 @@
   }
 
   test_change_multipleFiles() async {
-    await indexUnit(
-        '/other.dart',
-        r'''
+    await indexUnit('/other.dart', r'''
 class A {
   int test() => 1;
 }
diff --git a/pkg/analysis_server/test/services/refactoring/extract_method_test.dart b/pkg/analysis_server/test/services/refactoring/extract_method_test.dart
index e57e0e9..a5363ec 100644
--- a/pkg/analysis_server/test/services/refactoring/extract_method_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/extract_method_test.dart
@@ -2797,9 +2797,7 @@
   }
 
   void _addLibraryReturningAsync() {
-    addSource(
-        '/asyncLib.dart',
-        r'''
+    addSource('/asyncLib.dart', r'''
 library asyncLib;
 import 'dart:async';
 Future<int> newFuture() => null;
diff --git a/pkg/analysis_server/test/services/refactoring/move_file_test.dart b/pkg/analysis_server/test/services/refactoring/move_file_test.dart
index 8794896..c830b4f 100644
--- a/pkg/analysis_server/test/services/refactoring/move_file_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/move_file_test.dart
@@ -47,9 +47,7 @@
     assertNoFileChange(pathA);
     assertFileChangeResult(pathB, "import '22/new_name.dart';");
     assertNoFileChange(pathC);
-    assertFileChangeResult(
-        testFile,
-        '''
+    assertFileChangeResult(testFile, '''
 library lib;
 import 'dart:math';
 import 'c.dart';
@@ -64,18 +62,14 @@
     fail('The move file refactoring is not supported under the new driver');
     String pathA = '/project/000/1111/a.dart';
     testFile = '/project/000/1111/sub/folder/test.dart';
-    addSource(
-        pathA,
-        '''
+    addSource(pathA, '''
 import 'sub/folder/test.dart';
 ''');
     addTestSource('');
     // perform refactoring
     _createRefactoring('/project/000/new/folder/name/new_name.dart');
     await _assertSuccessfulRefactoring();
-    assertFileChangeResult(
-        pathA,
-        '''
+    assertFileChangeResult(pathA, '''
 import '../new/folder/name/new_name.dart';
 ''');
     assertNoFileChange(testFile);
@@ -86,18 +80,14 @@
     fail('The move file refactoring is not supported under the new driver');
     String pathA = '/project/000/1111/a.dart';
     testFile = '/project/000/1111/test.dart';
-    addSource(
-        pathA,
-        '''
+    addSource(pathA, '''
 import 'test.dart';
 ''');
     addTestSource('');
     // perform refactoring
     _createRefactoring('/project/000/1111/22/new_name.dart');
     await _assertSuccessfulRefactoring();
-    assertFileChangeResult(
-        pathA,
-        '''
+    assertFileChangeResult(pathA, '''
 import '22/new_name.dart';
 ''');
     assertNoFileChange(testFile);
@@ -120,18 +110,14 @@
 //    ]);
     // do testing
     String pathA = '/project/bin/a.dart';
-    addSource(
-        pathA,
-        '''
+    addSource(pathA, '''
 import 'package:my_pkg/aaa/test.dart';
 ''');
     addTestSource('', Uri.parse('package:my_pkg/aaa/test.dart'));
     // perform refactoring
     _createRefactoring('/packages/my_pkg/lib/bbb/ccc/new_name.dart');
     await _assertSuccessfulRefactoring();
-    assertFileChangeResult(
-        pathA,
-        '''
+    assertFileChangeResult(pathA, '''
 import 'package:my_pkg/bbb/ccc/new_name.dart';
 ''');
     assertNoFileChange(testFile);
@@ -142,18 +128,14 @@
     fail('The move file refactoring is not supported under the new driver');
     String pathA = '/project/000/1111/a.dart';
     testFile = '/project/000/1111/22/test.dart';
-    addSource(
-        pathA,
-        '''
+    addSource(pathA, '''
 import '22/test.dart';
 ''');
     addTestSource('');
     // perform refactoring
     _createRefactoring('/project/000/1111/new_name.dart');
     await _assertSuccessfulRefactoring();
-    assertFileChangeResult(
-        pathA,
-        '''
+    assertFileChangeResult(pathA, '''
 import 'new_name.dart';
 ''');
     assertNoFileChange(testFile);
@@ -164,9 +146,7 @@
     fail('The move file refactoring is not supported under the new driver');
     String pathA = '/project/000/1111/a.dart';
     testFile = '/project/000/1111/22/test.dart';
-    addSource(
-        pathA,
-        '''
+    addSource(pathA, '''
 library lib;
 part '22/test.dart';
 ''');
@@ -176,9 +156,7 @@
     // perform refactoring
     _createRefactoring('/project/000/1111/22/new_name.dart');
     await _assertSuccessfulRefactoring();
-    assertFileChangeResult(
-        pathA,
-        '''
+    assertFileChangeResult(pathA, '''
 library lib;
 part '22/new_name.dart';
 ''');
@@ -191,15 +169,11 @@
     String pathA = '/project/000/1111/a.dart';
     String pathB = '/project/000/b.dart';
     testFile = '/project/000/1111/22/test.dart';
-    addSource(
-        pathA,
-        '''
+    addSource(pathA, '''
 library lib;
 part '22/test.dart';
 ''');
-    addSource(
-        pathB,
-        '''
+    addSource(pathB, '''
 library lib;
 part '1111/22/test.dart';
 ''');
@@ -209,15 +183,11 @@
     // perform refactoring
     _createRefactoring('/project/000/1111/22/new_name.dart');
     await _assertSuccessfulRefactoring();
-    assertFileChangeResult(
-        pathA,
-        '''
+    assertFileChangeResult(pathA, '''
 library lib;
 part '22/new_name.dart';
 ''');
-    assertFileChangeResult(
-        pathB,
-        '''
+    assertFileChangeResult(pathB, '''
 library lib;
 part '1111/22/new_name.dart';
 ''');
@@ -229,17 +199,13 @@
     fail('The move file refactoring is not supported under the new driver');
     String pubspecPath = '/testName/pubspec.yaml';
     String appPath = '/testName/bin/myApp.dart';
-    provider.newFile(
-        pubspecPath,
-        '''
+    provider.newFile(pubspecPath, '''
 name: testName
 version: 0.0.1
 description: My pubspec file.
 ''');
     addSource('/testName/lib/myLib.dart', '');
-    addSource(
-        appPath,
-        '''
+    addSource(appPath, '''
 import 'package:testName/myLib.dart';
 export 'package:testName/myLib.dart';
 ''');
@@ -257,16 +223,12 @@
         provider, searchEngine, null, null, '/testName');
     refactoring.newFile = '/newName';
     await _assertSuccessfulRefactoring();
-    assertFileChangeResult(
-        pubspecPath,
-        '''
+    assertFileChangeResult(pubspecPath, '''
 name: newName
 version: 0.0.1
 description: My pubspec file.
 ''');
-    assertFileChangeResult(
-        appPath,
-        '''
+    assertFileChangeResult(appPath, '''
 import 'package:newName/myLib.dart';
 export 'package:newName/myLib.dart';
 ''');
diff --git a/pkg/analysis_server/test/services/refactoring/rename_class_member_test.dart b/pkg/analysis_server/test/services/refactoring/rename_class_member_test.dart
index 22a4657..18eb7d2 100644
--- a/pkg/analysis_server/test/services/refactoring/rename_class_member_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/rename_class_member_test.dart
@@ -132,9 +132,7 @@
   test() {}
 }
 ''');
-    await indexUnit(
-        '/lib.dart',
-        '''
+    await indexUnit('/lib.dart', '''
 library my.lib;
 import 'test.dart';
 
@@ -693,9 +691,7 @@
 
   test_createChange_MethodElement_potential_inPubCache() async {
     String pkgLib = '/.pub-cache/lib.dart';
-    await indexUnit(
-        pkgLib,
-        r'''
+    await indexUnit(pkgLib, r'''
 processObj(p) {
   p.test();
 }
@@ -729,9 +725,7 @@
   }
 
   test_createChange_MethodElement_potential_private_otherLibrary() async {
-    await indexUnit(
-        '/lib.dart',
-        '''
+    await indexUnit('/lib.dart', '''
 library lib;
 main(p) {
   p._test();
diff --git a/pkg/analysis_server/test/services/refactoring/rename_library_test.dart b/pkg/analysis_server/test/services/refactoring/rename_library_test.dart
index 9ba81d4..1acca7d 100644
--- a/pkg/analysis_server/test/services/refactoring/rename_library_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/rename_library_test.dart
@@ -40,9 +40,7 @@
   }
 
   test_createChange() async {
-    addSource(
-        '/part.dart',
-        '''
+    addSource('/part.dart', '''
 part of my.app;
 ''');
     await indexTestUnit('''
@@ -59,17 +57,13 @@
 library the.new.name;
 part 'part.dart';
 ''');
-    assertFileChangeResult(
-        '/part.dart',
-        '''
+    assertFileChangeResult('/part.dart', '''
 part of the.new.name;
 ''');
   }
 
   test_createChange_hasWhitespaces() async {
-    addSource(
-        '/part.dart',
-        '''
+    addSource('/part.dart', '''
 part of my .  app;
 ''');
     await indexTestUnit('''
@@ -86,9 +80,7 @@
 library the.new.name;
 part 'part.dart';
 ''');
-    assertFileChangeResult(
-        '/part.dart',
-        '''
+    assertFileChangeResult('/part.dart', '''
 part of the.new.name;
 ''');
   }
diff --git a/pkg/analysis_server/test/services/refactoring/rename_local_test.dart b/pkg/analysis_server/test/services/refactoring/rename_local_test.dart
index f5be5da..8533be0 100644
--- a/pkg/analysis_server/test/services/refactoring/rename_local_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/rename_local_test.dart
@@ -447,9 +447,7 @@
   A({test});
 }
 ''');
-    await indexUnit(
-        '/test2.dart',
-        '''
+    await indexUnit('/test2.dart', '''
 import 'test.dart';
 main() {
   new A(test: 2);
@@ -465,9 +463,7 @@
   A({newName});
 }
 ''');
-    assertFileChangeResult(
-        '/test2.dart',
-        '''
+    assertFileChangeResult('/test2.dart', '''
 import 'test.dart';
 main() {
   new A(newName: 2);
@@ -476,9 +472,7 @@
   }
 
   test_createChange_parameter_named_updateHierarchy() async {
-    await indexUnit(
-        '/test2.dart',
-        '''
+    await indexUnit('/test2.dart', '''
 library test2;
 class A {
   void foo({int test: 1}) {
@@ -522,9 +516,7 @@
   }
 }
 ''');
-    assertFileChangeResult(
-        '/test2.dart',
-        '''
+    assertFileChangeResult('/test2.dart', '''
 library test2;
 class A {
   void foo({int newName: 1}) {
diff --git a/pkg/analysis_server/test/services/refactoring/rename_unit_member_test.dart b/pkg/analysis_server/test/services/refactoring/rename_unit_member_test.dart
index 91b3a55..80085b4 100644
--- a/pkg/analysis_server/test/services/refactoring/rename_unit_member_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/rename_unit_member_test.dart
@@ -69,9 +69,7 @@
     await indexTestUnit('''
 class Test {}
 ''');
-    await indexUnit(
-        '/lib.dart',
-        '''
+    await indexUnit('/lib.dart', '''
 library my.lib;
 import 'test.dart';
 
@@ -111,9 +109,7 @@
     await indexTestUnit('''
 class Test {}
 ''');
-    await indexUnit(
-        '/lib.dart',
-        '''
+    await indexUnit('/lib.dart', '''
 library my.lib;
 import 'test.dart';
 class A {
@@ -137,9 +133,7 @@
     await indexTestUnit('''
 class Test {}
 ''');
-    await indexUnit(
-        '/lib.dart',
-        '''
+    await indexUnit('/lib.dart', '''
 library my.lib;
 import 'test.dart' hide Test;
 class A {
@@ -180,9 +174,7 @@
   }
 
   test_checkFinalConditions_shadowsInSubClass_notImportedLib() async {
-    await indexUnit(
-        '/lib.dart',
-        '''
+    await indexUnit('/lib.dart', '''
 library my.lib;
 class A {
   NewName() {}
@@ -223,9 +215,7 @@
   }
 
   test_checkInitialConditions_inPubCache_posix() async {
-    addSource(
-        '/.pub-cache/lib.dart',
-        r'''
+    addSource('/.pub-cache/lib.dart', r'''
 class A {}
 ''');
     await indexTestUnit('''
@@ -244,9 +234,7 @@
   }
 
   test_checkInitialConditions_inPubCache_windows() async {
-    addSource(
-        '/Pub/Cache/lib.dart',
-        r'''
+    addSource('/Pub/Cache/lib.dart', r'''
 class A {}
 ''');
     await indexTestUnit('''
@@ -495,9 +483,7 @@
   }
 
   test_createChange_FunctionElement_imported() async {
-    await indexUnit(
-        '/foo.dart',
-        r'''
+    await indexUnit('/foo.dart', r'''
 test() {}
 foo() {}
 ''');
@@ -524,9 +510,7 @@
   foo();
 }
 ''');
-    assertFileChangeResult(
-        '/foo.dart',
-        '''
+    assertFileChangeResult('/foo.dart', '''
 newName() {}
 foo() {}
 ''');
diff --git a/pkg/analysis_server/test/services/search/search_engine_test.dart b/pkg/analysis_server/test/services/search/search_engine_test.dart
index b45234f..c62ffe3 100644
--- a/pkg/analysis_server/test/services/search/search_engine_test.dart
+++ b/pkg/analysis_server/test/services/search/search_engine_test.dart
@@ -51,26 +51,20 @@
     var b = _p('/test/b.dart');
     var c = _p('/test/c.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class A {
   void a() {}
   void b() {}
   void c() {}
 }
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 import 'a.dart';
 class B extends A {
   void a() {}
 }
 ''');
-    provider.newFile(
-        c,
-        '''
+    provider.newFile(c, '''
 import 'a.dart';
 class C extends A {
   void b() {}
@@ -97,18 +91,14 @@
     var a = _p('/test/a.dart');
     var b = _p('/test/b.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class A {
   void a() {}
   void b() {}
   void c() {}
 }
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 import 'a.dart';
 class B extends A {}
 ''');
@@ -131,18 +121,14 @@
     var a = _p('/test/a.dart');
     var b = _p('/test/b.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class A {
   void a() {}
   void b() {}
   void c() {}
 }
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 import 'a.dart';
 class B {
   void a() {}
@@ -167,9 +153,7 @@
     var a = _p('/test/a.dart');
     var b = _p('/test/b.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class A {
   void a() {}
   void _b() {}
@@ -179,9 +163,7 @@
   void _b() {}
 }
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 import 'a.dart';
 class C extends A {
   void a() {}
@@ -210,9 +192,7 @@
   test_searchAllSubtypes() async {
     var p = _p('/test.dart');
 
-    provider.newFile(
-        p,
-        '''
+    provider.newFile(p, '''
 class T {}
 class A extends T {}
 class B extends A {}
@@ -237,15 +217,11 @@
     var a = _p('/test/a.dart');
     var b = _p('/test/b.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class T {}
 class A extends T {}
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 import 'a.dart';
 class B extends A {}
 class C extends B {}
@@ -321,9 +297,7 @@
     var a = _p('/test/a.dart');
     var b = _p('/test/b.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class A {
   int test;
 }
@@ -331,9 +305,7 @@
   p.test;
 }
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 import 'a.dart';
 bar(p) {
   p.test = 1;
@@ -364,15 +336,11 @@
     var a = _p('/test/a.dart');
     var b = _p('/test/b.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class T {}
 T a;
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 import 'a.dart';
 T b;
 ''');
@@ -399,15 +367,11 @@
     var a = _p('/test/a.dart');
     var b = _p('/test/b.dart');
 
-    provider.newFile(
-        a,
-        '''
+    provider.newFile(a, '''
 class A {}
 int a;
 ''');
-    provider.newFile(
-        b,
-        '''
+    provider.newFile(b, '''
 class B {}
 get b => 42;
 ''');
diff --git a/pkg/analysis_server/test/src/computer/import_elements_computer_test.dart b/pkg/analysis_server/test/src/computer/import_elements_computer_test.dart
index 3bb5dac..af43eaf 100644
--- a/pkg/analysis_server/test/src/computer/import_elements_computer_test.dart
+++ b/pkg/analysis_server/test/src/computer/import_elements_computer_test.dart
@@ -55,9 +55,7 @@
     expect(edit, isNotNull);
     expect(edit.offset, 0);
     expect(edit.length, 0);
-    expect(
-        edit.apply(targetCode),
-        """
+    expect(edit.apply(targetCode), """
 import 'source.dart';
 
 main() {}
diff --git a/pkg/analyzer/lib/src/dart/analysis/file_state.dart b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
index 42139e1..5db2c92 100644
--- a/pkg/analyzer/lib/src/dart/analysis/file_state.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
@@ -16,7 +16,6 @@
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/fasta/ast_builder.dart' as fasta;
-import 'package:analyzer/src/fasta/element_store.dart' as fasta;
 import 'package:analyzer/src/fasta/mock_element.dart' as fasta;
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
@@ -585,7 +584,6 @@
             new ErrorReporter(errorListener, source),
             null,
             null,
-            new _FastaElementStoreProxy(),
             new fasta.Scope.top(isModifiable: true),
             true,
             uri);
@@ -940,25 +938,3 @@
 
   KnownFilesSetChange(this.added, this.removed);
 }
-
-class _FastaElementProxy implements fasta.KernelClassElement {
-  @override
-  final fasta.KernelInterfaceType rawType = new _FastaInterfaceTypeProxy();
-
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
-
-class _FastaElementStoreProxy implements fasta.ElementStore {
-  final _elements = <fasta.Builder, _FastaElementProxy>{};
-
-  @override
-  _FastaElementProxy operator [](fasta.Builder builder) =>
-      _elements.putIfAbsent(builder, () => new _FastaElementProxy());
-
-  @override
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
-
-class _FastaInterfaceTypeProxy implements fasta.KernelInterfaceType {
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 5448630..97b3b2f 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -30,6 +30,7 @@
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/task/dart.dart';
+import 'package:kernel/kernel.dart' as kernel;
 
 /**
  * Assert that the given [object] is null, which in the places where this
@@ -411,6 +412,11 @@
   final UnlinkedClass _unlinkedClass;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.Class _kernel;
+
+  /**
    * The superclass of the class, or `null` for [Object].
    */
   InterfaceType _supertype;
@@ -466,13 +472,23 @@
    */
   ClassElementImpl(String name, int offset)
       : _unlinkedClass = null,
+        _kernel = null,
         super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  ClassElementImpl.forKernel(
+      CompilationUnitElementImpl enclosingUnit, this._kernel)
+      : _unlinkedClass = null,
+        super.forSerialized(enclosingUnit);
+
+  /**
    * Initialize a newly created class element to have the given [name].
    */
   ClassElementImpl.forNode(Identifier name)
       : _unlinkedClass = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
@@ -480,7 +496,8 @@
    */
   ClassElementImpl.forSerialized(
       this._unlinkedClass, CompilationUnitElementImpl enclosingUnit)
-      : super.forSerialized(enclosingUnit);
+      : _kernel = null,
+        super.forSerialized(enclosingUnit);
 
   /**
    * Set whether this class is abstract.
@@ -532,6 +549,16 @@
     if (isMixinApplication) {
       return _computeMixinAppConstructors();
     }
+    if (_kernel != null && _constructors == null) {
+      var constructors = _kernel.constructors
+          .map((k) => new ConstructorElementImpl.forKernel(this, k, null));
+      var factories = _kernel.procedures
+          .where((k) => k.isFactory)
+          .map((k) => new ConstructorElementImpl.forKernel(this, null, k));
+      _constructors = <ConstructorElement>[]
+        ..addAll(constructors)
+        ..addAll(factories);
+    }
     if (_unlinkedClass != null && _constructors == null) {
       _constructors = _unlinkedClass.executables
           .where((e) => e.kind == UnlinkedExecutableKind.constructor)
@@ -565,6 +592,9 @@
 
   @override
   String get documentationComment {
+    if (_kernel != null) {
+      return _kernel.documentationComment;
+    }
     if (_unlinkedClass != null) {
       return _unlinkedClass?.documentationComment?.text;
     }
@@ -719,12 +749,19 @@
 
   @override
   List<InterfaceType> get interfaces {
-    if (_unlinkedClass != null && _interfaces == null) {
-      ResynthesizerContext context = enclosingUnit.resynthesizerContext;
-      _interfaces = _unlinkedClass.interfaces
-          .map((EntityRef t) => context.resolveTypeRef(this, t))
-          .where(_isClassInterfaceType)
-          .toList(growable: false);
+    if (_interfaces == null) {
+      if (_kernel != null) {
+        _interfaces = _kernel.implementedTypes
+            .map((k) => enclosingUnit._kernelContext.getInterfaceType(this, k))
+            .toList(growable: false);
+      }
+      if (_unlinkedClass != null) {
+        ResynthesizerContext context = enclosingUnit.resynthesizerContext;
+        _interfaces = _unlinkedClass.interfaces
+            .map((EntityRef t) => context.resolveTypeRef(this, t))
+            .where(_isClassInterfaceType)
+            .toList(growable: false);
+      }
     }
     return _interfaces ?? const <InterfaceType>[];
   }
@@ -736,6 +773,9 @@
 
   @override
   bool get isAbstract {
+    if (_kernel != null) {
+      return _kernel.isAbstract;
+    }
     if (_unlinkedClass != null) {
       return _unlinkedClass.isAbstract;
     }
@@ -786,6 +826,9 @@
   }
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => _kernel?.typeParameters;
+
+  @override
   List<ElementAnnotation> get metadata {
     if (_unlinkedClass != null) {
       return _metadata ??=
@@ -843,6 +886,9 @@
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name;
+    }
     if (_unlinkedClass != null) {
       return _unlinkedClass.name;
     }
@@ -860,19 +906,30 @@
 
   @override
   InterfaceType get supertype {
-    if (_unlinkedClass != null && _supertype == null) {
-      if (_unlinkedClass.supertype != null) {
-        DartType type = enclosingUnit.resynthesizerContext
-            .resolveTypeRef(this, _unlinkedClass.supertype);
-        if (_isClassInterfaceType(type)) {
-          _supertype = type;
+    if (_supertype == null) {
+      if (_kernel != null) {
+        if (_kernel.supertype != null) {
+          _supertype = enclosingUnit._kernelContext
+              .getInterfaceType(this, _kernel.supertype);
+          _supertype ??= context.typeProvider.objectType;
+        } else {
+          return null;
+        }
+      }
+      if (_unlinkedClass != null) {
+        if (_unlinkedClass.supertype != null) {
+          DartType type = enclosingUnit.resynthesizerContext
+              .resolveTypeRef(this, _unlinkedClass.supertype);
+          if (_isClassInterfaceType(type)) {
+            _supertype = type;
+          } else {
+            _supertype = context.typeProvider.objectType;
+          }
+        } else if (_unlinkedClass.hasNoSupertype) {
+          return null;
         } else {
           _supertype = context.typeProvider.objectType;
         }
-      } else if (_unlinkedClass.hasNoSupertype) {
-        return null;
-      } else {
-        _supertype = context.typeProvider.objectType;
       }
     }
     return _supertype;
@@ -1277,6 +1334,11 @@
   final UnlinkedPart _unlinkedPart;
 
   /**
+   * The kernel context in which the library is resynthesized.
+   */
+  final KernelLibraryResynthesizerContext _kernelContext;
+
+  /**
    * The source that corresponds to this compilation unit.
    */
   @override
@@ -1360,9 +1422,24 @@
       : resynthesizerContext = null,
         _unlinkedUnit = null,
         _unlinkedPart = null,
+        _kernelContext = null,
         super(name, -1);
 
   /**
+   * Initialize using the given kernel information.
+   */
+  CompilationUnitElementImpl.forKernel(
+      LibraryElementImpl enclosingLibrary, this._kernelContext, String name)
+      : resynthesizerContext = null,
+        _unlinkedUnit = null,
+        _unlinkedPart = null,
+        super.forSerialized(null) {
+    _enclosingElement = enclosingLibrary;
+    _name = name;
+    _nameOffset = -1;
+  }
+
+  /**
    * Initialize using the given serialized information.
    */
   CompilationUnitElementImpl.forSerialized(
@@ -1371,7 +1448,8 @@
       this._unlinkedUnit,
       this._unlinkedPart,
       String name)
-      : super.forSerialized(null) {
+      : _kernelContext = null,
+        super.forSerialized(null) {
     _enclosingElement = enclosingLibrary;
     _name = name;
     _nameOffset = -1;
@@ -1520,6 +1598,11 @@
 
   @override
   List<TopLevelVariableElement> get topLevelVariables {
+    if (_kernelContext != null) {
+      return _variables ??= _kernelContext.library.fields
+          .map((k) => new TopLevelVariableElementImpl.forKernel(this, k))
+          .toList(growable: false);
+    }
     if (_unlinkedUnit != null) {
       if (_variables == null) {
         _explicitTopLevelAccessors ??=
@@ -1575,6 +1658,11 @@
 
   @override
   List<ClassElement> get types {
+    if (_kernelContext != null) {
+      _types ??= _kernelContext.library.classes
+          .map((k) => new ClassElementImpl.forKernel(this, k))
+          .toList(growable: false);
+    }
     if (_unlinkedUnit != null) {
       _types ??= _unlinkedUnit.classes
           .map((c) => new ClassElementImpl.forSerialized(c, this))
@@ -1934,6 +2022,16 @@
   List<ConstructorInitializer> _constantInitializers;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.Constructor _kernelConstructor;
+
+  /**
+   * The kernel of the element.
+   */
+  final kernel.Procedure _kernelFactory;
+
+  /**
    * The offset of the `.` before this constructor name or `null` if not named.
    */
   int _periodOffset;
@@ -1954,19 +2052,36 @@
    * Initialize a newly created constructor element to have the given [name] and
    * [offset].
    */
-  ConstructorElementImpl(String name, int offset) : super(name, offset);
+  ConstructorElementImpl(String name, int offset)
+      : _kernelConstructor = null,
+        _kernelFactory = null,
+        super(name, offset);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  ConstructorElementImpl.forKernel(ClassElementImpl enclosingClass,
+      this._kernelConstructor, this._kernelFactory)
+      : super.forKernel(enclosingClass, _kernelConstructor ?? _kernelFactory) {
+    isSynthetic = _kernelConstructor?.isSyntheticDefault ?? false;
+  }
 
   /**
    * Initialize a newly created constructor element to have the given [name].
    */
-  ConstructorElementImpl.forNode(Identifier name) : super.forNode(name);
+  ConstructorElementImpl.forNode(Identifier name)
+      : _kernelConstructor = null,
+        _kernelFactory = null,
+        super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ConstructorElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ClassElementImpl enclosingClass)
-      : super.forSerialized(serializedExecutable, enclosingClass);
+      : _kernelConstructor = null,
+        _kernelFactory = null,
+        super.forSerialized(serializedExecutable, enclosingClass);
 
   /**
    * Return the constant initializers for this element, which will be empty if
@@ -2005,6 +2120,12 @@
 
   @override
   bool get isConst {
+    if (_kernelConstructor != null) {
+      return _kernelConstructor.isConst;
+    }
+    if (_kernelFactory != null) {
+      return _kernelFactory.isConst;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isConst;
     }
@@ -2053,6 +2174,8 @@
 
   @override
   bool get isFactory {
+    if (_kernelConstructor != null) return false;
+    if (_kernelFactory != null) return true;
     if (serializedExecutable != null) {
       return serializedExecutable.isFactory;
     }
@@ -3549,6 +3672,11 @@
   final UnlinkedExecutable serializedExecutable;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.Member _kernel;
+
+  /**
    * A list containing all of the functions defined within this executable
    * element.
    */
@@ -3580,13 +3708,22 @@
    */
   ExecutableElementImpl(String name, int offset)
       : serializedExecutable = null,
+        _kernel = null,
         super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  ExecutableElementImpl.forKernel(ElementImpl enclosingElement, this._kernel)
+      : serializedExecutable = null,
+        super.forSerialized(enclosingElement);
+
+  /**
    * Initialize a newly created executable element to have the given [name].
    */
   ExecutableElementImpl.forNode(Identifier name)
       : serializedExecutable = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
@@ -3594,7 +3731,8 @@
    */
   ExecutableElementImpl.forSerialized(
       this.serializedExecutable, ElementImpl enclosingElement)
-      : super.forSerialized(enclosingElement);
+      : _kernel = null,
+        super.forSerialized(enclosingElement);
 
   /**
    * Set whether this executable element's body is asynchronous.
@@ -3627,6 +3765,9 @@
 
   @override
   String get displayName {
+    if (_kernel != null) {
+      return _kernel.name.name;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.name;
     }
@@ -3713,6 +3854,9 @@
 
   @override
   bool get isExternal {
+    if (_kernel != null) {
+      return _kernel.isExternal;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.isExternal;
     }
@@ -3734,6 +3878,9 @@
   bool get isSynchronous => !isAsynchronous;
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   List<ElementAnnotation> get metadata {
     if (serializedExecutable != null) {
       return _metadata ??=
@@ -3744,6 +3891,9 @@
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name.name;
+    }
     if (serializedExecutable != null) {
       return serializedExecutable.name;
     }
@@ -4565,6 +4715,9 @@
       _enclosingElement as CompilationUnitElementImpl;
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
@@ -4779,6 +4932,9 @@
   String get identifier => '-';
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   ElementKind get kind => ElementKind.GENERIC_FUNCTION_TYPE;
 
   @override
@@ -5006,6 +5162,9 @@
   }
 
   @override
+  List<kernel.TypeParameter> get kernelTypeParams => null;
+
+  @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
@@ -5459,6 +5618,25 @@
 }
 
 /**
+ * The kernel context in which a library is resynthesized.
+ */
+abstract class KernelLibraryResynthesizerContext {
+  kernel.Library get library;
+
+  /**
+   * Return the [InterfaceType] for the given Kernel [type], or `null` if the
+   * [type] does not correspond to an [InterfaceType].
+   */
+  InterfaceType getInterfaceType(ElementImpl context, kernel.Supertype type);
+
+  /**
+   * Return the [DartType] for the given Kernel [type], or `null` if the [type]
+   * does not correspond to a [DartType].
+   */
+  DartType getType(ElementImpl context, kernel.DartType type);
+}
+
+/**
  * A concrete implementation of a [LabelElement].
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
@@ -5532,6 +5710,11 @@
 
   final LibraryResynthesizerContext resynthesizerContext;
 
+  /**
+   * The kernel context in which the library is resynthesized.
+   */
+  final KernelLibraryResynthesizerContext _kernelContext;
+
   final UnlinkedUnit _unlinkedDefiningUnit;
 
   /**
@@ -5609,16 +5792,39 @@
    */
   LibraryElementImpl(this.context, String name, int offset, this.nameLength)
       : resynthesizerContext = null,
+        _kernelContext = null,
         _unlinkedDefiningUnit = null,
         super(name, offset);
 
   /**
+   * Initialize using the given kernel information.
+   */
+  LibraryElementImpl.forKernel(this.context, this._kernelContext)
+      : resynthesizerContext = null,
+        _unlinkedDefiningUnit = null,
+        nameLength = _kernelContext.library.name?.length ?? 0,
+        super.forSerialized(null) {
+    _name = _kernelContext.library.name ?? '';
+    _nameOffset = _kernelContext.library.fileOffset;
+    setResolutionCapability(
+        LibraryResolutionCapability.resolvedTypeNames, true);
+    setResolutionCapability(
+        LibraryResolutionCapability.constantExpressions, true);
+
+    definingCompilationUnit = new CompilationUnitElementImpl.forKernel(
+        this, _kernelContext, '<no-name>');
+
+    // TODO(scheglov) how to support parts?
+  }
+
+  /**
    * Initialize a newly created library element in the given [context] to have
    * the given [name].
    */
   LibraryElementImpl.forNode(this.context, LibraryIdentifier name)
       : nameLength = name != null ? name.length : 0,
         resynthesizerContext = null,
+        _kernelContext = null,
         _unlinkedDefiningUnit = null,
         super.forNode(name);
 
@@ -5627,7 +5833,8 @@
    */
   LibraryElementImpl.forSerialized(this.context, String name, int offset,
       this.nameLength, this.resynthesizerContext, this._unlinkedDefiningUnit)
-      : super.forSerialized(null) {
+      : _kernelContext = null,
+        super.forSerialized(null) {
     _name = name;
     _nameOffset = offset;
     setResolutionCapability(
@@ -6306,13 +6513,6 @@
 
   @override
   SourceRange get visibleRange {
-    if (_unlinkedVariable != null) {
-      if (_unlinkedVariable.visibleLength == 0) {
-        return null;
-      }
-      return new SourceRange(
-          _unlinkedVariable.visibleOffset, _unlinkedVariable.visibleLength);
-    }
     if (_visibleRangeLength < 0) {
       return null;
     }
@@ -6339,7 +6539,6 @@
    * [offset] with the given [length].
    */
   void setVisibleRange(int offset, int length) {
-    _assertNotResynthesized(_unlinkedVariable);
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
@@ -6930,18 +7129,33 @@
   final UnlinkedVariable _unlinkedVariable;
 
   /**
+   * The kernel of the element;
+   */
+  final kernel.Field _kernel;
+
+  /**
    * Initialize a newly created variable element to have the given [name] and
    * [offset].
    */
   NonParameterVariableElementImpl(String name, int offset)
       : _unlinkedVariable = null,
+        _kernel = null,
         super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  NonParameterVariableElementImpl.forKernel(
+      ElementImpl enclosingElement, this._kernel)
+      : _unlinkedVariable = null,
+        super.forSerialized(enclosingElement);
+
+  /**
    * Initialize a newly created variable element to have the given [name].
    */
   NonParameterVariableElementImpl.forNode(Identifier name)
       : _unlinkedVariable = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
@@ -6949,7 +7163,8 @@
    */
   NonParameterVariableElementImpl.forSerialized(
       this._unlinkedVariable, ElementImpl enclosingElement)
-      : super.forSerialized(enclosingElement);
+      : _kernel = null,
+        super.forSerialized(enclosingElement);
 
   @override
   int get codeLength {
@@ -7015,6 +7230,9 @@
 
   @override
   bool get isConst {
+    if (_kernel != null) {
+      return _kernel.isConst;
+    }
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.isConst;
     }
@@ -7029,6 +7247,9 @@
 
   @override
   bool get isFinal {
+    if (_kernel != null) {
+      return _kernel.isFinal;
+    }
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.isFinal;
     }
@@ -7052,6 +7273,9 @@
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name.name;
+    }
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.name;
     }
@@ -7069,6 +7293,9 @@
 
   @override
   DartType get type {
+    if (_kernel != null) {
+      return _type ??= enclosingUnit._kernelContext.getType(this, _kernel.type);
+    }
     if (_unlinkedVariable != null && _declaredType == null && _type == null) {
       _type = enclosingUnit.resynthesizerContext
           .resolveLinkedType(this, _unlinkedVariable.inferredTypeSlot);
@@ -8067,6 +8294,18 @@
   PropertyInducingElementImpl(String name, int offset) : super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  PropertyInducingElementImpl.forKernel(
+      ElementImpl enclosingElement, kernel.Field kernel)
+      : super.forKernel(enclosingElement, kernel) {
+    getter = new PropertyAccessorElementImpl_ImplicitGetter(this);
+    if (!isFinal && !isConst) {
+      setter = new PropertyAccessorElementImpl_ImplicitSetter(this);
+    }
+  }
+
+  /**
    * Initialize a newly created element to have the given [name].
    */
   PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
@@ -8277,6 +8516,13 @@
   TopLevelVariableElementImpl(String name, int offset) : super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  TopLevelVariableElementImpl.forKernel(
+      ElementImpl enclosingElement, kernel.Field kernel)
+      : super.forKernel(enclosingElement, kernel);
+
+  /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
@@ -8323,6 +8569,11 @@
   final int nestingLevel;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.TypeParameter _kernel;
+
+  /**
    * The type defined by this type parameter.
    */
   TypeParameterType _type;
@@ -8340,14 +8591,25 @@
   TypeParameterElementImpl(String name, int offset)
       : _unlinkedTypeParam = null,
         nestingLevel = null,
+        _kernel = null,
         super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  TypeParameterElementImpl.forKernel(
+      TypeParameterizedElementMixin enclosingElement, this._kernel)
+      : _unlinkedTypeParam = null,
+        nestingLevel = null,
+        super.forSerialized(enclosingElement);
+
+  /**
    * Initialize a newly created type parameter element to have the given [name].
    */
   TypeParameterElementImpl.forNode(Identifier name)
       : _unlinkedTypeParam = null,
         nestingLevel = null,
+        _kernel = null,
         super.forNode(name);
 
   /**
@@ -8355,7 +8617,8 @@
    */
   TypeParameterElementImpl.forSerialized(this._unlinkedTypeParam,
       TypeParameterizedElementMixin enclosingElement, this.nestingLevel)
-      : super.forSerialized(enclosingElement);
+      : _kernel = null,
+        super.forSerialized(enclosingElement);
 
   /**
    * Initialize a newly created synthetic type parameter element to have the
@@ -8364,18 +8627,26 @@
   TypeParameterElementImpl.synthetic(String name)
       : _unlinkedTypeParam = null,
         nestingLevel = null,
+        _kernel = null,
         super(name, -1) {
     isSynthetic = true;
   }
 
   DartType get bound {
-    if (_unlinkedTypeParam != null) {
-      if (_unlinkedTypeParam.bound == null) {
-        return null;
+    if (_bound == null) {
+      if (_kernel != null) {
+        _bound = enclosingUnit._kernelContext.getType(this, _kernel.bound);
+        // TODO(scheglov) Add a flag for explicit bound.
+        if (_bound != null && _bound.isObject) _bound = null;
       }
-      return _bound ??= enclosingUnit.resynthesizerContext.resolveTypeRef(
-          this, _unlinkedTypeParam.bound,
-          instantiateToBoundsAllowed: false, declaredType: true);
+      if (_unlinkedTypeParam != null) {
+        if (_unlinkedTypeParam.bound == null) {
+          return null;
+        }
+        _bound = enclosingUnit.resynthesizerContext.resolveTypeRef(
+            this, _unlinkedTypeParam.bound,
+            instantiateToBoundsAllowed: false, declaredType: true);
+      }
     }
     return _bound;
   }
@@ -8418,6 +8689,9 @@
 
   @override
   String get name {
+    if (_kernel != null) {
+      return _kernel.name;
+    }
     if (_unlinkedTypeParam != null) {
       return _unlinkedTypeParam.name;
     }
@@ -8523,6 +8797,12 @@
    */
   CompilationUnitElementImpl get enclosingUnit;
 
+  /**
+   * Get the [kernel.TypeParameter]s declared by this element, or `null` if
+   * this elements isn't from a kernel.
+   */
+  List<kernel.TypeParameter> get kernelTypeParams => const [];
+
   @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
@@ -8536,6 +8816,17 @@
   @override
   List<TypeParameterElement> get typeParameters {
     if (_typeParameterElements == null) {
+      List<kernel.TypeParameter> kernelParams = kernelTypeParams;
+      if (kernelParams != null) {
+        int numTypeParameters = kernelParams.length;
+        _typeParameterElements =
+            new List<TypeParameterElement>(numTypeParameters);
+        for (int i = 0; i < numTypeParameters; i++) {
+          _typeParameterElements[i] =
+              new TypeParameterElementImpl.forKernel(this, kernelParams[i]);
+        }
+      }
+
       List<UnlinkedTypeParam> unlinkedParams = unlinkedTypeParams;
       if (unlinkedParams != null) {
         int enclosingNestingLevel =
diff --git a/pkg/analyzer/lib/src/fasta/analyzer.dart b/pkg/analyzer/lib/src/fasta/analyzer.dart
deleted file mode 100644
index 4f4f8ea..0000000
--- a/pkg/analyzer/lib/src/fasta/analyzer.dart
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2016, 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 fasta.analyzer;
-
-import 'package:analyzer/analyzer.dart' show AstNode;
-
-import 'package:analyzer/dart/element/element.dart' show LocalElement;
-
-import 'package:analyzer/src/kernel/ast_from_analyzer.dart'
-    show ExpressionScope;
-
-import 'package:kernel/ast.dart' show Library, TreeNode;
-
-import 'package:front_end/src/fasta/kernel/kernel_builder.dart'
-    show Builder, KernelFormalParameterBuilder, Scope;
-
-import 'element_store.dart' show ElementStore;
-
-export 'ast_builder.dart' show AstBuilder;
-
-export 'element_store.dart' show ElementStore;
-
-TreeNode toKernel(
-    AstNode node, ElementStore store, Library library, Scope scope) {
-  ExpressionScope expressionScope = new ExpressionScope(store, library);
-  scope.forEach((String name, Builder builder) {
-    if (builder is KernelFormalParameterBuilder) {
-      L