Perform type inference on explicitly typed fields.

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`.
@@ skipping 1052 matching lines @@
   @override
   FieldNode createFieldNode(KernelField field) {
     FieldNode fieldNode = new FieldNode(this, field);
     field._fieldNode = fieldNode;
     return fieldNode;
   }
 
   @override
   KernelTypeInferrer createLocalTypeInferrer(
       Uri uri, TypeInferenceListener listener) {
-    return new KernelTypeInferrer._(this, uri.toString(), listener);
+    return new KernelTypeInferrer._(this, uri.toString(), listener, false);
   }
 
   @override
   KernelTypeInferrer createTopLevelTypeInferrer(
       KernelField field, TypeInferenceListener listener) {
     return field._typeInferrer =
-        new KernelTypeInferrer._(this, getFieldUri(field), listener);
+        new KernelTypeInferrer._(this, getFieldUri(field), listener, true);
   }
 
   @override
   bool fieldHasInitializer(KernelField field) {
     return field.initializer != null;
   }
 
   @override
   DartType getFieldDeclaredType(KernelField field) {
     return field._implicitlyTyped ? null : field.type;
@@ skipping 30 matching lines @@
   }
 }
 
 /// Concrete implementation of [TypeInferrer] specialized to work with kernel
 /// objects.
 class KernelTypeInferrer extends TypeInferrerImpl {
   @override
   final typePromoter = new KernelTypePromoter();
 
   KernelTypeInferrer._(KernelTypeInferenceEngine engine, String uri,
-      TypeInferenceListener listener)
-      : super(engine, uri, listener);
+      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;
@@ skipping 15 matching lines @@
     } else {
       // Encountered an expression type for which type inference is not yet
       // implemented, so just infer dynamic for now.
       // TODO(paulberry): once the BodyBuilder uses shadow classes for
       // everything, this case should no longer be needed.
       return typeNeeded ? const DynamicType() : null;
     }
   }
 
   @override
-  DartType inferFieldInitializer(
+  DartType inferFieldTopLevel(
       KernelField field, DartType type, bool typeNeeded) {
     return inferExpression(field.initializer, type, typeNeeded);
   }
 
   @override
   void inferStatement(Statement statement) {
     if (statement is KernelStatement) {
       // Use polymorphic dispatch on [KernelStatement] 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,
@@ skipping 223 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);
   }
 }