Split ast based parts from InferrerEngineImpl

pkg/compiler/lib/src/types/types.dart

 // Copyright (c) 2012, 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 types;
 
 import '../common.dart' show failedAt;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
@@ skipping 127 matching lines @@
 
   TypeMask get returnType =>
       _isJsInterop ? _dynamic : _inferrer.getReturnTypeOfParameter(_owner);
 
   TypeMask get type =>
       _isJsInterop ? _dynamic : _inferrer.getTypeOfParameter(_owner);
 }
 
 /// Internal data used during type-inference to store intermediate results about
 /// a single element.
-class GlobalTypeInferenceElementData {
+abstract class GlobalTypeInferenceElementData<T> {
+  TypeMask typeOfSend(T node);
+  TypeMask typeOfGetter(T node);
+  TypeMask typeOfOperator(T node);
+
+  void setTypeMask(T node, TypeMask mask);
+
+  void setGetterTypeMaskInComplexSendSet(T node, TypeMask mask);
+
+  void setOperatorTypeMaskInComplexSendSet(T node, TypeMask mask);
+
+  TypeMask typeOfIterator(T node);
+
+  TypeMask typeOfIteratorMoveNext(T node);
+
+  TypeMask typeOfIteratorCurrent(T node);
+
+  void setIteratorTypeMask(T node, TypeMask mask);
+
+  void setMoveNextTypeMask(T node, TypeMask mask);
+
+  void setCurrentTypeMask(T node, TypeMask mask);
+}
+
+class AstGlobalTypeInferenceElementData
+    extends GlobalTypeInferenceElementData<Node> {
   Map<Object, TypeMask> _typeMasks;
 
   TypeMask _get(Object node) => _typeMasks != null ? _typeMasks[node] : null;
   void _set(Object node, TypeMask mask) {
     _typeMasks ??= new Maplet<Object, TypeMask>();
     _typeMasks[node] = mask;
   }
 
-  TypeMask typeOfSend(Send node) => _get(node);
-  TypeMask typeOfGetter(SendSet node) => _get(node.selector);
-  TypeMask typeOfOperator(SendSet node) => _get(node.assignmentOperator);
+  TypeMask typeOfSend(covariant Send node) => _get(node);
+  TypeMask typeOfGetter(covariant SendSet node) => _get(node.selector);
+  TypeMask typeOfOperator(covariant SendSet node) =>
+      _get(node.assignmentOperator);
 
-  void setTypeMask(Send node, TypeMask mask) {
+  void setTypeMask(covariant Send node, TypeMask mask) {
     _set(node, mask);
   }
 
-  void setGetterTypeMaskInComplexSendSet(SendSet node, TypeMask mask) {
+  void setGetterTypeMaskInComplexSendSet(
+      covariant SendSet node, TypeMask mask) {
     _set(node.selector, mask);
   }
 
-  void setOperatorTypeMaskInComplexSendSet(SendSet node, TypeMask mask) {
+  void setOperatorTypeMaskInComplexSendSet(
+      covariant SendSet node, TypeMask mask) {
     _set(node.assignmentOperator, mask);
   }
 
   // TODO(sigmund): clean up. We store data about 3 selectors for "for in"
   // nodes: the iterator, move-next, and current element. Because our map keys
   // are nodes, we need to fabricate different keys to keep these selectors
   // separate. The current implementation does this by using
   // children of the for-in node (these children were picked arbitrarily).
 
-  TypeMask typeOfIterator(ForIn node) => _get(node);
+  TypeMask typeOfIterator(covariant ForIn node) => _get(node);
 
-  TypeMask typeOfIteratorMoveNext(ForIn node) => _get(node.forToken);
+  TypeMask typeOfIteratorMoveNext(covariant ForIn node) => _get(node.forToken);
 
-  TypeMask typeOfIteratorCurrent(ForIn node) => _get(node.inToken);
+  TypeMask typeOfIteratorCurrent(covariant ForIn node) => _get(node.inToken);
 
-  void setIteratorTypeMask(ForIn node, TypeMask mask) {
+  void setIteratorTypeMask(covariant ForIn node, TypeMask mask) {
     _set(node, mask);
   }
 
-  void setMoveNextTypeMask(ForIn node, TypeMask mask) {
+  void setMoveNextTypeMask(covariant ForIn node, TypeMask mask) {
     _set(node.forToken, mask);
   }
 
-  void setCurrentTypeMask(ForIn node, TypeMask mask) {
+  void setCurrentTypeMask(covariant ForIn node, TypeMask mask) {
     _set(node.inToken, mask);
   }
 }
 
 /// API to interact with the global type-inference engine.
 abstract class TypesInferrer {
   void analyzeMain(FunctionEntity element);
   TypeMask getReturnTypeOfMember(MemberElement element);
   TypeMask getReturnTypeOfParameter(ParameterElement element);
   TypeMask getTypeOfMember(MemberElement element);
@@ skipping 94 matching lines @@
     measure(() {
       typesInferrerInternal ??=
           new TypeGraphInferrer(compiler, closedWorld, closedWorldRefiner);
       typesInferrerInternal.analyzeMain(mainElement);
       typesInferrerInternal.clear();
       results =
           new GlobalTypeInferenceResults(typesInferrerInternal, closedWorld);
     });
   }
 }