Refactor strong mode to remove duplicate TypeRules

pkg/analyzer/lib/src/task/strong/info.dart

 // Copyright (c) 2015, 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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.info;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
-
-import 'rules.dart';
+import 'package:analyzer/src/generated/type_system.dart';
 
 // A down cast due to a variable declaration to a ground type.  E.g.,
 //   T x = expr;
 // where T is ground.  We exclude non-ground types as these behave differently
 // compared to standard Dart.
 class AssignmentCast extends DownCast {
-  AssignmentCast(TypeRules rules, Expression expression, Cast cast)
+  AssignmentCast(TypeSystem rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   @override
   String get name => 'STRONG_MODE_ASSIGNMENT_CAST';
 
   toErrorCode() => new HintCode(name, message);
 }
 
 // Coercion which casts one type to another
 class Cast extends Coercion {
@@ skipping 16 matching lines @@
 // could not be generated.  The code generator should not see
 // these.
 class CoercionError extends Coercion {
   CoercionError() : super(null, null);
 }
 
 /// Implicitly injected expression conversion.
 abstract class CoercionInfo extends StaticInfo {
   static const String _propertyName = 'dev_compiler.src.info.CoercionInfo';
 
-  final TypeRules rules;
+  final TypeSystem rules;
 
   final Expression node;
 
   CoercionInfo(this.rules, this.node);
 
-  DartType get baseType => rules.getStaticType(node);
+  DartType get baseType => node.staticType ?? DynamicTypeImpl.instance;
   DartType get convertedType;
 
   String get message;
   DartType get staticType => convertedType;
 
   toErrorCode() => new HintCode(name, message);
 
   /// Gets the coercion info associated with this node.
   static CoercionInfo get(AstNode node) => node.getProperty(_propertyName);
 
   /// Sets the coercion info associated with this node.
   static CoercionInfo set(AstNode node, CoercionInfo info) {
     node.setProperty(_propertyName, info);
     return info;
   }
 }
 
 // Base class for all casts from base type to sub type.
 abstract class DownCast extends CoercionInfo {
   Cast _cast;
 
-  DownCast._internal(TypeRules rules, Expression expression, this._cast)
+  DownCast._internal(
+      TypeSystem rules, Expression expression, this._cast)
       : super(rules, expression) {
     assert(_cast.toType != baseType &&
         _cast.fromType == baseType &&
         (baseType.isDynamic ||
             // Call methods make the following non-redundant
             _cast.toType.isSubtypeOf(baseType) ||
             baseType.isAssignableTo(_cast.toType)));
   }
 
   @override List<Object> get arguments => [node, baseType, convertedType];
 
   Cast get cast => _cast;
 
   DartType get convertedType => _cast.toType;
   @override String get message => '{0} ({1}) will need runtime check '
       'to cast to type {2}';
 
   // Factory to create correct DownCast variant.
-  static StaticInfo create(TypeRules rules, Expression expression, Cast cast,
+  static StaticInfo create(
+      StrongTypeSystemImpl rules, Expression expression, Cast cast,
       {String reason}) {
     final fromT = cast.fromType;
     final toT = cast.toType;
 
     // toT <:_R fromT => to <: fromT
     // NB: classes with call methods are subtypes of function
     // types, but the function type is not assignable to the class
     assert(toT.isSubtypeOf(fromT) || fromT.isAssignableTo(toT));
 
     // Handle null call specially.
@@ skipping 14 matching lines @@
       return new UninferredClosure(rules, expression, cast);
     }
     if (expression is InstanceCreationExpression) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
       return new StaticTypeError(rules, expression, toT, reason: reason);
     }
 
     // TODO(vsm): Change this to an assert when we have generic methods and
     // fix TypeRules._coerceTo to disallow implicit sideways casts.
-    if (!rules.isSubTypeOf(toT, fromT)) {
+    if (!rules.isSubtypeOf(toT, fromT)) {
       assert(toT.isSubtypeOf(fromT) || fromT.isAssignableTo(toT));
       return new DownCastComposite(rules, expression, cast);
     }
 
     // Composite cast: these are more likely to fail.
     if (!rules.isGroundType(toT)) {
       // This cast is (probably) due to our different treatment of dynamic.
       // It may be more likely to fail at runtime.
       if (fromT is InterfaceType) {
         // For class types, we'd like to allow non-generic down casts, e.g.,
@@ skipping 23 matching lines @@
     return new DownCastImplicit(rules, expression, cast);
   }
 }
 
 //
 // Implicit down casts.  These are only injected by the compiler by flag.
 //
 // A down cast to a non-ground type.  These behave differently from standard
 // Dart and may be more likely to fail at runtime.
 class DownCastComposite extends DownCast {
-  DownCastComposite(TypeRules rules, Expression expression, Cast cast)
+  DownCastComposite(
+      TypeSystem rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   @override
   String get name => 'STRONG_MODE_DOWN_CAST_COMPOSITE';
 
   toErrorCode() => new StaticTypeWarningCode(name, message);
 }
 
 // A down cast to a non-ground type.  These behave differently from standard
 // Dart and may be more likely to fail at runtime.
 class DownCastImplicit extends DownCast {
-  DownCastImplicit(TypeRules rules, Expression expression, Cast cast)
+  DownCastImplicit(TypeSystem rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   @override
   String get name => 'STRONG_MODE_DOWN_CAST_IMPLICIT';
 
   toErrorCode() => new HintCode(name, message);
 }
 
 // A down cast from dynamic to T.
 class DynamicCast extends DownCast {
-  DynamicCast(TypeRules rules, Expression expression, Cast cast)
+  DynamicCast(TypeSystem rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   @override
   String get name => 'STRONG_MODE_DYNAMIC_CAST';
 
   toErrorCode() => new HintCode(name, message);
 }
 
 class DynamicInvoke extends CoercionInfo {
   static const String _propertyName = 'dev_compiler.src.info.DynamicInvoke';
 
-  DynamicInvoke(TypeRules rules, Expression expression)
+  DynamicInvoke(TypeSystem rules, Expression expression)
       : super(rules, expression);
-  DartType get convertedType => rules.provider.dynamicType;
+  DartType get convertedType => DynamicTypeImpl.instance;
   String get message => '{0} requires dynamic invoke';
 
   @override
   String get name => 'STRONG_MODE_DYNAMIC_INVOKE';
 
   toErrorCode() => new HintCode(name, message);
 
   /// Whether this [node] is the target of a dynamic operation.
   static bool get(AstNode node) {
     var value = node.getProperty(_propertyName);
     return value != null ? value : false;
   }
 
   /// Sets whether this node is the target of a dynamic operation.
   static bool set(AstNode node, bool value) {
     // Free the storage for things that aren't dynamic.
     if (value == false) value = null;
     node.setProperty(_propertyName, value);
     return value;
   }
 }
 
 // The identity coercion
 class Identity extends Coercion {
   Identity(DartType fromType) : super(fromType, fromType);
 }
 
 // Standard / unspecialized inferred type
 class InferredType extends InferredTypeBase {
-  InferredType(TypeRules rules, Expression expression, DartType type)
+  InferredType(TypeSystem rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 
   @override
   String get name => 'STRONG_MODE_INFERRED_TYPE';
 
   // Factory to create correct InferredType variant.
   static InferredTypeBase create(
-      TypeRules rules, Expression expression, DartType type) {
+      TypeSystem rules, Expression expression, DartType type) {
     // Specialized inference:
     if (expression is Literal) {
       return new InferredTypeLiteral(rules, expression, type);
     }
     if (expression is InstanceCreationExpression) {
       return new InferredTypeAllocation(rules, expression, type);
     }
     if (expression is FunctionExpression) {
       return new InferredTypeClosure(rules, expression, type);
     }
     return new InferredType(rules, expression, type);
   }
 }
 
 // An inferred type for a non-literal allocation site.
 class InferredTypeAllocation extends InferredTypeBase {
-  InferredTypeAllocation(TypeRules rules, Expression expression, DartType type)
+  InferredTypeAllocation(
+      TypeSystem rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 
   @override
   String get name => 'STRONG_MODE_INFERRED_TYPE_ALLOCATION';
 }
 
 // An inferred type for the wrapped expression, which may need to be
 // reified into the term
 abstract class InferredTypeBase extends CoercionInfo {
   final DartType _type;
 
-  InferredTypeBase._internal(TypeRules rules, Expression expression, this._type)
+  InferredTypeBase._internal(
+      TypeSystem rules, Expression expression, this._type)
       : super(rules, expression);
 
   @override List get arguments => [node, type];
   DartType get convertedType => type;
   @override String get message => '{0} has inferred type {1}';
   DartType get type => _type;
 
   toErrorCode() => new HintCode(name, message);
 }
 
 // An inferred type for a closure expression
 class InferredTypeClosure extends InferredTypeBase {
-  InferredTypeClosure(TypeRules rules, Expression expression, DartType type)
+  InferredTypeClosure(
+      TypeSystem rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 
   @override
   String get name => 'STRONG_MODE_INFERRED_TYPE_CLOSURE';
 }
 
 // An inferred type for a literal expression.
 class InferredTypeLiteral extends InferredTypeBase {
-  InferredTypeLiteral(TypeRules rules, Expression expression, DartType type)
+  InferredTypeLiteral(
+      TypeSystem rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 
   @override
   String get name => 'STRONG_MODE_INFERRED_TYPE_LITERAL';
 }
 
 class InvalidFieldOverride extends InvalidOverride {
   InvalidFieldOverride(AstNode node, ExecutableElement element,
       InterfaceType base, DartType subType, DartType baseType)
       : super(node, element, base, subType, baseType);
@@ skipping 56 matching lines @@
         ? 'Base class introduces an $lcErrorName'
         : (fromMixin ? 'Mixin introduces an $lcErrorName' : errorName);
     return '$intro. The type of {0}.{1} ({2}) is not a '
         'subtype of {3}.{1} ({4}).';
   }
 }
 
 class InvalidParameterDeclaration extends StaticError {
   final DartType expectedType;
 
-  InvalidParameterDeclaration(
-      TypeRules rules, FormalParameter declaration, this.expectedType)
+  InvalidParameterDeclaration(TypeSystem rules,
+      FormalParameter declaration, this.expectedType)
       : super(declaration);
 
   @override List<Object> get arguments => [node, expectedType];
   @override String get message => 'Type check failed: {0} is not of type {1}';
   @override
   String get name => 'STRONG_MODE_INVALID_PARAMETER_DECLARATION';
 }
 
 /// Dart constructors have one weird quirk, illustrated with this example:
 ///
@@ skipping 31 matching lines @@
       "list (see http://goo.gl/q1T4BB): {0}";
 
   @override
   String get name => 'STRONG_MODE_INVALID_SUPER_INVOCATION';
 }
 
 class InvalidVariableDeclaration extends StaticError {
   final DartType expectedType;
 
   InvalidVariableDeclaration(
-      TypeRules rules, AstNode declaration, this.expectedType)
+      TypeSystem rules, AstNode declaration, this.expectedType)
       : super(declaration);
 
   @override List<Object> get arguments => [expectedType];
   @override String get message => 'Type check failed: null is not of type {0}';
 
   @override
   String get name => 'STRONG_MODE_INVALID_VARIABLE_DECLARATION';
 }
 
 class NonGroundTypeCheckInfo extends StaticInfo {
@@ skipping 74 matching lines @@
   // TODO(jmesserly): review the usage of error codes. We probably want our own,
   // as well as some DDC specific [ErrorType]s.
   ErrorCode toErrorCode();
 }
 
 class StaticTypeError extends StaticError {
   final DartType baseType;
   final DartType expectedType;
   String reason = null;
 
-  StaticTypeError(TypeRules rules, Expression expression, this.expectedType,
+  StaticTypeError(
+      TypeSystem rules, Expression expression, this.expectedType,
       {this.reason})
-      : baseType = rules.getStaticType(expression),
+      : baseType = expression.staticType ?? DynamicTypeImpl.instance,
         super(expression);
 
   @override List<Object> get arguments => [node, baseType, expectedType];
   @override String get message =>
       'Type check failed: {0} ({1}) is not of type {2}' +
           ((reason == null) ? '' : ' because $reason');
 
   @override
   String get name => 'STRONG_MODE_STATIC_TYPE_ERROR';
 }
 
 //
 // Temporary "casts" of allocation sites - literals, constructor invocations,
 // and closures.  These should be handled by contextual inference.  In most
 // cases, inference will be sufficient, though in some it may unmask an actual
 // error: e.g.,
 //   List<int> l = [1, 2, 3]; // Inference succeeds
 //   List<String> l = [1, 2, 3]; // Inference reveals static type error
 // We're marking all as warnings for now.
 //
 // TODO(vsm,leafp): Remove this.
 class UninferredClosure extends DownCast {
-  UninferredClosure(TypeRules rules, FunctionExpression expression, Cast cast)
+  UninferredClosure(
+      TypeSystem rules, FunctionExpression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   @override
   String get name => 'STRONG_MODE_UNINFERRED_CLOSURE';
 
   toErrorCode() => new StaticTypeWarningCode(name, message);
 }