Add explicit return types to work around #29398.

pkg/front_end/lib/src/fasta/kernel/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.
 
 import 'package:kernel/ast.dart';
 
 final Name indexGetName = new Name("[]");
@@ skipping 127 matching lines @@
   makeInvalidWrite(Expression value) => wrapInvalid(value);
 }
 
 class VariableAccessor extends Accessor {
   VariableDeclaration variable;
   DartType promotedType;
 
   VariableAccessor(this.variable, this.promotedType, int offset)
       : super(offset);
 
-  _makeRead() => new VariableGet(variable, promotedType)..fileOffset = offset;
+  Expression _makeRead() =>
+      new VariableGet(variable, promotedType)..fileOffset = offset;
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     return variable.isFinal || variable.isConst
         ? makeInvalidWrite(value)
         : new VariableSet(variable, value)
       ..fileOffset = offset;
   }
 }
 
 class PropertyAccessor extends Accessor {
   VariableDeclaration _receiverVariable;
   Expression receiver;
   Name name;
   Member getter, setter;
 
   static Accessor make(
       Expression receiver, Name name, Member getter, Member setter,
       {int offset: TreeNode.noOffset}) {
     if (receiver is ThisExpression) {
       return new ThisPropertyAccessor(name, getter, setter, offset);
     } else {
       return new PropertyAccessor.internal(
           receiver, name, getter, setter, offset);
     }
   }
 
   PropertyAccessor.internal(
       this.receiver, this.name, this.getter, this.setter, int offset)
       : super(offset);
 
-  _makeSimpleRead() =>
+  Expression _makeSimpleRead() =>
       new PropertyGet(receiver, name, getter)..fileOffset = offset;
 
-  _makeSimpleWrite(Expression value, bool voidContext) {
+  Expression _makeSimpleWrite(Expression value, bool voidContext) {
     return new PropertySet(receiver, name, value, setter)..fileOffset = offset;
   }
 
   receiverAccess() {
     _receiverVariable ??= new VariableDeclaration.forValue(receiver);
     return new VariableGet(_receiverVariable)..fileOffset = offset;
   }
 
-  _makeRead() => builtGetter = new PropertyGet(receiverAccess(), name, getter)
-    ..fileOffset = offset;
+  Expression _makeRead() => builtGetter =
+      new PropertyGet(receiverAccess(), name, getter)..fileOffset = offset;
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     return new PropertySet(receiverAccess(), name, value, setter)
       ..fileOffset = offset;
   }
 
-  _finish(Expression body) => makeLet(_receiverVariable, body);
+  Expression _finish(Expression body) => makeLet(_receiverVariable, body);
 }
 
 /// Special case of [PropertyAccessor] to avoid creating an indirect access to
 /// 'this'.
 class ThisPropertyAccessor extends Accessor {
   Name name;
   Member getter, setter;
 
   ThisPropertyAccessor(this.name, this.getter, this.setter, int offset)
       : super(offset);
 
-  _makeRead() => builtGetter =
+  Expression _makeRead() => builtGetter =
       new PropertyGet(new ThisExpression(), name, getter)..fileOffset = offset;
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     return new PropertySet(new ThisExpression(), name, value, setter)
       ..fileOffset = offset;
   }
 }
 
 class NullAwarePropertyAccessor extends Accessor {
   VariableDeclaration receiver;
   Name name;
   Member getter, setter;
   DartType type;
 
   NullAwarePropertyAccessor(Expression receiver, this.name, this.getter,
       this.setter, this.type, int offset)
       : this.receiver = makeOrReuseVariable(receiver),
         super(offset);
 
   receiverAccess() => new VariableGet(receiver);
 
-  _makeRead() => builtGetter = new PropertyGet(receiverAccess(), name, getter);
+  Expression _makeRead() =>
+      builtGetter = new PropertyGet(receiverAccess(), name, getter);
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     return new PropertySet(receiverAccess(), name, value, setter);
   }
 
