Lift nearly all top-level type inference restrictions.

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 35 matching lines @@
   if (arguments is KernelArguments) {
     return arguments._hasExplicitTypeArguments ? arguments.types : null;
   } else {
     // This code path should only be taken in situations where there are no
     // type arguments at all, e.g. calling a user-definable operator.
     assert(arguments.types.isEmpty);
     return null;
   }
 }
 
+bool _isOverloadableArithmeticOperator(String name) {
+  return identical(name, '+') ||
+      identical(name, '-') ||
+      identical(name, '*') ||
+      identical(name, '%');
+}
+
+bool _isUserDefinableOperator(String name) {
+  return identical(name, '<') ||
+      identical(name, '>') ||
+      identical(name, '<=') ||
+      identical(name, '>=') ||
+      identical(name, '==') ||
+      identical(name, '-') ||
+      identical(name, '+') ||
+      identical(name, '/') ||
+      identical(name, '~/') ||
+      identical(name, '*') ||
+      identical(name, '%') ||
+      identical(name, '|') ||
+      identical(name, '^') ||
+      identical(name, '&') ||
+      identical(name, '<<') ||
+      identical(name, '>>') ||
+      identical(name, '[]=') ||
+      identical(name, '~');
+}
+
 /// Concrete shadow object representing a set of invocation arguments.
 class KernelArguments extends Arguments {
   bool _hasExplicitTypeArguments;
 
   KernelArguments(List<Expression> positional,
       {List<DartType> types, List<NamedExpression> named})
       : _hasExplicitTypeArguments = types != null && types.isNotEmpty,
         super(positional, types: types, named: named);
 
   static void setExplicitArgumentTypes(
@@ skipping 683 matching lines @@
     for (var parameter in function.positionalParameters) {
       if (parameter.initializer != null) {
         inferrer.inferExpression(parameter.initializer, parameter.type, false);
       }
     }
     for (var parameter in function.namedParameters) {
       if (parameter.initializer != null) {
         inferrer.inferExpression(parameter.initializer, parameter.type, false);
       }
     }
-    var oldClosureContext = inferrer.closureContext;
-    inferrer.closureContext =
-        new ClosureContext(inferrer, function.asyncMarker, function.returnType);
-    inferrer.inferStatement(function.body);
-    inferrer.closureContext = oldClosureContext;
+    if (!inferrer.isTopLevel) {
+      var oldClosureContext = inferrer.closureContext;
+      inferrer.closureContext = new ClosureContext(
+          inferrer, function.asyncMarker, function.returnType);
+      inferrer.inferStatement(function.body);
+      inferrer.closureContext = oldClosureContext;
+    }
     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
@@ skipping 492 matching lines @@
   KernelMethodInvocation(Expression receiver, Name name, Arguments arguments,
       {bool isImplicitCall: false, Member interfaceTarget})
       : _isImplicitCall = isImplicitCall,
         super(receiver, name, arguments, interfaceTarget);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // The inference dependencies are the inference dependencies of the
     // receiver.
     collector.collectDependencies(receiver);
-    if (identical(name, '+') ||
-        identical(name, '-') ||
-        identical(name, '*') ||
-        identical(name, '%')) {
+    if (_isOverloadableArithmeticOperator(name.name)) {
       collector.collectDependencies(arguments.positional[0]);
     }
   }
 
   @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 =
         inferrer.findMethodInvocationMember(receiverType, this);
     if (interfaceMember is Procedure) {
       isOverloadedArithmeticOperator = inferrer.typeSchemaEnvironment
           .isOverloadedArithmeticOperator(interfaceMember);
     }
     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 {
+        // If no type arguments were given, then type inference might depend on
+        // the arguments (because the called method might be generic), so
+        // conservatively assume it does.
+        forceArgumentInference = getExplicitTypeArguments(arguments) == null;
+      }
+    }
     var inferredType = inferrer.inferInvocation(typeContext, typeNeeded,
         fileOffset, calleeType, calleeType.returnType, arguments,
         isOverloadedArithmeticOperator: isOverloadedArithmeticOperator,
-        receiverType: receiverType);
+        receiverType: receiverType,
+        forceArgumentInference: forceArgumentInference);
     inferrer.listener.methodInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [Not].
 class KernelNot extends Not implements KernelExpression {
   KernelNot(Expression operand) : super(operand);
 
   @override
@@ skipping 57 matching lines @@
             typeNeeded;
     // TODO(paulberry): record the appropriate types on let variables and
     // conditional expressions.
     var receiverType = _inferReceiver(inferrer);
     if (read != null) {
       inferrer.findPropertyGetMember(receiverType, read, silent: true);
     }
     Member writeMember;
     if (write != null) {
       writeMember = inferrer.findPropertySetMember(receiverType, write);
+      if (inferrer.isTopLevel &&
+          ((writeMember is Procedure &&
+                  writeMember.kind == ProcedureKind.Setter) ||
+              writeMember is Field)) {
+        // References to fields and setters can't be relied upon for top level
+        // inference.
+        inferrer.recordNotImmediatelyEvident(fileOffset);
+      }
     }
     // To replicate analyzer behavior, we base type inference on the write
     // member.  TODO(paulberry): would it be better to use the read member when
     // doing compound assignment?
     var writeContext = writeMember?.setterType;
     var inferredType = _inferRhs(inferrer, writeContext);
     inferrer.listener.propertyAssignExit(desugared, inferredType);
     return inferredType;
   }
 }
@@ skipping 156 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) {
+          inferrer.recordDryRunDependency(target._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.
 class KernelStaticGet extends StaticGet implements KernelExpression {
@@ skipping 16 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) {
+        inferrer.recordDryRunDependency(target._fieldNode);
+      }
+    }
     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,
@@ skipping 291 matching lines @@
       : super(engine, uri, listener, topLevel, thisType);
 
   @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
+    // needed so that we don't induce bogus dependencies on fields mentioned in
+    // those subexpressions.
+    if (!typeNeeded && isTopLevel) return null;
+
     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 {
       // Encountered an expression type for which type inference is not yet
       // implemented, so just infer dynamic for now.
@@ skipping 313 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }