Parameterize TypeSystem by its node kind

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';
@@ skipping 86 matching lines @@
   }
 
   String toString() {
     String rest = parent == null ? "null" : parent.toString();
     return '$variables $rest';
   }
 }
 
 /// Tracks initializers via initializations and assignments.
 class FieldInitializationScope {
-  final TypeSystem types;
+  final TypeSystem<Node> types;
   Map<Element, 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;
@@ skipping 118 matching lines @@
     _iteratePositional = false;
     return named.moveNext();
   }
 }
 
 /**
  * Placeholder for inferred types of local variables.
  */
 class LocalsHandler {
   final CompilerOptions options;
-  final TypeSystem types;
+  final TypeSystem<Node> types;
   final InferrerEngine inferrer;
   final VariableScope locals;
   final Map<Local, FieldEntity> captured;
   final Map<Local, FieldEntity> capturedAndBoxed;
   final FieldInitializationScope fieldScope;
   LocalsHandler tryBlock;
   bool seenReturnOrThrow = false;
   bool seenBreakOrContinue = false;
 
   bool get aborts {
@@ skipping 62 matching lines @@
     updateLocal() {
       TypeInformation currentType = locals[local];
 
       SendSet send = node != null ? node.asSendSet() : null;
       if (send != null && send.isIfNullAssignment && 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)),
+                locals.block, local, types.narrowNotNull(currentType),
+                isTry: locals.block is TryStatement),
             type);
       }
       locals[local] = type;
       if (currentType != type) {
         inferrer.recordLocalUpdate(local, type);
       }
     }
 
     if (capturedAndBoxed.containsKey(local)) {
       inferrer.recordTypeOfNonFinalField(capturedAndBoxed[local], type);
     } else if (inTryBlock) {
       // We don'TypeInformation know if an assignment in a try block
       // will be executed, so all assignments in that block are
       // potential types after we have left it. We update the parent
       // of the try block so that, at exit of the try block, we get
       // the right phi for it.
       TypeInformation existing = tryBlock.locals.parent[local];
       if (existing != null) {
-        TypeInformation phiType =
-            types.allocatePhi(tryBlock.locals.block, local, existing);
+        TypeInformation phiType = types.allocatePhi(
+            tryBlock.locals.block, local, existing,
+            isTry: tryBlock.locals.block is TryStatement);
         TypeInformation inputType = types.addPhiInput(local, phiType, type);
         tryBlock.locals.parent[local] = inputType;
       }
       // Update the current handler unconditionnally with the new
       // type.
       updateLocal();
     } else {
       updateLocal();
     }
   }
@@ skipping 138 matching lines @@
    * overwrites the current type knowledge in this handler.
    */
   bool mergeHandler(LocalsHandler 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);
+        newType = types.allocatePhi(locals.block, local, otherType,
+            isTry: locals.block is TryStatement);
         seen.add(local);
       } else {
         newType = types.addPhiInput(local, myType, otherType);
       }
       if (newType != myType) {
         changed = true;
         locals[local] = newType;
       }
     });
     return changed;
   }
 
   /**
    * Merge all [LocalsHandler] in [handlers] into this handler.
    * Returns whether a local in this handler has changed.
    */
   bool mergeAll(List<LocalsHandler> handlers) {
     bool changed = false;
     assert(!seenReturnOrThrow);
     handlers.forEach((other) {
       changed = mergeHandler(other) || changed;
     });
     return changed;
   }
 
   void startLoop(Node loop) {
     locals.forEachLocal((Local variable, TypeInformation type) {
-      TypeInformation newType = types.allocateLoopPhi(loop, variable, type);
+      TypeInformation newType = types.allocateLoopPhi(loop, variable, type,
+          isTry: loop is TryStatement);
       if (newType != type) {
         locals[variable] = newType;
       }
     });
   }
 
   void endLoop(Node 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) {
     fieldScope.updateField(element, type);
   }
 }