-  _finish(Expression body) => makeLet(
+  Expression _finish(Expression body) => makeLet(
       receiver,
       new ConditionalExpression(
           buildIsNull(receiverAccess()), new NullLiteral(), body, type));
 }
 
 class SuperPropertyAccessor extends Accessor {
   Name name;
   Member getter, setter;
 
   SuperPropertyAccessor(this.name, this.getter, this.setter, int offset)
       : super(offset);
 
-  _makeRead() {
+  Expression _makeRead() {
     if (getter == null) return makeInvalidRead();
     // TODO(ahe): Use [DirectPropertyGet] when possible.
     return builtGetter = new SuperPropertyGet(name, getter)
       ..fileOffset = offset;
   }
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     if (setter == null) return makeInvalidWrite(value);
     // TODO(ahe): Use [DirectPropertySet] when possible.
     return new SuperPropertySet(name, value, setter)..fileOffset = offset;
   }
 }
 
 class IndexAccessor extends Accessor {
   Expression receiver;
   Expression index;
   VariableDeclaration receiverVariable;
   VariableDeclaration indexVariable;
   Procedure getter, setter;
 
   static Accessor make(
       Expression receiver, Expression index, Procedure getter, Procedure setter,
       {int offset: TreeNode.noOffset}) {
     if (receiver is ThisExpression) {
       return new ThisIndexAccessor(index, getter, setter, offset);
     } else {
       return new IndexAccessor.internal(
           receiver, index, getter, setter, offset);
     }
   }
 
   IndexAccessor.internal(
       this.receiver, this.index, this.getter, this.setter, int offset)
       : super(offset);
 
-  _makeSimpleRead() => new MethodInvocation(
+  Expression _makeSimpleRead() => new MethodInvocation(
       receiver, indexGetName, new Arguments(<Expression>[index]), getter)
     ..fileOffset = offset;
 
-  _makeSimpleWrite(Expression value, bool voidContext) {
+  Expression _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new MethodInvocation(receiver, indexSetName,
         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() {
+  Expression _makeRead() {
     return builtGetter = new MethodInvocation(receiverAccess(), indexGetName,
         new Arguments(<Expression>[indexAccess()]), getter)
       ..fileOffset = offset;
   }
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     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
@@ skipping 18 matching lines @@
 /// Special case of [IndexAccessor] to avoid creating an indirect access to
 /// 'this'.
 class ThisIndexAccessor extends Accessor {
   Expression index;
   VariableDeclaration indexVariable;
   Procedure getter, setter;
 
   ThisIndexAccessor(this.index, this.getter, this.setter, int offset)
       : super(offset);
 
-  _makeSimpleRead() {
+  Expression _makeSimpleRead() {
     return new MethodInvocation(new ThisExpression(), indexGetName,
         new Arguments(<Expression>[index]), getter);
   }
 
-  _makeSimpleWrite(Expression value, bool voidContext) {
+  Expression _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new MethodInvocation(new ThisExpression(), indexSetName,
         new Arguments(<Expression>[index, value]), setter);
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable);
   }
 
-  _makeRead() => builtGetter = new MethodInvocation(new ThisExpression(),
-      indexGetName, new Arguments(<Expression>[indexAccess()]), getter);
+  Expression _makeRead() => builtGetter = new MethodInvocation(
+      new ThisExpression(),
+      indexGetName,
+      new Arguments(<Expression>[indexAccess()]),
+      getter);
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new MethodInvocation(new ThisExpression(), indexSetName,
         new Arguments(<Expression>[indexAccess(), value]), setter);
   }
 
   _makeWriteAndReturn(Expression value) {
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new MethodInvocation(
         new ThisExpression(),
         indexSetName,
@@ skipping 13 matching lines @@
   Member getter, setter;
 
   SuperIndexAccessor(this.index, this.getter, this.setter, int offset)
       : super(offset);
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable);
   }
 
-  _makeSimpleRead() => new SuperMethodInvocation(
+  Expression _makeSimpleRead() => new SuperMethodInvocation(
       indexGetName, new Arguments(<Expression>[index]), getter);
 
-  _makeSimpleWrite(Expression value, bool voidContext) {
+  Expression _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new SuperMethodInvocation(
         indexSetName, new Arguments(<Expression>[index, value]), setter);
   }
 
-  _makeRead() {
+  Expression _makeRead() {
     return builtGetter = new SuperMethodInvocation(
         indexGetName, new Arguments(<Expression>[indexAccess()]), getter);
   }
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return new SuperMethodInvocation(indexSetName,
         new Arguments(<Expression>[indexAccess(), value]), setter);
   }
 
   _makeWriteAndReturn(Expression value) {
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new SuperMethodInvocation(
         indexSetName,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
         setter));
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) {
     return makeLet(indexVariable, body);
   }
 }
 
 class StaticAccessor extends Accessor {
   Member readTarget;
   Member writeTarget;
 
   StaticAccessor(this.readTarget, this.writeTarget, int offset) : super(offset);
 
-  _makeRead() => builtGetter =
+  Expression _makeRead() => builtGetter =
       readTarget == null ? makeInvalidRead() : new StaticGet(readTarget)
         ..fileOffset = offset;
 
-  _makeWrite(Expression value, bool voidContext) {
+  Expression _makeWrite(Expression value, bool voidContext) {
     return writeTarget == null
         ? makeInvalidWrite(value)
         : new StaticSet(writeTarget, value)
       ..fileOffset = offset;
   }
 }
 
 class ReadOnlyAccessor extends Accessor {
   Expression expression;
   VariableDeclaration value;
 
   ReadOnlyAccessor(this.expression, int offset) : super(offset);
 
-  _makeSimpleRead() => expression;
+  Expression _makeSimpleRead() => expression;
 
-  _makeRead() {
+  Expression _makeRead() {
     value ??= new VariableDeclaration.forValue(expression);
     return new VariableGet(value);
   }
 
-  _makeWrite(Expression value, bool voidContext) => makeInvalidWrite(value);
+  Expression _makeWrite(Expression value, bool voidContext) =>
+      makeInvalidWrite(value);
 
   Expression _finish(Expression body) => makeLet(value, body);
 }
 
 Expression makeLet(VariableDeclaration variable, Expression body) {
   if (variable == null) return body;
   return new Let(variable, body);
 }
 
 Expression makeBinary(
@@ skipping 13 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());
 }