Change the approach of front_end top level inference to match the spec.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, 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.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
 ///
 /// Note that these classes represent the Dart language prior to desugaring.
 /// When a single Dart construct desugars to a tree containing multiple kernel
 /// AST nodes, the shadow class extends the kernel object at the top of the
 /// desugared tree.
 ///
 /// This means that in some cases multiple shadow classes may extend the same
 /// kernel class, because multiple constructs in Dart may desugar to a tree
 /// with the same kind of root node.
 import 'package:front_end/src/base/instrumentation.dart';
+import 'package:front_end/src/fasta/type_inference/dependency_collector.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_elimination.dart';
 import 'package:kernel/ast.dart';
 import 'package:kernel/frontend/accessors.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 53 matching lines @@
     arguments.types.addAll(types);
     arguments._hasExplicitTypeArguments = true;
   }
 }
 
 /// Shadow object for [AsExpression].
 class KernelAsExpression extends AsExpression implements KernelExpression {
   KernelAsExpression(Expression operand, DartType type) : super(operand, type);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.asExpressionEnter(this, typeContext) || typeNeeded;
     inferrer.inferExpression(operand, null, false);
     var inferredType = typeNeeded ? type : null;
     inferrer.listener.asExpressionExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [AwaitExpression].
 class KernelAwaitExpression extends AwaitExpression
     implements KernelExpression {
   KernelAwaitExpression(Expression operand) : super(operand);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Inference dependencies are the dependencies of the awaited expression.
+    collector.collectDependencies(operand);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.awaitExpressionEnter(this, typeContext) || typeNeeded;
     if (!inferrer.typeSchemaEnvironment.isEmptyContext(typeContext)) {
       typeContext = inferrer.wrapFutureOrType(typeContext);
     }
     var inferredType =
         inferrer.inferExpression(operand, typeContext, typeNeeded);
     inferredType = inferrer.typeSchemaEnvironment.flattenFutures(inferredType);
@@ skipping 14 matching lines @@
     }
     inferrer.listener.blockExit(this);
   }
 }
 
 /// Concrete shadow object representing a boolean literal in kernel form.
 class KernelBoolLiteral extends BoolLiteral implements KernelExpression {
   KernelBoolLiteral(bool value) : super(value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.boolLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.boolClass.rawType : null;
     inferrer.listener.boolLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
@@ skipping 44 matching lines @@
   }
 
   /// Finalizes the last cascade section with the given [expression].
   void finalize(Expression expression) {
     assert(nextCascade.variable.initializer is InvalidExpression);
     nextCascade.variable.initializer = expression;
     expression.parent = nextCascade.variable;
   }
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // The inference dependencies are the inference dependencies of the cascade
+    // target.
+    collector.collectDependencies(variable.initializer);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.cascadeExpressionEnter(this, typeContext) ||
         typeNeeded;
     var lhsType = inferrer.inferExpression(
         variable.initializer, typeContext, typeNeeded || inferrer.strongMode);
     if (inferrer.strongMode) {
       variable.type = lhsType;
     }
     Let section = body;
     while (true) {
       inferrer.inferExpression(section.variable.initializer, null, false);
       if (section.body is! Let) break;
       section = section.body;
     }
     inferrer.listener.cascadeExpressionExit(this, lhsType);
     return lhsType;
   }
 }
 
 /// Concrete shadow object representing a conditional expression in kernel form.
 /// Shadow object for [ConditionalExpression].
 class KernelConditionalExpression extends ConditionalExpression
     implements KernelExpression {
   KernelConditionalExpression(
       Expression condition, Expression then, Expression otherwise)
       : super(condition, then, otherwise, const DynamicType());
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Inference dependencies are the union of the inference dependencies of the
+    // two returned sub-expressions.
+    collector.collectDependencies(then);
+    collector.collectDependencies(otherwise);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.conditionalExpressionEnter(this, typeContext) ||
             typeNeeded;
-    inferrer.inferExpression(
-        condition, inferrer.coreTypes.boolClass.rawType, false);
+    if (!inferrer.isTopLevel) {
+      inferrer.inferExpression(
+          condition, inferrer.coreTypes.boolClass.rawType, false);
+    }
     // TODO(paulberry): is it correct to pass the context down?
     DartType thenType = inferrer.inferExpression(then, typeContext, true);
     DartType otherwiseType =
         inferrer.inferExpression(otherwise, typeContext, true);
     // TODO(paulberry): the spec proposal says we should only use LUB if the
     // typeContext is `null`.  If typeContext is non-null, we should use the
     // greatest closure of the context with respect to `?`
     DartType type = inferrer.typeSchemaEnvironment
         .getLeastUpperBound(thenType, otherwiseType);
     staticType = type;
     var inferredType = typeNeeded ? type : null;
     inferrer.listener.conditionalExpressionExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [ConstructorInvocation].
 class KernelConstructorInvocation extends ConstructorInvocation
     implements KernelExpression {
   final Member _initialTarget;
 
   KernelConstructorInvocation(
       Constructor target, this._initialTarget, Arguments arguments,
       {bool isConst: false})
       : super(target, arguments, isConst: isConst);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.constructorInvocationEnter(this, typeContext) ||
             typeNeeded;
     var inferredType = inferrer.inferInvocation(
         typeContext,
         typeNeeded,
         fileOffset,
         _initialTarget.function.functionType,
         computeConstructorReturnType(_initialTarget),
         arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
+/// Concrete implementation of [DependencyCollector] specialized to work with
+/// kernel objects.
+class KernelDependencyCollector extends DependencyCollectorImpl {
+  @override
+  void collectDependencies(Expression expression) {
+    if (expression is KernelExpression) {
+      // Use polymorphic dispatch on [KernelExpression] to perform whatever kind
+      // of type inference is correct for this kind of statement.
+      // TODO(paulberry): experiment to see if dynamic dispatch would be better,
+      // so that the type hierarchy will be simpler (which may speed up "is"
+      // checks).
+      expression._collectDependencies(this);
+    } else {
+      // Encountered an expression type for which type inference is not yet
+      // implemented, so just assume the expression does not have an immediately
+      // evident type for now.
+      // TODO(paulberry): once the BodyBuilder uses shadow classes for
+      // everything, this case should no longer be needed.
+      recordNotImmediatelyEvident(expression.fileOffset);
+    }
+  }
+}
+
 /// Shadow object for [DirectMethodInvocation].
 class KernelDirectMethodInvocation extends DirectMethodInvocation
     implements KernelExpression {
   KernelDirectMethodInvocation(
       Expression receiver, Procedure target, Arguments arguments)
       : super(receiver, target, arguments);
 
   KernelDirectMethodInvocation.byReference(
       Expression receiver, Reference targetReference, Arguments arguments)
       : super.byReference(receiver, targetReference, arguments);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // TODO(paulberry): Determine the right thing to do here.
+    throw 'TODO(paulberry)';
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [DirectPropertyGet].
 class KernelDirectPropertyGet extends DirectPropertyGet
     implements KernelExpression {
   KernelDirectPropertyGet(Expression receiver, Member target)
       : super(receiver, target);
 
   KernelDirectPropertyGet.byReference(
       Expression receiver, Reference targetReference)
       : super.byReference(receiver, targetReference);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // TODO(paulberry): Determine the right thing to do here.
+    throw 'TODO(paulberry)';
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [DirectPropertySet].
 class KernelDirectPropertySet extends DirectPropertySet
     implements KernelExpression {
   KernelDirectPropertySet(Expression receiver, Member target, Expression value)
       : super(receiver, target, value);
 
   KernelDirectPropertySet.byReference(
       Expression receiver, Reference targetReference, Expression value)
       : super.byReference(receiver, targetReference, value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Assignment expressions are not immediately evident expressions.
+    collector.recordNotImmediatelyEvident(fileOffset);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Concrete shadow object representing a double literal in kernel form.
 class KernelDoubleLiteral extends DoubleLiteral implements KernelExpression {
   KernelDoubleLiteral(double value) : super(value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.doubleLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType =
         typeNeeded ? inferrer.coreTypes.doubleClass.rawType : null;
     inferrer.listener.doubleLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Common base class for shadow objects representing expressions in kernel
 /// form.
 abstract class KernelExpression implements Expression {
+  /// Collects any dependencies of [expression], and reports errors if the
+  /// expression does not have an immediately evident type.
+  void _collectDependencies(KernelDependencyCollector collector);
+
   /// Calls back to [inferrer] to perform type inference for whatever concrete
   /// type of [KernelExpression] this is.
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded);
 }
 
 /// Concrete shadow object representing an expression statement in kernel form.
 class KernelExpressionStatement extends ExpressionStatement
     implements KernelStatement {
   KernelExpressionStatement(Expression expression) : super(expression);
@@ skipping 11 matching lines @@
 class KernelFactoryConstructorInvocation extends StaticInvocation
     implements KernelExpression {
   final Member _initialTarget;
 
   KernelFactoryConstructorInvocation(
       Procedure target, this._initialTarget, Arguments arguments,
       {bool isConst: false})
       : super(target, arguments, isConst: isConst);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.constructorInvocationEnter(this, typeContext) ||
             typeNeeded;
     var inferredType = inferrer.inferInvocation(
         typeContext,
         typeNeeded,
         fileOffset,
         _initialTarget.function.functionType,
@@ skipping 112 matching lines @@
     inferrer.listener.functionDeclarationExit(this);
   }
 }
 
 /// Concrete shadow object representing a function expression in kernel form.
 class KernelFunctionExpression extends FunctionExpression
     implements KernelExpression {
   KernelFunctionExpression(FunctionNode function) : super(function);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    for (KernelVariableDeclaration parameter in function.positionalParameters) {
+      if (parameter._implicitlyTyped) {
+        collector.recordNotImmediatelyEvident(parameter.fileOffset);
+      }
+    }
+    for (KernelVariableDeclaration parameter in function.namedParameters) {
+      if (parameter._implicitlyTyped) {
+        collector.recordNotImmediatelyEvident(parameter.fileOffset);
+      }
+    }
+    var body = function.body;
+    if (body is ReturnStatement) {
+      // The inference dependencies are the inference dependencies of the return
+      // expression.
+      collector.collectDependencies(body.expression);
+    } else {
+      collector.recordNotImmediatelyEvident(fileOffset);
+    }
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.functionExpressionEnter(this, typeContext) ||
         typeNeeded;
     // TODO(paulberry): do we also need to visit default parameter values?
 
     // Let `<T0, ..., Tn>` be the set of type parameters of the closure (with
     // `n`=0 if there are no type parameters).
     List<TypeParameter> typeParameters = function.typeParameters;
 
@@ skipping 135 matching lines @@
   /// Performs type inference for whatever concrete type of [KernelInitializer]
   /// this is.
   void _inferInitializer(KernelTypeInferrer inferrer);
 }
 
 /// Concrete shadow object representing an integer literal in kernel form.
 class KernelIntLiteral extends IntLiteral implements KernelExpression {
   KernelIntLiteral(int value) : super(value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.intLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.intClass.rawType : null;
     inferrer.listener.intLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a non-inverted "is" test in kernel form.
 class KernelIsExpression extends IsExpression implements KernelExpression {
   KernelIsExpression(Expression operand, DartType type) : super(operand, type);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.isExpressionEnter(this, typeContext) || typeNeeded;
     inferrer.inferExpression(operand, null, false);
     var inferredType = typeNeeded ? inferrer.coreTypes.boolClass.rawType : null;
     inferrer.listener.isExpressionExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing an inverted "is" test in kernel form.
 class KernelIsNotExpression extends Not implements KernelExpression {
   KernelIsNotExpression(Expression operand, DartType type, int charOffset)
       : super(new IsExpression(operand, type)..fileOffset = charOffset);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     IsExpression isExpression = this.operand;
     typeNeeded =
         inferrer.listener.isNotExpressionEnter(this, typeContext) || typeNeeded;
     inferrer.inferExpression(isExpression.operand, null, false);
     var inferredType = typeNeeded ? inferrer.coreTypes.boolClass.rawType : null;
     inferrer.listener.isNotExpressionExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a list literal in kernel form.
 class KernelListLiteral extends ListLiteral implements KernelExpression {
   final DartType _declaredTypeArgument;
 
   KernelListLiteral(List<Expression> expressions,
       {DartType typeArgument, bool isConst: false})
       : _declaredTypeArgument = typeArgument,
         super(expressions,
             typeArgument: typeArgument ?? const DynamicType(),
             isConst: isConst);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    if (_declaredTypeArgument == null) {
+      expressions.forEach(collector.collectDependencies);
+    }
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.listLiteralEnter(this, typeContext) || typeNeeded;
     var listClass = inferrer.coreTypes.listClass;
     var listType = listClass.thisType;
     List<DartType> inferredTypes;
     DartType inferredTypeArgument;
     List<DartType> formalTypes;
     List<DartType> actualTypes;
     bool inferenceNeeded = _declaredTypeArgument == null && inferrer.strongMode;
     if (inferenceNeeded) {
       inferredTypes = [const UnknownType()];
       inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(listType,
           listClass.typeParameters, null, null, typeContext, inferredTypes);
       inferredTypeArgument = inferredTypes[0];
       formalTypes = [];
       actualTypes = [];
     } else {
       inferredTypeArgument = _declaredTypeArgument ?? const DynamicType();
     }
-    for (var expression in expressions) {
-      var expressionType = inferrer.inferExpression(
-          expression, inferredTypeArgument, inferenceNeeded);
-      if (inferenceNeeded) {
-        formalTypes.add(listType.typeArguments[0]);
-        actualTypes.add(expressionType);
+    if (inferenceNeeded || !inferrer.isTopLevel) {
+      for (var expression in expressions) {
+        var expressionType = inferrer.inferExpression(
+            expression, inferredTypeArgument, inferenceNeeded);
+        if (inferenceNeeded) {
+          formalTypes.add(listType.typeArguments[0]);
+          actualTypes.add(expressionType);
+        }
       }
     }
     if (inferenceNeeded) {
       inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
           listType,
           listClass.typeParameters,
           formalTypes,
           actualTypes,
           typeContext,
           inferredTypes);
@@ skipping 13 matching lines @@
   }
 }
 
 /// Shadow object for [LogicalExpression].
 class KernelLogicalExpression extends LogicalExpression
     implements KernelExpression {
   KernelLogicalExpression(Expression left, String operator, Expression right)
       : super(left, operator, right);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [MapLiteral].
 class KernelMapLiteral extends MapLiteral implements KernelExpression {
   final DartType _declaredKeyType;
   final DartType _declaredValueType;
 
   KernelMapLiteral(List<MapEntry> entries,
       {DartType keyType, DartType valueType, bool isConst: false})
       : _declaredKeyType = keyType,
         _declaredValueType = valueType,
         super(entries,
             keyType: keyType ?? const DynamicType(),
             valueType: valueType ?? const DynamicType(),
             isConst: isConst);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    assert((_declaredKeyType == null) == (_declaredValueType == null));
+    if (_declaredKeyType == null) {
+      for (var entry in entries) {
+        collector.collectDependencies(entry.key);
+        collector.collectDependencies(entry.value);
+      }
+    }
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.mapLiteralEnter(this, typeContext) || typeNeeded;
     var mapClass = inferrer.coreTypes.mapClass;
     var mapType = mapClass.thisType;
     List<DartType> inferredTypes;
     DartType inferredKeyType;
     DartType inferredValueType;
     List<DartType> formalTypes;
     List<DartType> actualTypes;
     assert((_declaredKeyType == null) == (_declaredValueType == null));
     bool inferenceNeeded = _declaredKeyType == null && inferrer.strongMode;
     if (inferenceNeeded) {
       inferredTypes = [const UnknownType(), const UnknownType()];
       inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(mapType,
           mapClass.typeParameters, null, null, typeContext, inferredTypes);
       inferredKeyType = inferredTypes[0];
       inferredValueType = inferredTypes[1];
       formalTypes = [];
       actualTypes = [];
     } else {
       inferredKeyType = _declaredKeyType ?? const DynamicType();
       inferredValueType = _declaredValueType ?? const DynamicType();
     }
-    for (var entry in entries) {
-      var keyType =
-          inferrer.inferExpression(entry.key, inferredKeyType, inferenceNeeded);
-      var valueType = inferrer.inferExpression(
-          entry.value, inferredValueType, inferenceNeeded);
-      if (inferenceNeeded) {
-        formalTypes.addAll(mapType.typeArguments);
-        actualTypes.add(keyType);
-        actualTypes.add(valueType);
+    if (inferenceNeeded || !inferrer.isTopLevel) {
+      for (var entry in entries) {
+        var keyType = inferrer.inferExpression(
+            entry.key, inferredKeyType, inferenceNeeded);
+        var valueType = inferrer.inferExpression(
+            entry.value, inferredValueType, inferenceNeeded);
+        if (inferenceNeeded) {
+          formalTypes.addAll(mapType.typeArguments);
+          actualTypes.add(keyType);
+          actualTypes.add(valueType);
+        }
       }
     }
     if (inferenceNeeded) {
       inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
           mapType,
           mapClass.typeParameters,
           formalTypes,
           actualTypes,
           typeContext,
           inferredTypes);
@@ skipping 21 matching lines @@
     implements KernelExpression {
   KernelMethodInvocation(Expression receiver, Name name, Arguments arguments,
       [Procedure interfaceTarget])
       : super(receiver, name, arguments, interfaceTarget);
 
   KernelMethodInvocation.byReference(Expression receiver, Name name,
       Arguments arguments, Reference interfaceTargetReference)
       : super.byReference(receiver, name, arguments, interfaceTargetReference);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // The inference dependencies are the inference dependencies of the
+    // receiver.
+    collector.collectDependencies(receiver);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.methodInvocationEnter(this, typeContext) ||
         typeNeeded;
     // First infer the receiver so we can look up the method that was invoked.
     var receiverType = inferrer.inferExpression(receiver, null, true);
     bool isOverloadedArithmeticOperator = false;
     Member interfaceMember;
     if (receiverType is InterfaceType) {
       interfaceMember = inferrer.classHierarchy
@@ skipping 18 matching lines @@
     inferrer.listener.methodInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [Not].
 class KernelNot extends Not implements KernelExpression {
   KernelNot(Expression operand) : super(operand);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Concrete shadow object representing a null literal in kernel form.
 class KernelNullLiteral extends NullLiteral implements KernelExpression {
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.nullLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.nullClass.rawType : null;
     inferrer.listener.nullLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [PropertyGet].
 class KernelPropertyGet extends PropertyGet implements KernelExpression {
   KernelPropertyGet(Expression receiver, Name name, [Member interfaceTarget])
       : super(receiver, name, interfaceTarget);
 
   KernelPropertyGet.byReference(
       Expression receiver, Name name, Reference interfaceTargetReference)
       : super.byReference(receiver, name, interfaceTargetReference);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // A simple or qualified identifier referring to a top level function,
+    // static variable, field, getter; or a static class variable, static getter
+    // or method; or an instance method; has the inferred type of the referent.
+    // - Otherwise, if the identifier has no inferred or annotated type then it
+    //   is an error.
+    // - Note: specifically, references to instance fields and instance getters
+    //   are disallowed here.
+    // - The inference dependency of the identifier is the referent if the
+    //   referent is a candidate for inference.  Otherwise there are no
+    //   inference dependencies.
+    // TODO(paulberry): implement the proper logic here.

[scheglov, 2017/05/30 18:07:05]

Leaf also asked me to create a version of Analyzer which allows instance getters
with annotated types. He was going to run it over internal codebase to make a
decision.

[Paul Berry, 2017/05/30 20:41:53]

Thanks for the heads up!

+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [PropertyGet].
 class KernelPropertySet extends PropertySet implements KernelExpression {
   KernelPropertySet(Expression receiver, Name name, Expression value,
       [Member interfaceTarget])
       : super(receiver, name, value, interfaceTarget);
 
   KernelPropertySet.byReference(Expression receiver, Name name,
       Expression value, Reference interfaceTargetReference)
       : super.byReference(receiver, name, value, interfaceTargetReference);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Assignment expressions are not immediately evident expressions.
+    collector.recordNotImmediatelyEvident(fileOffset);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Concrete shadow object representing a redirecting initializer in kernel
 /// form.
 class KernelRedirectingInitializer extends RedirectingInitializer
     implements KernelInitializer {
   KernelRedirectingInitializer(Constructor target, Arguments arguments)
       : super(target, arguments);
 
   @override
   _inferInitializer(KernelTypeInferrer inferrer) {
     inferrer.listener.redirectingInitializerEnter(this);
     inferrer.inferInvocation(null, false, fileOffset,
         target.function.functionType, target.enclosingClass.thisType, arguments,
         skipTypeArgumentInference: true);
     inferrer.listener.redirectingInitializerExit(this);
   }
 }
 
 /// Shadow object for [Rethrow].
 class KernelRethrow extends Rethrow implements KernelExpression {
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Concrete shadow object representing a return statement in kernel form.
 class KernelReturnStatement extends ReturnStatement implements KernelStatement {
   KernelReturnStatement([Expression expression]) : super(expression);
@@ skipping 24 matching lines @@
   /// type of [KernelStatement] this is.
   void _inferStatement(KernelTypeInferrer inferrer);
 }
 
 /// Concrete shadow object representing a read of a static variable in kernel
 /// form.
 class KernelStaticGet extends StaticGet implements KernelExpression {
   KernelStaticGet(Member target) : super(target);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // A simple or qualified identifier referring to a top level function,
+    // static variable, field, getter; or a static class variable, static getter
+    // or method; or an instance method; has the inferred type of the referent.
+    // - Otherwise, if the identifier has no inferred or annotated type then it
+    //   is an error.
+    // - Note: specifically, references to instance fields and instance getters
+    //   are disallowed here.
+    // - The inference dependency of the identifier is the referent if the
+    //   referent is a candidate for inference.  Otherwise there are no
+    //   inference dependencies.
+    // TODO(paulberry): implement the proper error checking logic.
+    var target = this.target;
+    if (target is KernelField && target._fieldNode != null) {
+      collector.recordDependency(target._fieldNode);
+    }
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.staticGetEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? target.getterType : null;
     inferrer.listener.staticGetExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [StaticInvocation].
 class KernelStaticInvocation extends StaticInvocation
     implements KernelExpression {
   KernelStaticInvocation(Procedure target, Arguments arguments,
       {bool isConst: false})
       : super(target, arguments, isConst: isConst);
 
   KernelStaticInvocation.byReference(
       Reference targetReference, Arguments arguments)
       : super.byReference(targetReference, arguments);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.staticInvocationEnter(this, typeContext) ||
         typeNeeded;
     var calleeType = target.function.functionType;
     var inferredType = inferrer.inferInvocation(typeContext, typeNeeded,
         fileOffset, calleeType, calleeType.returnType, arguments);
     inferrer.listener.staticInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [StaticSet].
 class KernelStaticSet extends StaticSet implements KernelExpression {
   KernelStaticSet(Member target, Expression value) : super(target, value);
 
   KernelStaticSet.byReference(Reference targetReference, Expression value)
       : super.byReference(targetReference, value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Assignment expressions are not immediately evident expressions.
+    collector.recordNotImmediatelyEvident(fileOffset);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Concrete shadow object representing a string concatenation in kernel form.
 class KernelStringConcatenation extends StringConcatenation
     implements KernelExpression {
   KernelStringConcatenation(List<Expression> expressions) : super(expressions);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.stringConcatenationEnter(this, typeContext) ||
             typeNeeded;
-    for (Expression expression in expressions) {
-      inferrer.inferExpression(expression, null, false);
+    if (!inferrer.isTopLevel) {
+      for (Expression expression in expressions) {
+        inferrer.inferExpression(expression, null, false);
+      }
     }
     var inferredType =
         typeNeeded ? inferrer.coreTypes.stringClass.rawType : null;
     inferrer.listener.stringConcatenationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a string literal in kernel form.
 class KernelStringLiteral extends StringLiteral implements KernelExpression {
   KernelStringLiteral(String value) : super(value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.stringLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType =
         typeNeeded ? inferrer.coreTypes.stringClass.rawType : null;
     inferrer.listener.stringLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [SuperMethodInvocation].
 class KernelSuperMethodInvocation extends SuperMethodInvocation
     implements KernelExpression {
   KernelSuperMethodInvocation(Name name, Arguments arguments,
       [Procedure interfaceTarget])
       : super(name, arguments, interfaceTarget);
 
   KernelSuperMethodInvocation.byReference(
       Name name, Arguments arguments, Reference interfaceTargetReference)
       : super.byReference(name, arguments, interfaceTargetReference);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Super expressions should never occur in top level type inference.
+    // TODO(paulberry): but could they occur due to invalid code?
+    assert(false);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [SuperPropertyGet].
 class KernelSuperPropertyGet extends SuperPropertyGet
     implements KernelExpression {
   KernelSuperPropertyGet(Name name, [Member interfaceTarget])
       : super(name, interfaceTarget);
 
   KernelSuperPropertyGet.byReference(
       Name name, Reference interfaceTargetReference)
       : super.byReference(name, interfaceTargetReference);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Super expressions should never occur in top level type inference.
+    // TODO(paulberry): but could they occur due to invalid code?
+    assert(false);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [SuperPropertySet].
 class KernelSuperPropertySet extends SuperPropertySet
     implements KernelExpression {
   KernelSuperPropertySet(Name name, Expression value, Member interfaceTarget)
       : super(name, value, interfaceTarget);
 
   KernelSuperPropertySet.byReference(
       Name name, Expression value, Reference interfaceTargetReference)
       : super.byReference(name, value, interfaceTargetReference);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Assignment expressions are not immediately evident expressions.
+    collector.recordNotImmediatelyEvident(fileOffset);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [SymbolLiteral].
 class KernelSymbolLiteral extends SymbolLiteral implements KernelExpression {
   KernelSymbolLiteral(String value) : super(value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [ThisExpression].
 class KernelThisExpression extends ThisExpression implements KernelExpression {
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // TODO(paulberry): figure out the right thing to do here.
+    throw 'TODO(paulberry)';
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Shadow object for [Throw].
 class KernelThrow extends Throw implements KernelExpression {
   KernelThrow(Expression expression) : super(expression);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     inferrer.inferExpression(expression, null, false);
     return typeNeeded ? const BottomType() : null;
   }
 }
 
 /// Concrete implementation of [TypeInferenceEngine] specialized to work with
 /// kernel objects.
 class KernelTypeInferenceEngine extends TypeInferenceEngineImpl {
@@ skipping 29 matching lines @@
   bool fieldHasInitializer(KernelField field) {
     return field.initializer != null;
   }
 
   @override
   DartType getFieldDeclaredType(KernelField field) {
     return field._implicitlyTyped ? null : field.type;
   }
 
   @override
-  List<FieldNode> getFieldDependencies(KernelField field) {
-    return field._fieldNode?.dependencies;
-  }
-
-  @override
   int getFieldOffset(KernelField field) {
     return field.fileOffset;
   }
 
   @override
   KernelTypeInferrer getFieldTypeInferrer(KernelField field) {
     return field._typeInferrer;
   }
 
   @override
@@ skipping 21 matching lines @@
   KernelTypeInferrer._(KernelTypeInferenceEngine engine, String uri,
       TypeInferenceListener listener, bool topLevel)
       : super(engine, uri, listener, topLevel);
 
   @override
   Expression getFieldInitializer(KernelField field) {
     return field.initializer;
   }
 
   @override
-  FieldNode getFieldNodeForReadTarget(Member readTarget) {
-    if (readTarget is KernelField) {
-      return readTarget._fieldNode;
-    } else {
-      return null;
-    }
-  }
-
-  @override
   DartType inferExpression(
       Expression expression, DartType typeContext, bool typeNeeded) {
     if (expression is KernelExpression) {
       // Use polymorphic dispatch on [KernelExpression] to perform whatever kind
       // of type inference is correct for this kind of statement.
       // TODO(paulberry): experiment to see if dynamic dispatch would be better,
       // so that the type hierarchy will be simpler (which may speed up "is"
       // checks).
       return expression._inferExpression(this, typeContext, typeNeeded);
     } else {
@@ skipping 44 matching lines @@
       // everything, this case should no longer be needed.
     }
   }
 }
 
 /// Shadow object for [TypeLiteral].
 class KernelTypeLiteral extends TypeLiteral implements KernelExpression {
   KernelTypeLiteral(DartType type) : super(type);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
 /// Concrete implementation of [TypePromoter] specialized to work with kernel
 /// objects.
 ///
@@ skipping 133 matching lines @@
 /// Concrete shadow object representing a read from a variable in kernel form.
 class KernelVariableGet extends VariableGet implements KernelExpression {
   final TypePromotionFact<VariableDeclaration> _fact;
 
   final TypePromotionScope _scope;
 
   KernelVariableGet(VariableDeclaration variable, this._fact, this._scope)
       : super(variable);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // No inference dependencies.
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     var variable = this.variable as KernelVariableDeclaration;
     bool mutatedInClosure = variable._mutatedInClosure;
     DartType declaredOrInferredType = variable.type;
     typeNeeded =
         inferrer.listener.variableGetEnter(this, typeContext) || typeNeeded;
     DartType promotedType = inferrer.typePromoter
         .computePromotedType(_fact, _scope, mutatedInClosure);
     if (promotedType != null) {
       inferrer.instrumentation?.record(Uri.parse(inferrer.uri), fileOffset,
           'promotedType', new InstrumentationValueForType(promotedType));
     }
     this.promotedType = promotedType;
     var inferredType =
         typeNeeded ? (promotedType ?? declaredOrInferredType) : null;
     inferrer.listener.variableGetExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a write to a variable in kernel form.
 class KernelVariableSet extends VariableSet implements KernelExpression {
   KernelVariableSet(VariableDeclaration variable, Expression value)
       : super(variable, value);
 
   @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Assignment expressions are not immediately evident expressions.
+    collector.recordNotImmediatelyEvident(fileOffset);
+  }
+
+  @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     var variable = this.variable as KernelVariableDeclaration;
     typeNeeded =
         inferrer.listener.variableSetEnter(this, typeContext) || typeNeeded;
     var inferredType =
         inferrer.inferExpression(value, variable.type, typeNeeded);
     inferrer.listener.variableSetExit(this, inferredType);
     return inferredType;
   }
@@ skipping 16 matching lines @@
           closureContext.isAsync
               ? inferrer.coreTypes.streamClass
               : inferrer.coreTypes.iterableClass);
     }
     var inferredType = inferrer.inferExpression(
         expression, typeContext, closureContext != null);
     closureContext.handleYield(inferrer, isYieldStar, inferredType);
     inferrer.listener.yieldStatementExit(this);
   }
 }