Lift nearly all top-level type inference restrictions.

pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.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.md file.
 
 import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/dependency_walker.dart' as dependencyWalker;
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.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_schema_environment.dart';
@@ skipping 17 matching lines @@
 
   FieldNode(this._typeInferenceEngine, this._field);
 
   @override
   bool get isEvaluated => _typeInferenceEngine.isFieldInferred(_field);
 
   @override
   List<FieldNode> computeDependencies() {
     return _typeInferenceEngine.computeFieldDependencies(this);
   }
+
+  @override
+  String toString() => _field.toString();
 }
 
 /// Keeps track of the global state for the type inference that occurs outside
 /// of method bodies and initalizers.
 ///
 /// This class describes the interface for use by clients of type inference
 /// (e.g. DietListener).  Derived classes should derive from
 /// [TypeInferenceEngineImpl].
 abstract class TypeInferenceEngine {
   ClassHierarchy get classHierarchy;
@@ skipping 27 matching lines @@
   void recordInitializingFormal(KernelVariableDeclaration formal);
 }
 
 /// Derived class containing generic implementations of
 /// [TypeInferenceEngineImpl].
 ///
 /// This class contains as much of the implementation of type inference as
 /// possible without knowing the identity of the type parameter.  It defers to
 /// abstract methods for everything else.
 abstract class TypeInferenceEngineImpl extends TypeInferenceEngine {
+  /// Enables "expanded top level inference", which allows top level inference
+  /// to support all expressions, not just those defined as "immediately
+  /// evident" by https://github.com/dart-lang/sdk/pull/28218.
+  ///
+  /// Note that setting this value to `true` does not yet allow top level
+  /// inference to depend on field and property accesses; that will require
+  /// further work.  TODO(paulberry): fix this.
+  static const bool expandedTopLevelInference = true;
+
   final Instrumentation instrumentation;
 
   final bool strongMode;
 
   final fieldNodes = <FieldNode>[];
 
   final initializingFormals = <KernelVariableDeclaration>[];
 
   @override
   CoreTypes coreTypes;
 
   @override
   ClassHierarchy classHierarchy;
 
   TypeSchemaEnvironment typeSchemaEnvironment;
 
   TypeInferenceEngineImpl(this.instrumentation, this.strongMode);
 
   /// Clears the initializer of [field].
   void clearFieldInitializer(KernelField field);
 
   /// Computes type inference dependencies for the given [field].
   List<FieldNode> computeFieldDependencies(FieldNode fieldNode) {
     // TODO(paulberry): add logic to infer field types by inheritance.
     if (fieldHasInitializer(fieldNode._field)) {
-      var collector = new KernelDependencyCollector();
-      collector.collectDependencies(fieldNode._field.initializer);
-      fieldNode.isImmediatelyEvident = collector.isImmediatelyEvident;
-      return collector.dependencies;
+      if (expandedTopLevelInference) {
+        // In expanded top level inference, we determine the dependencies by
+        // doing a "dry run" of top level inference and recording which static
+        // fields were accessed.
+        var typeInferrer = getFieldTypeInferrer(fieldNode._field);
+        typeInferrer.startDryRun();
+        typeInferrer.listener.dryRunEnter(fieldNode._field.initializer);
+        typeInferrer.inferFieldTopLevel(fieldNode._field, null, true);
+        typeInferrer.listener.dryRunExit(fieldNode._field.initializer);
+        fieldNode.isImmediatelyEvident = true;
+        return typeInferrer.finishDryRun();
+      } else {
+        // In non-expanded top level inference, we determine the dependencies by
+        // calling `collectDependencies`; as a side effect this flags any
+        // expressions that are not "immediately evident".
+        // TODO(paulberry): get rid of this mode once we are sure we no longer
+        // need it.
+        var collector = new KernelDependencyCollector();
+        collector.collectDependencies(fieldNode._field.initializer);
+        fieldNode.isImmediatelyEvident = collector.isImmediatelyEvident;
+        return collector.dependencies;
+      }
     } else {
       return const [];
     }
   }
 
   /// Creates a [FieldNode] to track dependencies of the given [field].
   FieldNode createFieldNode(KernelField field);
 
   /// Queries whether the given [field] has an initializer.
   bool fieldHasInitializer(KernelField field);
@@ skipping 113 matching lines @@
   }
 
   @override
   void evaluateScc(List<FieldNode> scc) {
     // Mark every field as part of a circularity.
     for (var f in scc) {
       f._typeInferenceEngine.inferFieldCircular(f._field);
     }
   }
 }