Run formatter on a few frontend and kernel files that hadn't been formatted.

pkg/kernel/lib/frontend/accessors.dart

 // 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.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 library kernel.frontend.accessors;
 
 import '../ast.dart';
 
@@ skipping 133 matching lines @@
   DartType promotedType;
 
   VariableAccessor(this.variable, this.promotedType, int offset)
       : super(offset);
 
   _makeRead() => new VariableGet(variable, promotedType)..fileOffset = offset;
 
   _makeWrite(Expression value, bool voidContext) {
     return variable.isFinal || variable.isConst
         ? makeInvalidWrite(value)
-        : new VariableSet(variable, value)..fileOffset = offset;
+        : new VariableSet(variable, value)
+      ..fileOffset = offset;
   }
 }
 
 class PropertyAccessor extends Accessor {
   VariableDeclaration _receiverVariable;
   Expression receiver;
   Name name;
   Member getter, setter;
 
   static Accessor make(
@@ skipping 120 matching lines @@
       this.receiver, this.index, this.getter, this.setter, int offset)
       : super(offset);
 
   _makeSimpleRead() => new MethodInvocation(
       receiver, indexGetName, new Arguments(<Expression>[index]), getter)
     ..fileOffset = offset;
 
   _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new MethodInvocation(receiver, indexSetName,
-        new Arguments(<Expression>[index, value]), setter)..fileOffset = offset;
+        new Arguments(<Expression>[index, value]), setter)
+      ..fileOffset = offset;
   }
 
   receiverAccess() {
     // We cannot reuse the receiver if it is a variable since it might be
     // reassigned in the index expression.
     receiverVariable ??= new VariableDeclaration.forValue(receiver);
     return new VariableGet(receiverVariable)..fileOffset = offset;
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable)..fileOffset = offset;
   }
 
   _makeRead() {
-    return builtGetter = new MethodInvocation(
-        receiverAccess(),
-        indexGetName,
-        new Arguments(<Expression>[indexAccess()]),
-        getter)..fileOffset = offset;
+    return builtGetter = new MethodInvocation(receiverAccess(), indexGetName,
+        new Arguments(<Expression>[indexAccess()]), getter)
+      ..fileOffset = offset;
   }
 
   _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return new MethodInvocation(
-        receiverAccess(),
-        indexSetName,
-        new Arguments(<Expression>[indexAccess(), value]),
-        setter)..fileOffset = offset;
+    return new MethodInvocation(receiverAccess(), indexSetName,
+        new Arguments(<Expression>[indexAccess(), value]), setter)
+      ..fileOffset = offset;
   }
 
   // TODO(dmitryas): remove this method after the "[]=" operator of the Context
   // class is made to return a value.
   _makeWriteAndReturn(Expression value) {
     // The call to []= does not return the value like direct-style assignments
     // do.  We need to bind the value in a let.
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new MethodInvocation(
         receiverAccess(),
         indexSetName,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
-        setter)..fileOffset = offset);
+        setter)
+      ..fileOffset = offset);
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) {
     return makeLet(receiverVariable, makeLet(indexVariable, body));
   }
 }
 
 /// Special case of [IndexAccessor] to avoid creating an indirect access to
@@ skipping 94 matching lines @@
     return makeLet(indexVariable, body);
   }
 }
 
 class StaticAccessor extends Accessor {
   Member readTarget;
   Member writeTarget;
 
   StaticAccessor(this.readTarget, this.writeTarget, int offset) : super(offset);
 
-  _makeRead() => builtGetter = readTarget == null
-      ? makeInvalidRead()
-      : new StaticGet(readTarget)..fileOffset = offset;
+  _makeRead() => builtGetter =
+      readTarget == null ? makeInvalidRead() : new StaticGet(readTarget)
+        ..fileOffset = offset;
 
   _makeWrite(Expression value, bool voidContext) {
     return writeTarget == null
         ? makeInvalidWrite(value)
-        : new StaticSet(writeTarget, value)..fileOffset = offset;
+        : new StaticSet(writeTarget, value)
+      ..fileOffset = offset;
   }
 }
 
 class ReadOnlyAccessor extends Accessor {
   Expression expression;
   VariableDeclaration value;
 
   ReadOnlyAccessor(this.expression, int offset) : super(offset);
 
   _makeSimpleRead() => expression;
@@ skipping 30 matching lines @@
 
 VariableDeclaration makeOrReuseVariable(Expression value) {
   // TODO: Devise a way to remember if a variable declaration was reused
   // or is fresh (hence needs a let binding).
   return new VariableDeclaration.forValue(value);
 }
 
 Expression wrapInvalid(Expression e) {
   return new Let(new VariableDeclaration.forValue(e), new InvalidExpression());
 }