Refactor strong mode to remove duplicate TypeRules

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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 engine.resolver;
 
 import 'dart:collection';
 
 import '../task/strong/info.dart' show InferredType, StaticInfo;
-import '../task/strong/rules.dart' show TypeRules;
 import 'ast.dart';
 import 'constant.dart';
 import 'element.dart';
 import 'element_resolver.dart';
 import 'engine.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'html.dart' as ht;
 import 'java_core.dart';
 import 'java_engine.dart';
@@ skipping 5764 matching lines @@
    * Type provider, needed for type matching.
    */
   final TypeProvider _typeProvider;
 
   /**
    * The type system in use.
    */
   final TypeSystem _typeSystem;
 
   /**
-   * The DDC type rules, used to create the inference info nodes.
-   */
-  final TypeRules _rules;
-
-  /**
    * A stack of return types for all of the enclosing
    * functions and methods.
    */
   List<DartType> _returnStack = <DartType>[];
 
   InferenceContext._(this._errorListener, TypeProvider typeProvider,
       this._typeSystem, this._inferenceHints)
-      : _typeProvider = typeProvider,
-        _rules = new TypeRules(typeProvider);
+      : _typeProvider = typeProvider;
 
   /**
    * Get the return type of the current enclosing function, if any.
    */
   DartType get returnContext =>
       (_returnStack.isNotEmpty) ? _returnStack.last : null;
 
   /**
    * Match type [t1] against type [t2] as follows.
    * If `t1 = I<dynamic, ..., dynamic>`, then look for a supertype
@@ skipping 20 matching lines @@
    */
   void pushReturnContext(DartType returnType) {
     _returnStack.add(returnType);
   }
 
   /**
    * Place an info node into the error stream indicating that a
    * [type] has been inferred as the type of [node].
    */
   void recordInference(Expression node, DartType type) {
-    StaticInfo info = InferredType.create(_rules, node, type);
+    StaticInfo info = InferredType.create(_typeSystem, node, type);
     if (!_inferenceHints || info == null) {
       return;
     }
     AnalysisError error = info.toAnalysisError();
     _errorListener.onError(error);
   }
 
   List<DartType> _matchTypes(InterfaceType t1, InterfaceType t2) {
     if (t1 == t2) {
       return t2.typeArguments;
@@ skipping 10211 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }