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

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.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/fasta/errors.dart';
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
-import 'package:front_end/src/fasta/names.dart' show callName;
+import 'package:front_end/src/fasta/names.dart'
+    show callName, indexGetName, indexSetName;
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_elimination.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_environment.dart';
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
         BottomType,
         Class,
         DartType,
         DynamicType,
         Expression,
         Field,
         FunctionType,
         Initializer,
         InterfaceType,
+        Let,
         Member,
+        MethodInvocation,
         Name,
         Procedure,
         ProcedureKind,
         Statement,
         TypeParameterType,
+        VariableDeclaration,
+        VariableGet,
         VoidType;
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/type_algebra.dart';
 
 /// Keeps track of information about the innermost function or closure being
 /// inferred.
 class ClosureContext {
   final bool isAsync;
 
@@ skipping 186 matching lines @@
         strongMode = engine.strongMode,
         classHierarchy = engine.classHierarchy,
         instrumentation = topLevel ? null : engine.instrumentation,
         typeSchemaEnvironment = engine.typeSchemaEnvironment,
         isTopLevel = topLevel;
 
   /// Gets the type promoter that should be used to promote types during
   /// inference.
   TypePromoter get typePromoter;
 
+  /// Finds a member of [receiverType] called [name], and if it is found,
+  /// reports it through instrumentation using [fileOffset].
+  Member findInterfaceMember(DartType receiverType, Name name, int fileOffset,
+      {bool setter: false, bool silent: false}) {
+    // 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.

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

As far as I understand, interface targets are for strong mode only. Obviously,
that can be changed if it's a problem.

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

Acknowledged.

+    if (!strongMode) return null;
+
+    if (receiverType is InterfaceType) {
+      var interfaceMember = classHierarchy
+          .getInterfaceMember(receiverType.classNode, name, setter: setter);
+      if (!silent && interfaceMember != null) {
+        instrumentation?.record(Uri.parse(uri), fileOffset, 'target',
+            new InstrumentationValueForMember(interfaceMember));
+      }
+      return interfaceMember;
+    }
+    return null;
+  }
+
+  /// Finds a member of [receiverType] called [name], and if it is found,
+  /// reports it through instrumentation and records it in [methodInvocation].
+  Member findMethodInvocationMember(
+      DartType receiverType, MethodInvocation methodInvocation,
+      {bool silent: false}) {
+    var interfaceMember = findInterfaceMember(
+        receiverType, methodInvocation.name, methodInvocation.fileOffset,
+        silent: silent);
+    // 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) {
+      methodInvocation.interfaceTarget = interfaceMember;
+    }
+    return interfaceMember;
+  }
+
   FunctionType getCalleeFunctionType(Member interfaceMember,
       DartType receiverType, Name methodName, bool followCall) {
     var type = getCalleeType(interfaceMember, receiverType, methodName);
     if (type is FunctionType) {
       return type;
     } else if (followCall && type is InterfaceType) {
       var member = classHierarchy.getInterfaceMember(type.classNode, callName);
       var callType = member?.getterType;
       if (callType is FunctionType) {
         return callType;
@@ skipping 155 matching lines @@
 
   @override
   void inferFunctionBody(
       DartType returnType, AsyncMarker asyncMarker, Statement body) {
     assert(closureContext == null);
     closureContext = new ClosureContext(this, asyncMarker, returnType);
     inferStatement(body);
     closureContext = null;
   }
 
+  /// Performs type inference for a (possibly compound) assignment whose LHS is
+  /// an index expression.
+  DartType inferIndexAssign(
+      Expression expression, DartType typeContext, bool typeNeeded) {
+    typeNeeded =
+        listener.indexAssignEnter(expression, typeContext) || typeNeeded;
+
+    // Decompose an expression like `a[b] += c` into subexpressions and record
+    // the variables holding those subexpressions (if any):
+    //   receiver: a
+    //   index: b
+    //   read: a[b]
+    //   rhs: c
+    //   value: a[b] + c
+    //   write: a[b] = a[b] + c
+    Expression receiver;
+    VariableDeclaration receiverVariable;
+    Expression index;
+    VariableDeclaration indexVariable;
+    Expression read;
+    VariableDeclaration readVariable;
+    Expression rhs;
+    VariableDeclaration rhsVariable;
+    Expression value;
+    VariableDeclaration valueVariable;
+    MethodInvocation write;
+    KernelConditionalExpression nullAwareCombiner;
+    MethodInvocation combiner;
+    List<VariableDeclaration> syntheticVariables = [];
+    VariableGet finalValue;
+    bool isPostIncDec = false;
+
+    // Dig in to the tree to find the expression with the main effect.
+    Expression e = expression;
+    while (true) {
+      if (e is Let) {
+        Let let = e;
+        var variable = let.variable;
+        syntheticVariables.add(variable);
+        if (KernelVariableDeclaration.isDiscarding(variable)) {
+          finalValue = let.body;
+          e = variable.initializer;

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

I don't understand this. Isn't [e] supposed to be the main effect? Also, how do
you know that let.body is really a VariableGet?

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

Again considering the example of `var x = a[b] = c;`, which desugars to:

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

When we reach the "let" expression for t4, the main effect of the expression is
found in the initializer for t4, namely `t1.[]=(t2, t3)`.

As for how we know the body is a VariableGet, we know it because the only time
desugaring produces a "let" expression whose variable has the `isDiscarding`
flag set, it is doing so in order to allow the final value of the expression to
be some previously computed value (t3 in this instance).  So the body of the
"let" is always a VariableGet which reads the previously computed value.

I've added comments to this effect, and I've also added an assertion
`assert(let.body is VariableGet);` to make the assumption about the body
clearer.

+        } else {
+          e = let.body;
+        }
+      } else if (e is KernelConditionalExpression &&
+          KernelConditionalExpression.isNullAwareCombiner(e)) {
+        KernelConditionalExpression conditional = e;
+        nullAwareCombiner = conditional;
+        e = conditional.then;
+      } else {
+        break;
+      }
+    }
+
+    Expression deref(Expression e, void callback(VariableDeclaration v)) {
+      if (e is VariableGet) {
+        var variable = e.variable;
+        if (syntheticVariables.contains(variable)) {
+          callback(variable);
+          return variable.initializer;
+        }
+      }
+      return e;
+    }
+
+    if (e is KernelMethodInvocation && identical(e.name.name, '[]=')) {
+      write = e;
+      receiver = deref(e.receiver, (v) => receiverVariable = v);
+      index = deref(e.arguments.positional[0], (v) => indexVariable = v);
+      value = deref(e.arguments.positional[1], (v) => valueVariable = v);
+      if (value is KernelMethodInvocation &&
+          KernelMethodInvocation.isCombiner(value)) {
+        combiner = value;
+        read = deref(value.receiver, (v) => readVariable = v);
+        rhs = deref(value.arguments.positional[0], (v) => rhsVariable = v);
+        isPostIncDec =
+            finalValue is VariableGet && finalValue.variable == readVariable;
+      } else {
+        rhs = value;
+        if (nullAwareCombiner != null) {
+          MethodInvocation equalsNullCheck = nullAwareCombiner.condition;
+          read = deref(equalsNullCheck.receiver, (v) => readVariable = v);
+        }
+      }
+    } else {
+      internalError('Unexpected expression type: $e');
+    }
+
+    var receiverType = inferExpression(receiver, null, true);
+    receiverVariable?.type = receiverType;
+    if (read != null) {
+      var readMember =
+          findMethodInvocationMember(receiverType, read, silent: true);
+      if (readVariable != null) {
+        var calleeType = getCalleeType(readMember, receiverType, indexGetName);
+        if (calleeType is FunctionType) {
+          readVariable.type = calleeType.returnType;
+        }
+      }
+    }
+    var writeMember = findMethodInvocationMember(receiverType, write);
+    // 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 calleeType = getCalleeType(writeMember, receiverType, indexSetName);
+    DartType indexContext;
+    DartType rhsContext;
+    DartType inferredType;
+    if (calleeType is FunctionType &&
+        calleeType.positionalParameters.length >= 2) {
+      // TODO(paulberry): we ought to get a context for the index expression
+      // from the index formal parameter, but analyzer doesn't so for now we
+      // replicate its behavior.
+      indexContext = null;
+      rhsContext = calleeType.positionalParameters[1];
+      if (combiner != null) {
+        var combinerMember =
+            findMethodInvocationMember(rhsContext, combiner, silent: true);
+        if (isPostIncDec) {
+          inferredType = rhsContext;
+        } else {
+          inferredType = getCalleeFunctionType(
+                  combinerMember, rhsContext, combiner.name, false)
+              .returnType;
+        }
+        // Analyzer uses a null context for the RHS here.
+        // TODO(paulberry): improve on this.
+        rhsContext = null;
+      } else {
+        inferredType = rhsContext;
+      }
+    } else {
+      inferredType = const DynamicType();
+    }
+    var indexType = inferExpression(index, indexContext, true);
+    indexVariable?.type = indexType;
+    var rhsType = inferExpression(rhs, rhsContext, true);
+    rhsVariable?.type = rhsType;
+    valueVariable?.type = rhsContext ?? const DynamicType();
+    if (nullAwareCombiner != null) {
+      MethodInvocation equalsInvocation = nullAwareCombiner.condition;
+      findMethodInvocationMember(rhsContext, equalsInvocation);
+      nullAwareCombiner.staticType = inferredType;
+    }
+    listener.indexAssignExit(expression, inferredType);
+    return inferredType;
+  }
+
   /// Performs the type inference steps that are shared by all kinds of
   /// invocations (constructors, instance methods, and static methods).
   DartType inferInvocation(DartType typeContext, bool typeNeeded, int offset,
       FunctionType calleeType, DartType returnType, Arguments arguments,
       {bool isOverloadedArithmeticOperator: false,
       DartType receiverType,
       bool skipTypeArgumentInference: false}) {
     var calleeTypeParameters = calleeType.typeParameters;
     List<DartType> explicitTypeArguments = getExplicitTypeArguments(arguments);
     bool inferenceNeeded = !skipTypeArgumentInference &&
@@ skipping 134 matching lines @@
   void _forEachArgument(
       Arguments arguments, void callback(String name, Expression expression)) {
     for (var expression in arguments.positional) {
       callback(null, expression);
     }
     for (var namedExpression in arguments.named) {
       callback(namedExpression.name, namedExpression.value);
     }
   }
 }