Fasta type inference prototype #2

pkg/front_end/lib/src/fasta/kernel/shadow_ast.dart

Index: pkg/front_end/lib/src/fasta/kernel/shadow_ast.dart
diff --git a/pkg/front_end/lib/src/fasta/kernel/shadow_ast.dart b/pkg/front_end/lib/src/fasta/kernel/shadow_ast.dart
new file mode 100644
index 0000000000000000000000000000000000000000..1d7778573b7cb04fc5b7eb2ee8a1debf7e61e3f1
--- /dev/null
+++ b/pkg/front_end/lib/src/fasta/kernel/shadow_ast.dart
@@ -0,0 +1,142 @@
+import 'package:kernel/ast.dart' as kernel;
+import '../builder/shadow_ast.dart' as builder;
+import 'package:kernel/ast.dart' show DartType;
+
+class Block extends kernel.Block with builder.Block implements Statement {
+  Block(List<Statement> statements) : super(statements);
+
+  @override
+  List<Statement> get shadowStatements => statements;
+}
+
+abstract class Expression implements kernel.Expression, builder.Expression {}
+
+class FunctionExpression extends kernel.FunctionExpression
+    with builder.FunctionExpression
+    implements Expression {
+  FunctionExpression(kernel.FunctionNode function) : super(function);
+
+  @override
+  Statement get shadowBody => function.body;
+
+  @override
+  set shadowInferredReturnType(DartType type) {
+    function.returnType = type;
+  }
+
+  @override
+  bool get shadowIsAsync {
+    // TODO(paulberry): is there a helper function in kernel that does this?
+    var asyncMarker = function.asyncMarker;
+    return asyncMarker == kernel.AsyncMarker.Async ||
+        asyncMarker == kernel.AsyncMarker.AsyncStar;
+  }
+
+  @override
+  bool get shadowIsExpressionFunction =>
+      function.body is kernel.ReturnStatement;
+
+  @override
+  bool get shadowIsGenerator {
+    // TODO(paulberry): is there a helper function in kernel that does this?
+    var asyncMarker = function.asyncMarker;
+    return asyncMarker == kernel.AsyncMarker.SyncStar ||
+        asyncMarker == kernel.AsyncMarker.AsyncStar;
+  }
+
+  @override
+  DartType shadowMakeFunctionType() {
+    return function.functionType;
+  }
+}
+
+class IntLiteral extends kernel.IntLiteral
+    with builder.IntLiteral
+    implements Expression {
+  IntLiteral(int value) : super(value);
+}
+
+class ListLiteral extends kernel.ListLiteral
+    with builder.ListLiteral
+    implements Expression {
+  DartType _declaredTypeArgument;
+
+  ListLiteral(List<Expression> expressions,
+      {DartType typeArgument, bool isConst: false})
+      : _declaredTypeArgument = typeArgument,
+        super.forMixin(
+            expressions, typeArgument ?? const kernel.DynamicType(), isConst);
+  @override
+  kernel.DartType get declaredTypeArgumentForInference => _declaredTypeArgument;
+
+  @override
+  Iterable<Expression> get expressionsForInference {
+    List<Expression> shadowExpressions = expressions;
+    return shadowExpressions;
+  }
+
+  @override
+  set inferredTypeArgument(kernel.DartType type) {
+    typeArgument = type;
+  }
+}
+
+class NullLiteral extends kernel.NullLiteral
+    with builder.NullLiteral
+    implements Expression {}
+
+class ReturnStatement extends kernel.ReturnStatement
+    with builder.ReturnStatement
+    implements Statement {
+  ReturnStatement([Expression expression]) : super.forMixin(expression);
+
+  @override
+  Expression get expressionForInference => expression;
+}
+
+abstract class Statement extends kernel.Statement implements builder.Statement {
+}
+
+class VariableDeclaration extends kernel.VariableDeclaration
+    with builder.VariableDeclaration
+    implements Statement {
+  DartType _declaredType;
+
+  VariableDeclaration(String name,
+      {Expression initializer,
+      DartType type,
+      bool isFinal: false,
+      bool isConst: false})
+      : _declaredType = type,
+        super.forMixin(name, initializer, type ?? const kernel.DynamicType(),
+            null, isFinal, isConst);
+
+  @override
+  DartType get shadowDeclaredType => _declaredType;
+
+  @override
+  kernel.DartType get shadowInferredType => type;
+
+  @override
+  set shadowInferredType(kernel.DartType type) {
+    super.type = type;
+  }
+
+  @override
+  Expression get shadowInitializer => initializer;
+
+  @override
+  set type(kernel.DartType type) {
+    super.type = _declaredType = type;
+  }
+}
+
+class VariableGet extends kernel.VariableGet
+    with builder.VariableGet
+    implements Expression {
+  VariableGet(kernel.VariableDeclaration variable, [DartType promotedType])
+      : super.forMixin(variable, promotedType);
+
+  @override
+  VariableDeclaration get shadowDeclaration => variable;
+}