Perform type inference on redirecting initializers (`C() : this(...);`).

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 566 matching lines @@
   void _inferStatement(KernelTypeInferrer inferrer) {
     inferrer.listener.ifStatementEnter(this);
     inferrer.inferExpression(
         condition, inferrer.coreTypes.boolClass.rawType, false);
     inferrer.inferStatement(then);
     if (otherwise != null) inferrer.inferStatement(otherwise);
     inferrer.listener.ifStatementExit(this);
   }
 }
 
+/// Common base class for shadow objects representing initializers in kernel
+/// form.
+abstract class KernelInitializer implements Initializer {
+  /// Performs type inference for whatever concrete type of [KernelInitializer]
+  /// this is.
+  void _inferInitializer(KernelTypeInferrer inferrer);
+}
+
 /// Concrete shadow object representing an integer literal in kernel form.
 class KernelIntLiteral extends IntLiteral implements KernelExpression {
   KernelIntLiteral(int value) : super(value);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.intLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.intClass.rawType : null;
@@ skipping 230 matching lines @@
       : super.byReference(receiver, name, value, interfaceTargetReference);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
+/// Concrete shadow object representing a redirecting initializer in kernel
+/// form.
+class KernelRedirectingInitializer extends RedirectingInitializer
+    implements KernelInitializer {
+  KernelRedirectingInitializer(Constructor target, Arguments arguments)
+      : super(target, arguments);
+
+  @override
+  _inferInitializer(KernelTypeInferrer inferrer) {
+    inferrer.listener.redirectingInitializerEnter(this);
+    inferrer.inferInvocation(null, false, fileOffset,
+        target.function.functionType, target.enclosingClass.thisType, arguments,
+        skipTypeArgumentInference: true);
+    inferrer.listener.redirectingInitializerExit(this);
+  }
+}
+
 /// Shadow object for [Rethrow].
 class KernelRethrow extends Rethrow implements KernelExpression {
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
@@ skipping 324 matching lines @@
     }
   }
 
   @override
   DartType inferFieldTopLevel(
       KernelField field, DartType type, bool typeNeeded) {
     return inferExpression(field.initializer, type, typeNeeded);
   }
 
   @override
+  void inferInitializer(Initializer initializer) {
+    if (initializer is KernelInitializer) {
+      // Use polymorphic dispatch on [KernelInitializer] to perform whatever
+      // kind of type inference is correct for this kind of initializer.
+      // 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 initializer._inferInitializer(this);
+    } else {
+      // Encountered an initializer type for which type inference is not yet
+      // implemented, so just skip it for now.
+      // TODO(paulberry): once the BodyBuilder uses shadow classes for
+      // everything, this case should no longer be needed.
+    }
+  }
+
+  @override
   void inferStatement(Statement statement) {
     if (statement is KernelStatement) {
       // Use polymorphic dispatch on [KernelStatement] 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 statement._inferStatement(this);
     } else {
       // Encountered a statement type for which type inference is not yet
@@ skipping 218 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);
   }
 }