Fasta type inference prototype #2

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

 // Copyright (c) 2016, 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.
 
 library fasta.body_builder;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
+import 'package:front_end/src/fasta/builder/ast_factory.dart';
+import 'package:front_end/src/fasta/kernel/ast_factory.dart' as kernel;
+import 'package:front_end/src/fasta/type_inference/local_type_inferrer.dart';
+import 'shadow_ast.dart' as shadow;
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
 import 'package:kernel/transformations/flags.dart' show TransformerFlag;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
@@ skipping 98 matching lines @@
   CloneVisitor cloner;
 
   bool constantExpressionRequired = false;
 
   DartType currentLocalVariableType;
 
   // Using non-null value to initialize this field based on performance advice
   // from VM engineers. TODO(ahe): Does this still apply?
   int currentLocalVariableModifiers = -1;
 
+  final AstFactory _ast = new kernel.AstFactory();
+
+  final LocalTypeInferrer _typeInferrer;
+
+  OldFunctionContext _functionContext;
+
   BodyBuilder(
       KernelLibraryBuilder library,
       this.member,
       Scope scope,
       this.formalParameterScope,
       this.hierarchy,
-      this.coreTypes,
+      CoreTypes coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri)
-      : enclosingScope = scope,
+      : coreTypes = coreTypes,
+        enclosingScope = scope,
         library = library,
         isDartLibrary = library.uri.scheme == "dart",
+        // TODO(paulberry): put this behind a flag.
+        _typeInferrer = new LocalTypeInferrer(coreTypes),
         super(scope);
 
   bool get hasParserError => recoverableErrors.isNotEmpty;
 
   bool get inConstructor {
     return functionNestingLevel == 0 && member is KernelConstructorBuilder;
   }
 
   bool get isInstanceContext {
     return isInstanceMember || member is KernelConstructorBuilder;
@@ skipping 53 matching lines @@
     } else {
       return internalError("Unhandled: ${node.runtimeType}");
     }
   }
 
   Expression toEffect(Object node) {
     if (node is BuilderAccessor) return node.buildForEffect();
     return toValue(node);
   }
 
-  List<Expression> popListForValue(int n) {
-    List<Expression> list =
-        new List<Expression>.filled(n, null, growable: true);
+  List<shadow.Expression> popListForValue(int n) {
+    List<shadow.Expression> list =
+        new List<shadow.Expression>.filled(n, null, growable: true);
     for (int i = n - 1; i >= 0; i--) {
       list[i] = popForValue();
     }
     return list;
   }
 
   List<Expression> popListForEffect(int n) {
     List<Expression> list =
         new List<Expression>.filled(n, null, growable: true);
     for (int i = n - 1; i >= 0; i--) {
       list[i] = popForEffect();
     }
     return list;
   }
 
-  Block popBlock(int count, int charOffset) {
+  shadow.Block popBlock(int count, int charOffset) {
     List<dynamic /*Statement | List<Statement>*/ > statements =
         popList(count) ?? <Statement>[];
     List<Statement> copy;
     for (int i = 0; i < statements.length; i++) {
       var statement = statements[i];
       if (statement is List) {
         copy ??= new List<Statement>.from(statements.getRange(0, i));
         // TODO(sigmund): remove this assignment (issue #28651)
         Iterable subStatements = statement;
         copy.addAll(subStatements);
       } else if (copy != null) {
         copy.add(statement);
       }
     }
-    return new Block(copy ?? statements)..fileOffset = charOffset;
+    return _ast.block(copy ?? statements, charOffset);
   }
 
   Statement popStatementIfNotNull(Object value) {
     return value == null ? null : popStatement();
   }
 
   Statement popStatement() {
     var statement = pop();
     if (statement is List) {
       return new Block(new List<Statement>.from(statement));
@@ skipping 176 matching lines @@
   void handleNoInitializers() {
     debugEvent("NoInitializers");
   }
 
   @override
   void endInitializers(int count, Token beginToken, Token endToken) {
     debugEvent("Initializers");
   }
 
   @override
-  void finishFunction(
-      FormalParameters formals, AsyncMarker asyncModifier, Statement body) {
+  void finishFunction(FormalParameters formals, AsyncMarker asyncModifier,
+      shadow.Statement body) {
     debugEvent("finishFunction");
     KernelFunctionBuilder builder = member;
     if (builder is KernelConstructorBuilder) {
       if (asyncModifier != AsyncMarker.Sync) {
         // TODO(ahe): Change this to a null check.
         addCompileTimeError(body?.fileOffset,
             "Can't be marked as ${asyncModifier}: ${builder.name}");
       }
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
       internalError("Unhandled: ${builder.runtimeType}");
     }
+    _typeInferrer.inferBody(body);
     builder.body = body;
     if (formals?.optional != null) {
       Iterator<FormalParameterBuilder> formalBuilders =
           builder.formals.skip(formals.required.length).iterator;
       for (VariableDeclaration parameter in formals.optional.formals) {
         bool hasMore = formalBuilders.moveNext();
         assert(hasMore);
         VariableDeclaration realParameter = formalBuilders.current.target;
         Expression initializer = parameter.initializer ?? new NullLiteral();
         realParameter.initializer = initializer..parent = realParameter;
@@ skipping 442 matching lines @@
           expressions.add(part);
         }
       }
     }
     push(new StringConcatenation(expressions ?? parts));
   }
 
   @override
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
-    push(
-        new IntLiteral(int.parse(token.lexeme))..fileOffset = token.charOffset);
+    push(_ast.intLiteral(int.parse(token.lexeme), token.charOffset));
   }
 
   @override
   void handleEmptyFunctionBody(Token semicolon) {
     debugEvent("ExpressionFunctionBody");
     endBlockFunctionBody(0, null, semicolon);
   }
 
   @override
   void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
     debugEvent("ExpressionFunctionBody");
     endReturnStatement(true, arrowToken.next, endToken);
   }
 
   @override
   void endReturnStatement(
       bool hasExpression, Token beginToken, Token endToken) {
     debugEvent("ReturnStatement");
-    Expression expression = hasExpression ? popForValue() : null;
+    shadow.Expression expression = hasExpression ? popForValue() : null;
     if (expression != null && inConstructor) {
       push(buildCompileTimeErrorStatement(
           "Can't return from a constructor.", beginToken.charOffset));
     } else {
-      push(new ReturnStatement(expression)..fileOffset = beginToken.charOffset);
+      push(_ast.returnStatement(expression, beginToken.charOffset));
+      _typeInferrer.recordReturnStatement(_functionContext, expression);
     }
   }
 
   @override
   void endIfStatement(Token ifToken, Token elseToken) {
     Statement elsePart = popStatementIfNotNull(elseToken);
     Statement thenPart = popStatement();
     Expression condition = popForValue();
     push(new IfStatement(condition, thenPart, elsePart));
   }
 
   @override
   void endVariableInitializer(Token assignmentOperator) {
     debugEvent("VariableInitializer");
     assert(assignmentOperator.stringValue == "=");
     pushNewLocalVariable(popForValue(),
         equalsCharOffset: assignmentOperator.charOffset);
   }
 
   @override
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");
     pushNewLocalVariable(null);
   }
 
-  void pushNewLocalVariable(Expression initializer,
+  void pushNewLocalVariable(shadow.Expression initializer,
       {int equalsCharOffset: TreeNode.noOffset}) {
     Identifier identifier = pop();
     assert(currentLocalVariableModifiers != -1);
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
     bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
     assert(isConst == constantExpressionRequired);
-    push(new VariableDeclaration(identifier.name,
+    var variable = _ast.variableDeclaration(identifier.name,
         initializer: initializer,
-        type: currentLocalVariableType ?? const DynamicType(),
+        type: currentLocalVariableType,
         isFinal: isFinal,
-        isConst: isConst)..fileEqualsOffset = equalsCharOffset);
+        isConst: isConst,
+        charOffset: equalsCharOffset);
+    _typeInferrer.finishVariableDeclaration(
+        currentLocalVariableType, initializer, variable);
+    push(variable);
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator) {
     debugEvent("FieldInitializer");
     assert(assignmentOperator.stringValue == "=");
     push(popForValue());
   }
 
   @override
@@ skipping 139 matching lines @@
   void endAwaitExpression(Token beginToken, Token endToken) {
     debugEvent("AwaitExpression");
     push(
         new AwaitExpression(popForValue())..fileOffset = beginToken.charOffset);
   }
 
   @override
   void handleAsyncModifier(Token asyncToken, Token starToken) {
     debugEvent("AsyncModifier");
     push(asyncMarkerFromTokens(asyncToken, starToken));
+    _functionContext?.recordAsyncModifier(asyncToken != null);
   }
 
   @override
   void handleLiteralList(
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralList");
-    List<Expression> expressions = popListForValue(count);
+    List<shadow.Expression> expressions = popListForValue(count);
     List<DartType> typeArguments = pop();
-    DartType typeArgument = const DynamicType();
+    DartType typeArgument;
     if (typeArguments != null) {
       typeArgument = typeArguments.first;
       if (typeArguments.length > 1) {
-        typeArgument = const DynamicType();
+        typeArgument = null;
         warning(
             "Too many type arguments on List literal.", beginToken.charOffset);
       }
     }
-    push(new ListLiteral(expressions,
-        typeArgument: typeArgument, isConst: constKeyword != null)
-      ..fileOffset = constKeyword?.charOffset ?? beginToken.charOffset);
+    push(_ast.listLiteral(expressions, typeArgument, constKeyword != null,
+        constKeyword?.charOffset ?? beginToken.charOffset));
   }
 
   @override
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
     bool value = optional("true", token);
     assert(value || optional("false", token));
     push(new BoolLiteral(value)..fileOffset = token.charOffset);
   }
 
   @override
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
     push(new DoubleLiteral(double.parse(token.lexeme))
       ..fileOffset = token.charOffset);
   }
 
   @override
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
-    push(new NullLiteral()..fileOffset = token.charOffset);
+    push(_ast.nullLiteral(token.charOffset));
   }
 
   @override
   void handleLiteralMap(
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralMap");
     List<MapEntry> entries = popList(count) ?? <MapEntry>[];
     List<DartType> typeArguments = pop();
     DartType keyType = const DynamicType();
     DartType valueType = const DynamicType();
@@ skipping 201 matching lines @@
       if (!inConstructor) {
         addCompileTimeError(thisKeyword.charOffset,
             "'this' parameters can only be used on constructors.");
         thisKeyword = null;
       }
     }
     Identifier name = pop();
     DartType type = pop();
     pop(); // Modifiers.
     ignore(Unhandled.Metadata);
-    VariableDeclaration variable;
+    shadow.VariableDeclaration variable;
     if (!inCatchClause && functionNestingLevel == 0) {
       dynamic builder = formalParameterScope.lookup(name.name, charOffset, uri);
       if (builder == null) {
         if (thisKeyword == null) {
           internalError("Internal error: formal missing for '${name.name}'");
         } else {
           addCompileTimeError(thisKeyword.charOffset,
               "'${name.name}' isn't a field in this class.");
           thisKeyword = null;
         }
       } else if (thisKeyword == null) {
         variable = builder.build(library);
         variable.initializer = name.initializer;
       } else if (builder.isField && builder.parent == classBuilder) {
         FieldBuilder field = builder;
         if (type != null) {
           nit("Ignoring type on 'this' parameter '${name.name}'.",
               thisKeyword.charOffset);
         }
         type = field.target.type ?? const DynamicType();
-        variable = new VariableDeclaration(name.name,
-            type: type, initializer: name.initializer);
+        variable = _ast.variableDeclaration(name.name,
+            type: type,
+            initializer: name.initializer as shadow.Expression,
+            charOffset: name.fileOffset);
       } else {
         addCompileTimeError(
             name.fileOffset, "'${name.name}' isn't a field in this class.");
       }
     }
-    variable ??= new VariableDeclaration(name.name,
-        type: type ?? const DynamicType(),
-        initializer: name.initializer)..fileOffset = name.fileOffset;
+    variable ??= _ast.variableDeclaration(name.name,
+        type: type,
+        initializer: name.initializer as shadow.Expression,
+        charOffset: name.fileOffset);
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
         ? FormalParameterType.NAMED
         : FormalParameterType.POSITIONAL;
@@ skipping 45 matching lines @@
     }
     FormalParameters formals = new FormalParameters(
         popList(count) ?? <VariableDeclaration>[],
         optional,
         beginToken.charOffset);
     push(formals);
     if (inCatchClause || functionNestingLevel != 0) {
       enterLocalScope(formals.computeFormalParameterScope(
           scope, member ?? classBuilder ?? library));
     }
+    formals.recordTypeInferenceTo(_functionContext);
   }
 
   @override
   void beginCatchClause(Token token) {
     debugEvent("beginCatchClause");
     inCatchClause = true;
   }
 
   @override
   void endCatchClause(Token token) {
@@ skipping 357 matching lines @@
     VariableDeclaration variable =
         new VariableDeclaration(name.name, isFinal: true);
     push(new FunctionDeclaration(
         variable, new FunctionNode(new InvalidStatement()))
       ..fileOffset = beginToken.charOffset);
     scope[variable.name] = new KernelVariableBuilder(
         variable, member ?? classBuilder ?? library, uri);
     enterLocalScope();
   }
 
-  void enterFunction() {
+  void enterFunction(bool isNamed) {
     debugEvent("enterFunction");
     functionNestingLevel++;
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = null;
+    _functionContext = _typeInferrer.nestFunctionContext(_functionContext);
   }
 
   void exitFunction() {
     debugEvent("exitFunction");
     functionNestingLevel--;
     switchScope = pop();
   }
 
   @override
   void beginFunction(Token token) {
     debugEvent("beginFunction");
-    enterFunction();
+    enterFunction(true);
   }
 
   @override
   void beginUnnamedFunction(Token token) {
     debugEvent("beginUnnamedFunction");
-    enterFunction();
+    enterFunction(false);
   }
 
   @override
   void endFunction(Token getOrSet, Token endToken) {
     debugEvent("Function");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     if (functionNestingLevel != 0) {
       exitLocalScope();
     }
@@ skipping 25 matching lines @@
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
     exitFunction();
     List<TypeParameter> typeParameters = pop();
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
       ..fileOffset = beginToken.charOffset
       ..fileEndOffset = token.charOffset);
-    push(new FunctionExpression(function)..fileOffset = beginToken.charOffset);
+    push(new shadow.FunctionExpression(function)
+      ..fileOffset = beginToken.charOffset);
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
     debugEvent("DoWhileStatement");
     Expression condition = popForValue();
     Statement body = popStatement();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
@@ skipping 870 matching lines @@
           new KernelVariableBuilder(parameter, builder, builder.fileUri);
     }
     if (optional != null) {
       for (VariableDeclaration parameter in optional.formals) {
         local[parameter.name] =
             new KernelVariableBuilder(parameter, builder, builder.fileUri);
       }
     }
     return new Scope(local, parent, isModifiable: false);
   }
+
+  void recordTypeInferenceTo(OldFunctionContext functionContext) {
+    if (functionContext == null) return;
+    int requiredParameterCount = required.length;
+    var positionalFormals = <shadow.VariableDeclaration>[];
+    var namedFormals = const <shadow.VariableDeclaration>[];
+    for (VariableDeclaration parameter in required) {
+      positionalFormals.add(parameter);
+    }
+    if (optional != null) {
+      throw new UnimplementedError();
+    }
+    functionContext.recordFormals(
+        requiredParameterCount, positionalFormals, namedFormals);
+  }
 }
 
 /// Returns a block like this:
 ///
 ///     {
 ///       statement;
 ///       body;
 ///     }
 ///
 /// If [body] is a [Block], it's returned with [statement] prepended to it.
@@ skipping 22 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }