Use KernelTypeGraphBuilder in KernelInferrerEngine

pkg/compiler/lib/src/inferrer/locals_handler.dart

 // Copyright (c) 2013, 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 locals_handler;
 
 import 'dart:collection' show IterableMixin;
 
 import '../options.dart' show CompilerOptions;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
+import '../elements/types.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 import 'inferrer_engine.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
 /**
  * A variable scope holds types for variables. It has a link to a
  * parent scope, but never changes the types in that parent. Instead,
  * updates to locals of a parent scope are put in the current scope.
  * The inferrer makes sure updates get merged into the parent scope,
  * once the control flow block has been visited.
  */
-class VariableScope {
+class VariableScope<T> {
   Map<Local, TypeInformation> variables;
 
   /// The parent of this scope. Null for the root scope.
   final VariableScope parent;
 
   /// The [Node] that created this scope.
-  final Node block;
+  final T block;
 
   VariableScope(this.block, [parent])
       : this.variables = null,
         this.parent = parent;
 
-  VariableScope.deepCopyOf(VariableScope other)
+  VariableScope.deepCopyOf(VariableScope<T> other)
       : variables = other.variables == null
             ? null
             : new Map<Local, TypeInformation>.from(other.variables),
         block = other.block,
         parent = other.parent == null
             ? null
             : new VariableScope.deepCopyOf(other.parent);
 
-  VariableScope.topLevelCopyOf(VariableScope other)
+  VariableScope.topLevelCopyOf(VariableScope<T> other)
       : variables = other.variables == null
             ? null
             : new Map<Local, TypeInformation>.from(other.variables),
         block = other.block,
         parent = other.parent;
 
   TypeInformation operator [](Local variable) {
     TypeInformation result;
     if (variables == null || (result = variables[variable]) == null) {
       return parent == null ? null : parent[variable];
     }
     return result;
   }
 
   void operator []=(Local variable, TypeInformation mask) {
     assert(mask != null);
     if (variables == null) {
       variables = new Map<Local, TypeInformation>();
     }
     variables[variable] = mask;
   }
 
   void forEachOwnLocal(void f(Local variable, TypeInformation type)) {
     if (variables == null) return;
     variables.forEach(f);
   }
 
   void forEachLocalUntilNode(
-      Node node, void f(Local variable, TypeInformation type),
+      T node, void f(Local variable, TypeInformation type),
       [Setlet<Local> seenLocals]) {
     if (seenLocals == null) seenLocals = new Setlet<Local>();
     if (variables != null) {
       variables.forEach((variable, type) {
         if (seenLocals.contains(variable)) return;
         seenLocals.add(variable);
         f(variable, type);
       });
     }
     if (block == node) return;
     if (parent != null) parent.forEachLocalUntilNode(node, f, seenLocals);
   }
 
   void forEachLocal(void f(Local variable, TypeInformation type)) {
     forEachLocalUntilNode(null, f);
   }
 
   bool updates(Local variable) {
     if (variables == null) return false;
     return variables.containsKey(variable);
   }
 
   String toString() {
     String rest = parent == null ? "null" : parent.toString();
     return '$variables $rest';
   }
 }
 
 /// Tracks initializers via initializations and assignments.
-class FieldInitializationScope {
-  final TypeSystem<Node> types;
-  Map<Element, TypeInformation> fields;
+class FieldInitializationScope<T> {
+  final TypeSystem<T> types;
+  Map<FieldEntity, TypeInformation> fields;
   bool isThisExposed;
 
   /// `true` when control flow prevents accumulating definite assignments,
   /// e.g. an early return or caught exception.
   bool isIndefinite;
 
   FieldInitializationScope(this.types)
       : isThisExposed = false,
         isIndefinite = false;
 
-  FieldInitializationScope.internalFrom(FieldInitializationScope other)
+  FieldInitializationScope.internalFrom(FieldInitializationScope<T> other)
       : types = other.types,
         isThisExposed = other.isThisExposed,
         isIndefinite = other.isIndefinite;
 
-  factory FieldInitializationScope.from(FieldInitializationScope other) {
+  factory FieldInitializationScope.from(FieldInitializationScope<T> other) {
     if (other == null) return null;
-    return new FieldInitializationScope.internalFrom(other);
+    return new FieldInitializationScope<T>.internalFrom(other);
   }
 
-  void updateField(Element field, TypeInformation type) {
+  void updateField(FieldEntity field, TypeInformation type) {
     if (isThisExposed) return;
     if (isIndefinite) return;
-    fields ??= new Map<Element, TypeInformation>();
+    fields ??= new Map<FieldEntity, TypeInformation>();
     fields[field] = type;
   }
 
-  TypeInformation readField(Element field) {
+  TypeInformation readField(FieldEntity field) {
     return fields == null ? null : fields[field];
   }
 
-  void forEach(void f(Element element, TypeInformation type)) {
+  void forEach(void f(FieldEntity element, TypeInformation type)) {
     fields?.forEach(f);
   }
 
-  void mergeDiamondFlow(
-      FieldInitializationScope thenScope, FieldInitializationScope elseScope) {
+  void mergeDiamondFlow(FieldInitializationScope<T> thenScope,
+      FieldInitializationScope<T> elseScope) {
     // Quick bailout check. If [isThisExposed] or [isIndefinite] is true, we
     // know the code following won'TypeInformation do anything.
     if (isThisExposed) return;
     if (isIndefinite) return;
 
-    FieldInitializationScope otherScope =
+    FieldInitializationScope<T> otherScope =
         (elseScope == null || elseScope.fields == null) ? this : elseScope;
 
-    thenScope.forEach((Element field, TypeInformation type) {
+    thenScope.forEach((FieldEntity field, TypeInformation type) {
       TypeInformation otherType = otherScope.readField(field);
       if (otherType == null) return;
       updateField(field, types.allocateDiamondPhi(type, otherType));
     });
 
     isThisExposed = thenScope.isThisExposed || elseScope.isThisExposed;
     isIndefinite = thenScope.isIndefinite || elseScope.isIndefinite;
   }
 }
 
@@ skipping 69 matching lines @@
       return true;
     }
     _iteratePositional = false;
     return named.moveNext();
   }
 }
 
 /**
  * Placeholder for inferred types of local variables.
  */
-class LocalsHandler {
+class LocalsHandler<T> {
   final CompilerOptions options;
-  final TypeSystem<Node> types;
-  final InferrerEngine inferrer;
-  final VariableScope locals;
+  final TypeSystem<T> types;
+  final InferrerEngine<T> inferrer;
+  final VariableScope<T> locals;
   final Map<Local, FieldEntity> captured;
   final Map<Local, FieldEntity> capturedAndBoxed;
-  final FieldInitializationScope fieldScope;
-  LocalsHandler tryBlock;
+  final FieldInitializationScope<T> fieldScope;
+  LocalsHandler<T> tryBlock;
   bool seenReturnOrThrow = false;
   bool seenBreakOrContinue = false;
 
   bool get aborts {
     return seenReturnOrThrow || seenBreakOrContinue;
   }
 
   bool get inTryBlock => tryBlock != null;
 
-  LocalsHandler(this.inferrer, this.types, this.options, Node block,
+  LocalsHandler(this.inferrer, this.types, this.options, T block,
       [this.fieldScope])
-      : locals = new VariableScope(block),
+      : locals = new VariableScope<T>(block),
         captured = new Map<Local, FieldEntity>(),
         capturedAndBoxed = new Map<Local, FieldEntity>(),
         tryBlock = null;
 
-  LocalsHandler.from(LocalsHandler other, Node block,
+  LocalsHandler.from(LocalsHandler<T> other, T block,
       {bool useOtherTryBlock: true})
-      : locals = new VariableScope(block, other.locals),
-        fieldScope = new FieldInitializationScope.from(other.fieldScope),
+      : locals = new VariableScope<T>(block, other.locals),
+        fieldScope = new FieldInitializationScope<T>.from(other.fieldScope),
         captured = other.captured,
         capturedAndBoxed = other.capturedAndBoxed,
         types = other.types,
         inferrer = other.inferrer,
         options = other.options {
     tryBlock = useOtherTryBlock ? other.tryBlock : this;
   }
 
-  LocalsHandler.deepCopyOf(LocalsHandler other)
-      : locals = new VariableScope.deepCopyOf(other.locals),
-        fieldScope = new FieldInitializationScope.from(other.fieldScope),
+  LocalsHandler.deepCopyOf(LocalsHandler<T> other)
+      : locals = new VariableScope<T>.deepCopyOf(other.locals),
+        fieldScope = new FieldInitializationScope<T>.from(other.fieldScope),
         captured = other.captured,
         capturedAndBoxed = other.capturedAndBoxed,
         tryBlock = other.tryBlock,
         types = other.types,
         inferrer = other.inferrer,
         options = other.options;
 
-  LocalsHandler.topLevelCopyOf(LocalsHandler other)
-      : locals = new VariableScope.topLevelCopyOf(other.locals),
-        fieldScope = new FieldInitializationScope.from(other.fieldScope),
+  LocalsHandler.topLevelCopyOf(LocalsHandler<T> other)
+      : locals = new VariableScope<T>.topLevelCopyOf(other.locals),
+        fieldScope = new FieldInitializationScope<T>.from(other.fieldScope),
         captured = other.captured,
         capturedAndBoxed = other.capturedAndBoxed,
         tryBlock = other.tryBlock,
         types = other.types,
         inferrer = other.inferrer,
         options = other.options;
 
   TypeInformation use(Local local) {
     assert(!(local is LocalElement && !local.isImplementation));
     if (capturedAndBoxed.containsKey(local)) {
       FieldElement field = capturedAndBoxed[local];
       return inferrer.typeOfMember(field);
     } else {
       return locals[local];
     }
   }
 
-  void update(LocalElement local, TypeInformation type, Node node) {
+  void update(Local local, TypeInformation type, T node, DartType staticType,
+      {bool isSetIfNull: false}) {
     assert(type != null);
     if (options.trustTypeAnnotations || options.enableTypeAssertions) {
-      type = types.narrowType(type, local.type);
+      type = types.narrowType(type, staticType);
     }
     updateLocal() {
       TypeInformation currentType = locals[local];
 
-      SendSet send = node != null ? node.asSendSet() : null;
-      if (send != null && send.isIfNullAssignment && currentType != null) {
+      if (isSetIfNull && currentType != null) {
         // If-null assignments may return either the new or the original value
         // narrowed to non-null.
         type = types.addPhiInput(
             local,
             types.allocatePhi(
                 locals.block, local, types.narrowNotNull(currentType),
                 isTry: locals.block is TryStatement),
             type);
       }
       locals[local] = type;
@@ skipping 16 matching lines @@
         tryBlock.locals.parent[local] = inputType;
       }
       // Update the current handler unconditionnally with the new
       // type.
       updateLocal();
     } else {
       updateLocal();
     }
   }
 
+  void narrow(Local local, DartType type, T node, {bool isSetIfNull: false}) {
+    TypeInformation existing = use(local);
+    TypeInformation newType =
+        types.narrowType(existing, type, isNullable: false);
+    update(local, newType, node, type, isSetIfNull: isSetIfNull);
+  }
+
   void setCaptured(Local local, FieldEntity field) {
     captured[local] = field;
   }
 
   void setCapturedAndBoxed(Local local, FieldEntity field) {
     capturedAndBoxed[local] = field;
   }
 
-  void mergeDiamondFlow(LocalsHandler thenBranch, LocalsHandler elseBranch) {
+  void mergeDiamondFlow(
+      LocalsHandler<T> thenBranch, LocalsHandler<T> elseBranch) {
     if (fieldScope != null && elseBranch != null) {
       fieldScope.mergeDiamondFlow(thenBranch.fieldScope, elseBranch.fieldScope);
     }
     seenReturnOrThrow = thenBranch.seenReturnOrThrow &&
         elseBranch != null &&
         elseBranch.seenReturnOrThrow;
     seenBreakOrContinue = thenBranch.seenBreakOrContinue &&
         elseBranch != null &&
         elseBranch.seenBreakOrContinue;
     if (aborts) return;
 
-    void mergeOneBranch(LocalsHandler other) {
+    void mergeOneBranch(LocalsHandler<T> other) {
       other.locals.forEachOwnLocal((Local local, TypeInformation type) {
         TypeInformation myType = locals[local];
         if (myType == null) return; // Variable is only defined in [other].
         if (type == myType) return;
         locals[local] = types.allocateDiamondPhi(myType, type);
       });
     }
 
-    void inPlaceUpdateOneBranch(LocalsHandler other) {
+    void inPlaceUpdateOneBranch(LocalsHandler<T> other) {
       other.locals.forEachOwnLocal((Local local, TypeInformation type) {
         TypeInformation myType = locals[local];
         if (myType == null) return; // Variable is only defined in [other].
         if (type == myType) return;
         locals[local] = type;
       });
     }
 
     if (thenBranch.aborts) {
       if (elseBranch == null) return;
@@ skipping 49 matching lines @@
    *
    * [: L: {
    *      if (...) break;
    *      ...
    *    }
    * :]
    *
    * where [:this:] is the [LocalsHandler] for the paths through the
    * labeled statement that do not break out.
    */
-  void mergeAfterBreaks(List<LocalsHandler> handlers,
+  void mergeAfterBreaks(List<LocalsHandler<T>> handlers,
       {bool keepOwnLocals: true}) {
-    Node level = locals.block;
+    T level = locals.block;
     // Use a separate locals handler to perform the merge in, so that Phi
     // creation does not invalidate previous type knowledge while we might
     // still look it up.
-    LocalsHandler merged = new LocalsHandler.from(this, level);
+    LocalsHandler<T> merged = new LocalsHandler<T>.from(this, level);
     Set<Local> seenLocals = new Setlet<Local>();
     bool allBranchesAbort = true;
     // Merge all other handlers.
-    for (LocalsHandler handler in handlers) {
+    for (LocalsHandler<T> handler in handlers) {
       allBranchesAbort = allBranchesAbort && handler.seenReturnOrThrow;
       merged.mergeHandler(handler, seenLocals);
     }
     // If we want to keep own locals, we merge [seenLocals] from [this] into
     // [merged] to update the Phi nodes with original values.
     if (keepOwnLocals && !seenReturnOrThrow) {
       for (Local variable in seenLocals) {
         TypeInformation originalType = locals[variable];
         if (originalType != null) {
           merged.locals[variable] = types.addPhiInput(
               variable, merged.locals[variable], originalType);
         }
       }
     }
     // Clean up Phi nodes with single input and store back result into
     // actual locals handler.
     merged.locals.forEachOwnLocal((Local variable, TypeInformation type) {
       locals[variable] = types.simplifyPhi(level, variable, type);
     });
     seenReturnOrThrow =
         allBranchesAbort && (!keepOwnLocals || seenReturnOrThrow);
   }
 
   /**
    * Merge [other] into this handler. Returns whether a local in this
    * has changed. If [seen] is not null, we allocate new Phi nodes
    * unless the local is already present in the set [seen]. This effectively
    * overwrites the current type knowledge in this handler.
    */
-  bool mergeHandler(LocalsHandler other, [Set<Local> seen]) {
+  bool mergeHandler(LocalsHandler<T> other, [Set<Local> seen]) {
     if (other.seenReturnOrThrow) return false;
     bool changed = false;
     other.locals.forEachLocalUntilNode(locals.block, (local, otherType) {
       TypeInformation myType = locals[local];
       if (myType == null) return;
       TypeInformation newType;
       if (seen != null && !seen.contains(local)) {
         newType = types.allocatePhi(locals.block, local, otherType,
             isTry: locals.block is TryStatement);
         seen.add(local);
@@ skipping 14 matching lines @@
    */
   bool mergeAll(List<LocalsHandler> handlers) {
     bool changed = false;
     assert(!seenReturnOrThrow);
     handlers.forEach((other) {
       changed = mergeHandler(other) || changed;
     });
     return changed;
   }
 
-  void startLoop(Node loop) {
+  void startLoop(T loop) {
     locals.forEachLocal((Local variable, TypeInformation type) {
       TypeInformation newType = types.allocateLoopPhi(loop, variable, type,
           isTry: loop is TryStatement);
       if (newType != type) {
         locals[variable] = newType;
       }
     });
   }
 
-  void endLoop(Node loop) {
+  void endLoop(T loop) {
     locals.forEachLocal((Local variable, TypeInformation type) {
       TypeInformation newType = types.simplifyPhi(loop, variable, type);
       if (newType != type) {
         locals[variable] = newType;
       }
     });
   }
 
-  void updateField(Element element, TypeInformation type) {
+  void updateField(FieldEntity element, TypeInformation type) {
     fieldScope.updateField(element, type);
   }
 }