Parameterize TypeSystem by its node kind

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

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 45 matching lines @@
 
   int overallRefineCount = 0;
   int addedInGraph = 0;
 
   final Compiler compiler;
 
   /// The [ClosedWorld] on which inference reasoning is based.
   final ClosedWorld closedWorld;
 
   final ClosedWorldRefiner closedWorldRefiner;
-  final TypeSystem types;
+  final TypeSystem<ast.Node> types;
   final Map<ast.Node, TypeInformation> concreteTypes =
       new Map<ast.Node, TypeInformation>();
 
   /// Parallel structure for concreteTypes.
   // TODO(efortuna): Remove concreteTypes and/or parameterize InferrerEngine by
   // ir.Node or ast.Node type. Then remove this in favor of `concreteTypes`.
   final Map<ir.Node, TypeInformation> concreteKernelTypes =
       new Map<ir.Node, TypeInformation>();
   final Set<ConstructorElement> generativeConstructorsExposingThis =
       new Set<ConstructorElement>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
   final Map<MemberElement, GlobalTypeInferenceElementData> _memberData =
       new Map<MemberElement, GlobalTypeInferenceElementData>();
 
   InferrerEngine(this.compiler, ClosedWorld closedWorld,
       this.closedWorldRefiner, this.mainElement)
-      : this.types = new TypeSystem(closedWorld),
+      : this.types = new TypeSystem<ast.Node>(closedWorld),
         this.closedWorld = closedWorld;
 
   CommonElements get commonElements => closedWorld.commonElements;
 
   /**
    * Applies [f] to all elements in the universe that match
    * [selector] and [mask]. If [f] returns false, aborts the iteration.
    */
   void forEachElementMatching(
       Selector selector, TypeMask mask, bool f(Element element)) {
@@ skipping 844 matching lines @@
     types.allocatedCalls.add(info);
     return info;
   }
 
   /**
    * Registers a call to await with an expression of type [argumentType] as
    * argument.
    */
   TypeInformation registerAwait(ast.Node node, TypeInformation argument) {
     AwaitTypeInformation info =
-        new AwaitTypeInformation(types.currentMember, node);
+        new AwaitTypeInformation<ast.Node>(types.currentMember, node);
     info.addAssignment(argument);
     types.allocatedTypes.add(info);
     return info;
   }
 
   /**
    * Registers a call to yield with an expression of type [argumentType] as
    * argument.
    */
   TypeInformation registerYield(ast.Node node, TypeInformation argument) {
     YieldTypeInformation info =
-        new YieldTypeInformation(types.currentMember, node);
+        new YieldTypeInformation<ast.Node>(types.currentMember, node);
     info.addAssignment(argument);
     types.allocatedTypes.add(info);
     return info;
   }
 
   /**
    * Registers that [caller] calls [closure] with [arguments].
    *
    * [sideEffects] will be updated to incorporate the potential
    * callees' side effects.
@@ skipping 143 matching lines @@
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }