Add type inference logic for cascade expressions.

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`.
 ///
 /// Note that these classes represent the Dart language prior to desugaring.
 /// When a single Dart construct desugars to a tree containing multiple kernel
 /// AST nodes, the shadow class extends the kernel object at the top of the
 /// desugared tree.
 ///
 /// This means that in some cases multiple shadow classes may extend the same
 /// kernel class, because multiple constructs in Dart may desugar to a tree
 /// with the same kind of root node.
 import 'package:front_end/src/base/instrumentation.dart';
 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_inferrer.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:kernel/ast.dart';
+import 'package:kernel/frontend/accessors.dart';
 import 'package:kernel/type_algebra.dart';
 
 List<DartType> getExplicitTypeArguments(Arguments arguments) {
   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;
@@ skipping 68 matching lines @@
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.boolLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.boolClass.rawType : null;
     inferrer.listener.boolLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
+/// Concrete shadow object representing a cascade expression.
+///
+/// A cascade expression of the form `a..b()..c()` is represented as the kernel
+/// expression:
+///
+///     let v = a in
+///         let _ = v.b() in
+///             let _ = v.c() in
+///                 v
+///
+/// In the documentation that follows, `v` is referred to as the "cascade
+/// variable"--this is the variable that remembers the value of the expression
+/// preceding the first `..` while the cascades are being evaluated.
+///
+/// After constructing a [KernelCascadeExpression], the caller should
+/// call [finalize] with an expression representing the expression after the
+/// `..`.  If a further `..` follows that expression, the caller should call
+/// [extend] followed by [finalize] for each subsequent cascade.
+class KernelCascadeExpression extends Let implements KernelExpression {
+  /// Pointer to the last "let" expression in the cascade.
+  Let nextCascade;
+
+  /// Creates a [KernelCascadeExpression] using [variable] as the cascade
+  /// variable.  Caller is responsible for ensuring that [variable]'s
+  /// initializer is the expression preceding the first `..` of the cascade
+  /// expression.
+  KernelCascadeExpression(KernelVariableDeclaration variable)
+      : super(
+            variable,
+            makeLet(new VariableDeclaration.forValue(new InvalidExpression()),
+                new VariableGet(variable))) {
+    nextCascade = body;
+  }
+
+  /// Adds a new unfinalized section to the end of the cascade.  Should be
+  /// called after the previous cascade section has been finalized.
+  void extend() {
+    assert(nextCascade.variable.initializer is! InvalidExpression);
+    Let newCascade = makeLet(
+        new VariableDeclaration.forValue(new InvalidExpression()),
+        nextCascade.body);
+    nextCascade.body = newCascade;
+    newCascade.parent = nextCascade;
+    nextCascade = newCascade;
+  }
+
+  /// Finalizes the last cascade section with the given [expression].
+  void finalize(Expression expression) {
+    assert(nextCascade.variable.initializer is InvalidExpression);
+    nextCascade.variable.initializer = expression;
+    expression.parent = nextCascade.variable;
+  }
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    typeNeeded = inferrer.listener.cascadeExpressionEnter(this, typeContext) ||
+        typeNeeded;
+    var lhsType = inferrer.inferExpression(
+        variable.initializer, typeContext, typeNeeded || inferrer.strongMode);
+    if (inferrer.strongMode) {
+      variable.type = lhsType;
+    }
+    Let section = body;
+    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 conditional expression in kernel form.
 /// Shadow object for [ConditionalExpression].
 class KernelConditionalExpression extends ConditionalExpression
     implements KernelExpression {
   KernelConditionalExpression(
       Expression condition, Expression then, Expression otherwise)
       : super(condition, then, otherwise, const DynamicType());
 
   @override
   DartType _inferExpression(
@@ skipping 1097 matching lines @@
       bool isConst: false,
       bool isLocalFunction: false})
       : _implicitlyTyped = type == null,
         _isLocalFunction = isLocalFunction,
         super(name,
             initializer: initializer,
             type: type ?? const DynamicType(),
             isFinal: isFinal,
             isConst: isConst);
 
+  KernelVariableDeclaration.forValue(
+      Expression initializer, this._functionNestingLevel)
+      : _implicitlyTyped = true,
+        _isLocalFunction = false,
+        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));
@@ skipping 78 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);
   }
 }