Fuse top level type inference with dependency generation.

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 353 matching lines @@
       inferrer.findMethodInvocationMember(writeContext, equalsInvocation,
           silent: true);
       return inferrer.typeSchemaEnvironment
           .getLeastUpperBound(inferredType, rhsType);
     } else if (combiner != null) {
       bool isOverloadedArithmeticOperator = false;
       var combinerMember = inferrer
           .findMethodInvocationMember(writeContext, combiner, silent: true);
       if (combinerMember is Procedure) {
         isOverloadedArithmeticOperator = inferrer.typeSchemaEnvironment
-            .isOverloadedArithmeticOperator(combinerMember);
+            .isOverloadedArithmeticOperatorAndType(
+                combinerMember, writeContext);
       }
       if (isPostIncDec) {
         return inferredType;
       } else {
         DartType rhsType;
         if (isPreIncDec) {
           rhsType = inferrer.coreTypes.intClass.rawType;
         } else {
           // Analyzer uses a null context for the RHS here.
           // TODO(paulberry): improve on this.
@@ skipping 294 matching lines @@
         arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a field in kernel form.
 class KernelField extends Field {
   FieldNode _fieldNode;
 
-  bool _isInferred = false;
-
   KernelTypeInferrer _typeInferrer;
 
   KernelField(Name name, {String fileUri}) : super(name, fileUri: fileUri) {}
-
-  void _setInferredType(DartType inferredType) {
-    _isInferred = true;
-    super.type = inferredType;
-  }
 }
 
 /// Concrete shadow object representing a for-in loop in kernel form.
 class KernelForInStatement extends ForInStatement implements KernelStatement {
   final bool _declaresVariable;
 
   KernelForInStatement(VariableDeclaration variable, Expression iterable,
       Statement body, this._declaresVariable,
       {bool isAsync: false})
       : super(variable, iterable, body, isAsync: isAsync);
@@ skipping 596 matching lines @@
       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 =
         inferrer.findMethodInvocationMember(receiverType, this);
     if (interfaceMember is Procedure) {
       isOverloadedArithmeticOperator = inferrer.typeSchemaEnvironment
-          .isOverloadedArithmeticOperator(interfaceMember);
+          .isOverloadedArithmeticOperatorAndType(interfaceMember, receiverType);
     }
     var calleeType = inferrer.getCalleeFunctionType(
         interfaceMember, receiverType, name, !_isImplicitCall);
     bool forceArgumentInference = false;
     if (inferrer.isDryRun) {
       if (_isUserDefinableOperator(name.name)) {
         // If this is an overloadable arithmetic operator, then type inference
         // might depend on the RHS, so conservatively assume it does.
         forceArgumentInference = _isOverloadableArithmeticOperator(name.name);
       } else {
@@ skipping 262 matching lines @@
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.staticAssignEnter(desugared, typeContext) ||
         typeNeeded;
     // TODO(paulberry): record the appropriate types on let variables and
     // conditional expressions.
     DartType writeContext;
     var write = this.write;
     if (write is StaticSet) {
       writeContext = write.target.setterType;
-      if (inferrer.isDryRun) {
-        var target = write.target;
-        if (target is KernelField && target._fieldNode != null) {
+      var target = write.target;
+      if (target is KernelField && target._fieldNode != null) {
+        if (inferrer.isDryRun) {
           inferrer.recordDryRunDependency(target._fieldNode);
         }
+        if (TypeInferenceEngineImpl.fusedTopLevelInference &&
+            inferrer.isTopLevel) {
+          inferrer.engine
+              .inferFieldFused(target._fieldNode, inferrer.fieldNode);
+        }
       }
     }
     var inferredType = _inferRhs(inferrer, writeContext);
     inferrer.listener.staticAssignExit(desugared, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a read of a static variable in kernel
 /// form.
@@ skipping 17 matching lines @@
     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;
-    if (inferrer.isDryRun) {
-      var target = this.target;
-      if (target is KernelField && target._fieldNode != null) {
+    var target = this.target;
+    if (target is KernelField && target._fieldNode != null) {
+      if (inferrer.isDryRun) {
         inferrer.recordDryRunDependency(target._fieldNode);
       }
+      if (TypeInferenceEngineImpl.fusedTopLevelInference &&
+          inferrer.isTopLevel) {
+        inferrer.engine.inferFieldFused(target._fieldNode, inferrer.fieldNode);
+      }
     }
     var inferredType = typeNeeded ? target.getterType : null;
     inferrer.listener.staticGetExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [StaticInvocation].
 class KernelStaticInvocation extends StaticInvocation
     implements KernelExpression {
@@ skipping 233 matching lines @@
   FieldNode createFieldNode(KernelField field) {
     FieldNode fieldNode = new FieldNode(this, field);
     field._fieldNode = fieldNode;
     return fieldNode;
   }
 
   @override
   KernelTypeInferrer createLocalTypeInferrer(
       Uri uri, TypeInferenceListener listener, InterfaceType thisType) {
     return new KernelTypeInferrer._(
-        this, uri.toString(), listener, false, thisType);
+        this, uri.toString(), listener, false, thisType, null);
   }
 
   @override
   KernelTypeInferrer createTopLevelTypeInferrer(TypeInferenceListener listener,
       InterfaceType thisType, KernelField field) {
-    return field._typeInferrer =
-        new KernelTypeInferrer._(this, field.fileUri, listener, true, thisType);
+    return field._typeInferrer = new KernelTypeInferrer._(
+        this, field.fileUri, listener, true, thisType, field._fieldNode);
   }
 
   @override
   int getFieldOffset(KernelField field) {
     return field.fileOffset;
   }
 
   @override
   KernelTypeInferrer getFieldTypeInferrer(KernelField field) {
     return field._typeInferrer;
   }
-
-  @override
-  bool isFieldInferred(KernelField field) {
-    return field._isInferred;
-  }
-
-  @override
-  void setFieldInferredType(KernelField field, DartType inferredType) {
-    field._setInferredType(inferredType);
-  }
 }
 
 /// 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, bool topLevel, InterfaceType thisType)
-      : super(engine, uri, listener, topLevel, thisType);
+  KernelTypeInferrer._(
+      KernelTypeInferenceEngine engine,
+      String uri,
+      TypeInferenceListener listener,
+      bool topLevel,
+      InterfaceType thisType,
+      FieldNode fieldNode)
+      : super(engine, uri, listener, topLevel, thisType, fieldNode);
 
   @override
   Expression getFieldInitializer(KernelField field) {
     return field.initializer;
   }
 
   @override
   DartType inferExpression(
       Expression expression, DartType typeContext, bool typeNeeded) {
     // When doing top level inference, we skip subexpressions whose type isn't
@@ skipping 327 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }