Introduce initial plumbing for type promotion in fasta.

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 '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:front_end/src/fasta/builder/ast_factory.dart' show AstFactory;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
-    show KernelField, KernelVariableDeclaration;
+    show KernelField;
 
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
     show FieldNode;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
+import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
+    show TypePromoter;
+
 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 48 matching lines @@
   final Map<String, FieldInitializer> fieldInitializers =
       <String, FieldInitializer>{};
 
   final Scope enclosingScope;
 
   final bool isDartLibrary;
 
   @override
   final Uri uri;
 
-  final TypeInferrer<Statement, Expression, KernelVariableDeclaration,
-      KernelField> _typeInferrer;
+  final TypeInferrer<Statement, Expression, VariableDeclaration, KernelField>
+      _typeInferrer;
 
+  @override
   final AstFactory astFactory;
 
+  @override
+  final TypePromoter<Expression, VariableDeclaration> typePromoter;
+
   /// If not `null`, dependencies on fields are accumulated into this list.
   ///
   /// If `null`, no dependency information is recorded.
   final List<FieldNode<KernelField>> fieldDependencies;
 
   /// Only used when [member] is a constructor. It tracks if an implicit super
   /// initializer is needed.
   ///
   /// An implicit super initializer isn't needed
   ///
@@ skipping 41 matching lines @@
       this.isInstanceMember,
       this.uri,
       this._typeInferrer,
       this.astFactory,
       {this.fieldDependencies})
       : enclosingScope = scope,
         library = library,
         isDartLibrary = library.uri.scheme == "dart",
         needsImplicitSuperInitializer =
             coreTypes.objectClass != classBuilder?.cls,
+        typePromoter = _typeInferrer.typePromoter,
         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 279 matching lines @@
 
   @override
   void endInitializers(int count, Token beginToken, Token endToken) {
     debugEvent("Initializers");
   }
 
   @override
   void finishFunction(
       FormalParameters formals, AsyncMarker asyncModifier, Statement body) {
     debugEvent("finishFunction");
+    typePromoter.finished();
     _typeInferrer.inferStatement(body);
     KernelFunctionBuilder builder = member;
     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;
@@ skipping 54 matching lines @@
       /// >and no body is provided, then c implicitly has an empty body {}.
       /// We use an empty statement instead.
       constructor.function.body = new EmptyStatement();
       constructor.function.body.parent = constructor.function;
     }
   }
 
   @override
   void endExpressionStatement(Token token) {
     debugEvent("ExpressionStatement");
-    push(new ExpressionStatement(popForEffect()));
+    push(astFactory.expressionStatement(popForEffect()));
   }
 
   @override
   void endArguments(int count, Token beginToken, Token endToken) {
     debugEvent("Arguments");
     List arguments = popList(count) ?? <Expression>[];
     int firstNamedArgumentIndex = arguments.length;
     for (int i = 0; i < arguments.length; i++) {
       var node = arguments[i];
       if (node is NamedExpression) {
@@ skipping 492 matching lines @@
     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);
     }
   }
 
   @override
+  void beginThenStatement(Token token) {
+    Expression condition = popForValue();
+    typePromoter.enterThen(condition);
+    push(condition);
+    super.beginThenStatement(token);
+  }
+
+  @override
+  void endThenStatement(Token token) {
+    typePromoter.enterElse();
+    super.endThenStatement(token);
+  }
+
+  @override
   void endIfStatement(Token ifToken, Token elseToken) {
     Statement elsePart = popStatementIfNotNull(elseToken);
     Statement thenPart = popStatement();
     Expression condition = popForValue();
-    push(new IfStatement(condition, thenPart, elsePart));
+    typePromoter.exitConditional();
+    push(astFactory.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,
       {int equalsCharOffset: TreeNode.noOffset}) {
     Identifier identifier = pop();
     assert(currentLocalVariableModifiers != -1);
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
     bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
     assert(isConst == constantExpressionRequired);
-    push(astFactory.variableDeclaration(identifier.name, identifier.fileOffset,
+    push(astFactory.variableDeclaration(
+        identifier.name, identifier.fileOffset, functionNestingLevel,
         initializer: initializer,
         type: currentLocalVariableType,
         isFinal: isFinal,
         isConst: isConst,
         equalsCharOffset: equalsCharOffset));
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator, Token token) {
     debugEvent("FieldInitializer");
@@ skipping 119 matching lines @@
     }
     if (variableOrExpression is VariableDeclaration) {
       variables.add(variableOrExpression);
     } else if (variableOrExpression is List) {
       // TODO(sigmund): remove this assignment (see issue #28651)
       Iterable vars = variableOrExpression;
       variables.addAll(vars);
     } else if (variableOrExpression == null) {
       // Do nothing.
     } else if (variableOrExpression is Expression) {
-      begin = new ExpressionStatement(variableOrExpression);
+      begin = astFactory.expressionStatement(variableOrExpression);
     } else {
       return internalError("Unhandled: ${variableOrExpression.runtimeType}");
     }
     exitLocalScope();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
       body = new LabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
@@ skipping 229 matching lines @@
     debugEvent("AsOperator");
     DartType type = pop();
     Expression expression = popForValue();
     push(new AsExpression(expression, type)..fileOffset = operator.charOffset);
   }
 
   @override
   void handleIsOperator(Token operator, Token not, Token endToken) {
     debugEvent("IsOperator");
     DartType type = pop();
-    Expression expression = popForValue();
-    expression = new IsExpression(expression, type)
-      ..fileOffset = operator.charOffset;
-    if (not != null) {
-      expression = new Not(expression);
+    Expression operand = popForValue();
+    bool isInverted = not != null;
+    Expression isExpression =
+        astFactory.isExpression(operand, type, operator.charOffset, isInverted);
+    if (operand is VariableGet) {
+      typePromoter.handleIsCheck(isExpression, isInverted, operand.variable,
+          type, functionNestingLevel);
     }
-    push(expression);
+    push(isExpression);
   }
 
   @override
   void handleConditionalExpression(Token question, Token colon) {
     debugEvent("ConditionalExpression");
     Expression elseExpression = popForValue();
     Expression thenExpression = popForValue();
     Expression condition = popForValue();
     push(new ConditionalExpression(
         condition, thenExpression, elseExpression, const DynamicType()));
@@ skipping 47 matching lines @@
       } 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 = astFactory.variableDeclaration(name.name, name.fileOffset,
+        variable = astFactory.variableDeclaration(
+            name.name, name.fileOffset, functionNestingLevel,
             type: type,
             initializer: name.initializer,
             isFinal: isFinal,
             isConst: isConst);
       } else {
         addCompileTimeError(
             name.fileOffset, "'${name.name}' isn't a field in this class.");
       }
     }
-    variable ??= astFactory.variableDeclaration(name.name, name.fileOffset,
+    variable ??= astFactory.variableDeclaration(
+        name.name, name.fileOffset, functionNestingLevel,
         type: type ?? const DynamicType(),
         initializer: name.initializer,
         isFinal: isFinal,
         isConst: isConst);
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
@@ skipping 442 matching lines @@
     debugEvent("NamedArgument");
     Expression value = popForValue();
     Identifier identifier = pop();
     push(new NamedExpression(identifier.name, value));
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
-    VariableDeclaration variable = astFactory
-        .variableDeclaration(name.name, name.fileOffset, isFinal: true);
+    VariableDeclaration variable = astFactory.variableDeclaration(
+        name.name, name.fileOffset, functionNestingLevel,
+        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() {
     debugEvent("enterFunction");
@@ skipping 59 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(astFactory.functionExpression(function, 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 45 matching lines @@
       ///     for (lvalue in expression) body
       ///
       /// This is normalized to:
       ///
       ///     for (final #t in expression) {
       ///       lvalue = #t;
       ///       body;
       ///     }
       variable = new VariableDeclaration.forValue(null);
       body = combineStatements(
-          new ExpressionStatement(lvalue
+          astFactory.expressionStatement(lvalue
               .buildAssignment(new VariableGet(variable), voidContext: true)),
           body);
     } else {
       variable = new VariableDeclaration.forValue(buildCompileTimeError(
           "Expected lvalue, but got ${lvalue}", forToken.next.next.charOffset));
     }
     Statement result = new ForInStatement(variable, expression, body,
         isAsync: awaitToken != null)
       ..fileOffset = body.fileOffset;
     if (breakTarget.hasUsers) {
@@ skipping 41 matching lines @@
       }
       target.continueTarget.resolveContinues(statement);
     }
     push(statement);
   }
 
   @override
   void endRethrowStatement(Token throwToken, Token endToken) {
     debugEvent("RethrowStatement");
     if (inCatchBlock) {
-      push(new ExpressionStatement(
+      push(astFactory.expressionStatement(
           new Rethrow()..fileOffset = throwToken.charOffset));
     } else {
       push(buildCompileTimeErrorStatement(
           "'rethrow' can only be used in catch clauses.",
           throwToken.charOffset));
     }
   }
 
   @override
   void handleFinallyBlock(Token finallyKeyword) {
@@ skipping 288 matching lines @@
   Expression buildAbstractClassInstantiationError(String className,
       [int charOffset = -1]) {
     warning("The class '$className' is abstract and can't be instantiated.",
         charOffset);
     Builder constructor = library.loader.getAbstractClassInstantiationError();
     return new Throw(buildStaticInvocation(constructor.target,
         new Arguments(<Expression>[new StringLiteral(className)])));
   }
 
   Statement buildCompileTimeErrorStatement(error, [int charOffset = -1]) {
-    return new ExpressionStatement(buildCompileTimeError(error, charOffset));
+    return astFactory
+        .expressionStatement(buildCompileTimeError(error, charOffset));
   }
 
   @override
   Initializer buildInvalidIntializer(Expression expression,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
     return new LocalInitializer(new VariableDeclaration.forValue(expression))
       ..fileOffset = charOffset;
   }
 
@@ skipping 555 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }