Add type inference for complex assignments whose LHS is an index expression.

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 214 matching lines @@
     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 complex assignment in kernel form.

[ahe, 2017/06/08 14:16:33]

What is a complex assignment?

[Paul Berry, 2017/06/08 16:17:04]

I'm still figuring out exactly where to draw the line.  It will probably be
something like: an assignment that desugars to a let expression.

For now I've added a TODO comment.

+class KernelComplexAssign extends Let implements KernelExpression {
+  KernelComplexAssign(VariableDeclaration variable, Expression body)
+      : super(variable, body);
+
+  @override
+  void _collectDependencies(KernelDependencyCollector collector) {
+    // Assignment expressions are not immediately evident expressions.
+    collector.recordNotImmediatelyEvident(fileOffset);
+  }
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    return inferrer.inferIndexAssign(this, typeContext, typeNeeded);
+  }
+}
+
 /// Concrete shadow object representing a conditional expression in kernel form.
 /// Shadow object for [ConditionalExpression].
 class KernelConditionalExpression extends ConditionalExpression
     implements KernelExpression {
+  /// Indicates whether this conditional expression is associated with a `??=`
+  /// in a null-aware compound assignment.
+  final bool _isNullAwareCombiner;
+
   KernelConditionalExpression(
-      Expression condition, Expression then, Expression otherwise)
-      : super(condition, then, otherwise, const DynamicType());
+      Expression condition, Expression then, Expression otherwise,
+      {bool isNullAwareCombiner: false})
+      : _isNullAwareCombiner = isNullAwareCombiner,
+        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;
     if (!inferrer.isTopLevel) {
       inferrer.inferExpression(
           condition, inferrer.coreTypes.boolClass.rawType, false);
     }
     DartType thenType = inferrer.inferExpression(then, typeContext, true);
     DartType otherwiseType =
         inferrer.inferExpression(otherwise, typeContext, true);
     DartType type = inferrer.typeSchemaEnvironment
         .getLeastUpperBound(thenType, otherwiseType);
     staticType = type;
     var inferredType = typeNeeded ? type : null;
     inferrer.listener.conditionalExpressionExit(this, inferredType);
     return inferredType;
   }
+
+  /// Helper method allowing [_isNullAwareCombiner] to be checked from outside
+  /// this library without adding a public member to the class.
+  static bool isNullAwareCombiner(KernelConditionalExpression e) =>
+      e._isNullAwareCombiner;
 }
 
 /// Shadow object for [ConstructorInvocation].
 class KernelConstructorInvocation extends ConstructorInvocation
     implements KernelExpression {
   final Member _initialTarget;
 
   KernelConstructorInvocation(
       Constructor target, this._initialTarget, Arguments arguments,
       {bool isConst: false})
@@ skipping 750 matching lines @@
   }
 }
 
 /// Shadow object for [MethodInvocation].
 class KernelMethodInvocation extends MethodInvocation
     implements KernelExpression {
   /// Indicates whether this method invocation is a call to a `call` method
   /// resulting from the invocation of a function expression.
   final bool _isImplicitCall;
 
+  /// Indicates whether this method invocation invokes the operator that
+  /// combines old and new values in a compound assignment.
+  final bool _isCombiner;
+
   KernelMethodInvocation(Expression receiver, Name name, Arguments arguments,
-      {bool isImplicitCall: false, Procedure interfaceTarget})
+      {bool isImplicitCall: false,
+      Procedure interfaceTarget,
+      bool isCombiner: false})
       : _isImplicitCall = isImplicitCall,
+        _isCombiner = isCombiner,
         super(receiver, name, arguments, interfaceTarget);
 
   @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) {
+    if (identical(name.name, '[]=')) {
+      return inferrer.inferIndexAssign(this, typeContext, 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
-          .getInterfaceMember(receiverType.classNode, name);
-      // Our non-strong golden files currently don't include interface
-      // targets, so we can't store the interface target without causing tests
-      // to fail.  TODO(paulberry): fix this.
-      if (inferrer.strongMode) {
-        if (interfaceMember != null) {
-          inferrer.instrumentation?.record(Uri.parse(inferrer.uri), fileOffset,
-              'target', new InstrumentationValueForMember(interfaceMember));
-        }
-        // interfaceTarget is currently required to be a procedure, so we skip
-        // if it's anything else.  TODO(paulberry): fix this - see
-        // https://codereview.chromium.org/2923653003/.
-        if (interfaceMember is Procedure) {
-          interfaceTarget = interfaceMember;
-        }
-      }
-      if (interfaceMember is Procedure) {
-        isOverloadedArithmeticOperator = inferrer.typeSchemaEnvironment
-            .isOverloadedArithmeticOperator(interfaceMember);
-      }
+    Member interfaceMember =
+        inferrer.findMethodInvocationMember(receiverType, this);
+    if (interfaceMember is Procedure) {
+      isOverloadedArithmeticOperator = inferrer.typeSchemaEnvironment
+          .isOverloadedArithmeticOperator(interfaceMember);
     }
     var calleeType = inferrer.getCalleeFunctionType(
         interfaceMember, receiverType, name, !_isImplicitCall);
     var inferredType = inferrer.inferInvocation(typeContext, typeNeeded,
         fileOffset, calleeType, calleeType.returnType, arguments,
         isOverloadedArithmeticOperator: isOverloadedArithmeticOperator,
         receiverType: receiverType);
     inferrer.listener.methodInvocationExit(this, inferredType);
     return inferredType;
   }
+
+  /// Helper method allowing [_isCombiner] to be checked from outside this
+  /// library without adding a public member to the class.
+  static bool isCombiner(KernelMethodInvocation e) => e._isCombiner;
 }
 
 /// Shadow object for [Not].
 class KernelNot extends Not implements KernelExpression {
   KernelNot(Expression operand) : super(operand);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // No inference dependencies.
   }
@@ skipping 52 matching lines @@
     // field dependencies.  So we don't need to do anything here.
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.propertyGetEnter(this, typeContext) || typeNeeded;
     // First infer the receiver so we can look up the getter that was invoked.
     var receiverType = inferrer.inferExpression(receiver, null, true);
-    Member interfaceMember;
-    if (receiverType is InterfaceType) {
-      interfaceMember = inferrer.classHierarchy
-          .getInterfaceMember(receiverType.classNode, name);
-      if (inferrer.isTopLevel &&
-          ((interfaceMember is Procedure &&
-                  interfaceMember.kind == ProcedureKind.Getter) ||
-              interfaceMember is Field)) {
-        // References to fields and getters can't be relied upon for top level
-        // inference.
-        inferrer.recordNotImmediatelyEvident(fileOffset);
-      }
-      // Our non-strong golden files currently don't include interface targets,
-      // so we can't store the interface target without causing tests to fail.
-      // TODO(paulberry): fix this.
-      if (inferrer.strongMode) {
-        inferrer.instrumentation?.record(Uri.parse(inferrer.uri), fileOffset,
-            'target', new InstrumentationValueForMember(interfaceMember));
-        interfaceTarget = interfaceMember;
-      }
+    Member interfaceMember =
+        inferrer.findInterfaceMember(receiverType, name, fileOffset);
+    if (inferrer.isTopLevel &&
+        ((interfaceMember is Procedure &&
+                interfaceMember.kind == ProcedureKind.Getter) ||
+            interfaceMember is Field)) {
+      // References to fields and getters can't be relied upon for top level
+      // inference.
+      inferrer.recordNotImmediatelyEvident(fileOffset);
     }
+    interfaceTarget = interfaceMember;
     var inferredType =
         inferrer.getCalleeType(interfaceMember, receiverType, name);
     // TODO(paulberry): Infer tear-off type arguments if appropriate.
     inferrer.listener.propertyGetExit(this, inferredType);
     return typeNeeded ? inferredType : null;
   }
 }
 
 /// Shadow object for [PropertyGet].
 class KernelPropertySet extends PropertySet implements KernelExpression {
@@ skipping 11 matching lines @@
     collector.recordNotImmediatelyEvident(fileOffset);
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.propertySetEnter(this, typeContext) || typeNeeded;
     // First infer the receiver so we can look up the setter that was invoked.
     var receiverType = inferrer.inferExpression(receiver, null, true);
-    Member interfaceMember;
-    if (receiverType is InterfaceType) {
-      interfaceMember = inferrer.classHierarchy
-          .getInterfaceMember(receiverType.classNode, name, setter: true);
-      // Our non-strong golden files currently don't include interface targets,
-      // so we can't store the interface target without causing tests to fail.
-      // TODO(paulberry): fix this.
-      if (inferrer.strongMode) {
-        inferrer.instrumentation?.record(Uri.parse(inferrer.uri), fileOffset,
-            'target', new InstrumentationValueForMember(interfaceMember));
-        interfaceTarget = interfaceMember;
-      }
-    }
+    Member interfaceMember = inferrer
+        .findInterfaceMember(receiverType, name, fileOffset, setter: true);
+    interfaceTarget = interfaceMember;
     var setterType = inferrer.getSetterType(interfaceMember, receiverType);
     var inferredType = inferrer.inferExpression(value, setterType, typeNeeded);
     inferrer.listener.propertySetExit(this, inferredType);
     return typeNeeded ? inferredType : null;
   }
 }
 
 /// Concrete shadow object representing a redirecting initializer in kernel
 /// form.
 class KernelRedirectingInitializer extends RedirectingInitializer
@@ skipping 549 matching lines @@
   final bool _implicitlyTyped;
 
   final int _functionNestingLevel;
 
   bool _mutatedInClosure = false;
 
   bool _mutatedAnywhere = false;
 
   final bool _isLocalFunction;
 
+  /// Indicates whether this variable declaration exists for the sole purpose of
+  /// discarding a return value in a complex desugared expression.
+  final bool _isDiscarding;

[ahe, 2017/06/08 14:16:33]

It would be easier for for me to understand the meaning of this if it was called
"voidContext" or something like that.

[Paul Berry, 2017/06/08 16:17:04]

I'm open to changing this, but I think "voidContext" would be confusing, because
the only time it's true is when we're *not* in a void context.  For example,
when desugaring the assignment `var x = t1[t2] = t3;`, we generate:

var x =
 let t1 = a in
  let t2 = b in
   let t3 = c in
    let t4 = a.[]=(b, c)
     t3

The variable declaration for t4 is marked with _isDiscarding = true to indicate
that the value of t4 will not be used.  But the overall expression `a[b] = c` is
in a non-void context.

+
   KernelVariableDeclaration(String name, this._functionNestingLevel,
       {Expression initializer,
       DartType type,
       bool isFinal: false,
       bool isConst: false,
       bool isLocalFunction: false})
       : _implicitlyTyped = type == null,
         _isLocalFunction = isLocalFunction,
+        _isDiscarding = false,
         super(name,
             initializer: initializer,
             type: type ?? const DynamicType(),
             isFinal: isFinal,
             isConst: isConst);
 
   KernelVariableDeclaration.forValue(
-      Expression initializer, this._functionNestingLevel)
+      Expression initializer, this._functionNestingLevel,
+      {bool isDiscarding: false})
       : _implicitlyTyped = true,
         _isLocalFunction = false,
+        _isDiscarding = isDiscarding,
         super.forValue(initializer);
 
   @override
   void _inferStatement(KernelTypeInferrer inferrer) {
     inferrer.listener.variableDeclarationEnter(this);
     var declaredType = _implicitlyTyped ? null : type;
     if (initializer != null) {
       var inferredType = inferrer.inferDeclarationType(inferrer.inferExpression(
           initializer, declaredType, _implicitlyTyped));
       if (inferrer.strongMode && _implicitlyTyped) {
         inferrer.instrumentation?.record(Uri.parse(inferrer.uri), fileOffset,
             'type', new InstrumentationValueForType(inferredType));
         type = inferredType;
       }
     }
     inferrer.listener.variableDeclarationExit(this);
   }
 
+  /// Helper method allowing [_isDiscarding] to be checked from outside this
+  /// library without adding a public member to the class.
+  static bool isDiscarding(VariableDeclaration v) =>
+      v is KernelVariableDeclaration && v._isDiscarding;
+
   /// Determine whether the given [KernelVariableDeclaration] had an implicit
   /// type.
   ///
   /// This is static to avoid introducing a method that would be visible to
   /// the kernel.
   static bool isImplicitlyTyped(KernelVariableDeclaration variable) =>
       variable._implicitlyTyped;
 }
 
 /// Concrete shadow object representing a read from a variable in kernel form.
@@ skipping 95 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }