Fasta type inference prototype #2

pkg/front_end/lib/src/fasta/builder/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.
 
+import 'package:front_end/src/fasta/type_inference/local_type_inferrer.dart';
+
 /// This file declares mixins which can be used to create a shadow hierarchy
 /// of either the kernel or the analyzer AST representations.
 ///
 /// These classes are intended to be used by [BodyBuilder] as a form of
 /// indirection so that it can manipulate either kernel or analyzer ASTs.
 ///
 /// All methods, getters, and setters defined in this file start with the prefix
 /// "shadow" in order to avoid naming conflicts with code in kernel or analyzer.
 ///
 /// Note that the analyzer AST representation closely parallels Dart syntax,
 /// whereas the kernel AST representation is desugared.  The classes in the
 /// shadow hierarchy represent the full language (prior to desugaring).
-import 'package:kernel/ast.dart' show DartType;
+import 'package:kernel/ast.dart' show DartType, DynamicType, InterfaceType;
+import 'package:kernel/core_types.dart';
 
 /// Shadow mixin representing a statement block.
 abstract class ShadowBlock implements ShadowStatement {
   /// Iterates through the statements contained in the block.
   Iterable<ShadowStatement> get shadowStatements;
+
+  @override
+  void shadowInfer(LocalTypeInferrer inferrer, FunctionContext context) {
+    for (var statement in shadowStatements) {
+      statement.shadowInfer(inferrer, context);
+    }
+  }
 }
 
 /// Common interface for shadow mixins representing expressions.
-///
-/// TODO(paulberry): add an abstract `shadowInfer` method here to do type
-/// inference.
-abstract class ShadowExpression {}
+abstract class ShadowExpression {
+  DartType shadowInfer(
+      LocalTypeInferrer inferrer, DartType context, bool typeNeeded);
+}
 
 /// Shadow mixin representing a function expression.
 abstract class ShadowFunctionExpression implements ShadowExpression {
   /// Gets the body of the function expression.
   ShadowStatement get shadowBody;
 
   /// Creates a [DartType] representing the type of the function expression.
   ///
   /// If type inference has already been performed, returns the inferred type.
   /// Otherwise returns the declared type.
   DartType get shadowFunctionType;
 
   /// Indicates whether the function is asynchronous (`async` or `async*`)
   bool get shadowIsAsync;
 
   /// Indicates whether the function was declared using `=>` syntax.
   bool get shadowIsExpressionFunction;
 
   /// Indicates whether the function is a generator (`sync*` or `async*`)
   bool get shadowIsGenerator;
 
   /// Sets the return type of the function expression.
   ///
   /// Intended for use by type inference.
   void set shadowReturnType(DartType type);
+
+  @override
+  DartType shadowInfer(
+      LocalTypeInferrer inferrer, DartType context, bool typeNeeded) {
+    // TODO(paulberry): infer argument types and type parameters.
+    // TODO(paulberry): full support for generators.
+    var body = shadowBody;
+    // TODO(paulberry): Dart 1.0 rules say we only need to set the function
+    // node's return type if it uses expression syntax.  Does that make sense
+    // for Dart 2.0?
+    bool needToSetReturnType = shadowIsExpressionFunction;
+    bool returnTypeNeeded = typeNeeded || needToSetReturnType;
+    bool isAsync = shadowIsAsync;
+    var functionContext = new FunctionContext(
+        inferrer, returnTypeNeeded, isAsync, shadowIsGenerator);
+    body.shadowInfer(inferrer, functionContext);
+    DartType inferredReturnType;
+    if (needToSetReturnType || typeNeeded) {
+      inferredReturnType = functionContext.inferredReturnType;
+      if (isAsync) {
+        inferredReturnType = new InterfaceType(
+            inferrer.coreTypes.futureClass, <DartType>[inferredReturnType]);
+      }
+    }
+    if (needToSetReturnType) {
+      this.shadowReturnType = inferredReturnType;
+    }
+    if (typeNeeded) {
+      return shadowFunctionType;
+    } else {
+      return null;
+    }
+  }
 }
 
 /// Shadow mixin representing an integer literal.
-abstract class ShadowIntLiteral implements ShadowExpression {}
+abstract class ShadowIntLiteral implements ShadowExpression {
+  @override
+  DartType shadowInfer(
+      LocalTypeInferrer inferrer, DartType context, bool typeNeeded) {
+    return typeNeeded ? inferrer.coreTypes.intClass.rawType : null;
+  }
+}
 
 /// Shadow mixin representing a list literal.
 abstract class ShadowListLiteral implements ShadowExpression {
   /// Iterates through the expressions contained in the list literal.
   Iterable<ShadowExpression> get shadowExpressions;
 
   /// Gets the type argument of the list literal.  If type inference has not
   /// been performed and no explicit type argument was specified, returns
   /// `null`.
   DartType get shadowTypeArgument;
 
   /// Sets the type argument of the list literal.
   ///
   /// Intended for use by type inference.
   void set shadowTypeArgument(DartType type);
+
+  @override
+  DartType shadowInfer(
+      LocalTypeInferrer inferrer, DartType context, bool typeNeeded) {
+    DartType declaredTypeArgument = shadowTypeArgument;
+    DartType typeArgumentContext = declaredTypeArgument;
+    if (typeArgumentContext == null) {
+      if (context is InterfaceType &&
+          context.classNode == inferrer.coreTypes.listClass &&
+          context.typeArguments.length == 1) {
+        typeArgumentContext = context.typeArguments[0];
+      } else if (context != null) {
+        // TODO(paulberry): report an error?
+        throw new UnimplementedError('$context');
+      }
+    }
+    DartType inferredTypeArgument = typeArgumentContext;
+    bool typeArgumentNeeded = inferredTypeArgument == null;
+    for (ShadowExpression e in shadowExpressions) {
+      DartType t =
+          e.shadowInfer(inferrer, typeArgumentContext, typeArgumentNeeded);
+      if (typeArgumentNeeded) {
+        inferredTypeArgument = inferrer.union(inferredTypeArgument, t);
+      }
+    }
+    if (inferredTypeArgument == null) {
+      // Empty list.
+      throw new UnimplementedError();
+    }
+    if (declaredTypeArgument == null) {
+      this.shadowTypeArgument = inferredTypeArgument;
+    }
+    if (typeNeeded) {
+      return new InterfaceType(
+          inferrer.coreTypes.listClass, <DartType>[inferredTypeArgument]);
+    } else {
+      return null;
+    }
+  }
 }
 
 /// Shadow mixin representing a null literal.
-abstract class ShadowNullLiteral implements ShadowExpression {}
+abstract class ShadowNullLiteral implements ShadowExpression {
+  @override
+  DartType shadowInfer(
+      LocalTypeInferrer inferrer, DartType context, bool typeNeeded) {
+    return typeNeeded ? inferrer.coreTypes.nullClass.rawType : null;
+  }
+}
 
 /// Shadow mixin representing a return statement.
 abstract class ShadowReturnStatement implements ShadowStatement {
   /// Gets the expression being returned, or `null` if this is a bare "return"
   /// statement.
   ShadowExpression get shadowExpression;
+
+  @override
+  void shadowInfer(LocalTypeInferrer inferrer, FunctionContext context) {
+    DartType expressionContext = null; // TODO(paulberry): probably wrong.
+    bool expressionTypeNeeded =
+        context.returnTypeNeeded && !context.isGenerator;
+    DartType expressionType = shadowExpression.shadowInfer(
+        inferrer, expressionContext, expressionTypeNeeded);
+    if (expressionTypeNeeded) {
+      if (context.isAsync) {
+        expressionType = _unwrapFuture(inferrer.coreTypes, expressionType);
+      }
+      context.recordReturnType(expressionType);
+    }
+  }
+
+  DartType _unwrapFuture(CoreTypes coreTypes, DartType type) {
+    // TODO(paulberry): replace with a full implementation of what's in the spec
+    // (e.g. handle types derived from Future).  Also probably move to Kernel.
+    if (type is InterfaceType && type.classNode == coreTypes.futureClass) {
+      return type.typeArguments[0];
+    } else {
+      return type;
+    }
+  }
 }
 
 /// Common interface for shadow mixins representing statements.
-///
-/// TODO(paulberry): add an abstract `shadowInfer` method here to do type
-/// inference.
-abstract class ShadowStatement {}
+abstract class ShadowStatement {
+  void shadowInfer(LocalTypeInferrer inferrer, FunctionContext context);
+}
 
 /// Shadow mixin representing a declaration of a single variable.
 abstract class ShadowVariableDeclaration implements ShadowStatement {
   /// Gets the initializer expression for the variable, or `null` if the
   /// variable has no initializer.
   ShadowExpression get shadowInitializer;
 
   /// Gets the type of the variable.  If type inference has not been performed
   /// and no explicit type was specified, returns `null`.
   DartType get shadowType;
 
   /// Sets the type of the variable.
   ///
   /// Intended for use by type inference.
   void set shadowType(DartType type);
+
+  @override
+  void shadowInfer(LocalTypeInferrer inferrer, FunctionContext context) {
+    var initializer = shadowInitializer;
+    if (initializer != null) {
+      var type = shadowType;
+      var inferredType = initializer.shadowInfer(inferrer, type, type == null);
+      if (type == null) {
+        this.shadowType = inferredType;
+      }
+    }
+  }
 }
 
 /// Shadow mixin representing a "read" reference to a variable.
 abstract class ShadowVariableGet implements ShadowExpression {
   /// Gets the variable declaration which is being referenced.
   ShadowVariableDeclaration get shadowDeclaration;
+
+  @override
+  DartType shadowInfer(
+      LocalTypeInferrer inferrer, DartType context, bool typeNeeded) {
+    // TODO(paulberry): make the "?? const DynamicType()" unnecessary.
+    return typeNeeded
+        ? (shadowDeclaration.shadowType ?? const DynamicType())
+        : null;
+  }
 }