further refactoring: merge RestrictedRules into TypeRules

lib/src/checker/rules.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.
 
 library dev_compiler.src.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 import '../../strong_mode.dart' show StrongModeOptions;
 import '../info.dart';
 import '../utils.dart' as utils;
 
-abstract class TypeRules {
+class TypeRules {
   final TypeProvider provider;
 
   /// Map of fields / properties / methods on Object.
   final Map<String, DartType> objectMembers;
 
-  TypeRules(TypeProvider provider)
+  final StrongModeOptions options;
+  DownwardsInference inferrer;
+
+  TypeRules(TypeProvider provider, {this.options})
       : provider = provider,
-        objectMembers = utils.getObjectMemberMap(provider);
-
-  bool isSubTypeOf(DartType t1, DartType t2);
-  bool isAssignable(DartType t1, DartType t2);
-
-  bool isGroundType(DartType t) => true;
-  // TODO(vsm): The default implementation is not ignoring the return type,
-  // only the restricted override is.
-  bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
-          {bool fuzzyArrows: true, bool ignoreReturn: false}) =>
-      isSubTypeOf(f1, f2);
-
-  StaticInfo checkAssignment(Expression expr, DartType t);
-
-  DartType getStaticType(Expression expr) => expr.staticType;
+        objectMembers = utils.getObjectMemberMap(provider) {
+    inferrer = new DownwardsInference(this);
+  }
 
   /// Given a type t, if t is an interface type with a call method
   /// defined, return the function type for the call method, otherwise
   /// return null.
   FunctionType getCallMethodType(DartType t) {
     if (t is InterfaceType) {
       ClassElement element = t.element;
       InheritanceManager manager = new InheritanceManager(element.library);
       FunctionType callType = manager.lookupMemberType(t, "call");
       return callType;
     }
     return null;
   }
 
   /// Given an expression, return its type assuming it is
   /// in the caller position of a call (that is, accounting
   /// for the possibility of a call method).  Returns null
   /// if expression is not statically callable.
   FunctionType getTypeAsCaller(Expression applicand) {
     var t = getStaticType(applicand);
     if (t is InterfaceType) {
       return getCallMethodType(t);
     }
     if (t is FunctionType) return t;
     return null;
   }
 
-  DartType elementType(Element e);
-
-  bool isDynamicTarget(Expression expr);
-  bool isDynamicCall(Expression call);
-
   /// Gets the expected return type of the given function [body], either from
   /// a normal return/yield, or from a yield*.
   DartType getExpectedReturnType(FunctionBody body, {bool yieldStar: false}) {
     FunctionType functionType;
     var parent = body.parent;
     if (parent is Declaration) {
       functionType = elementType(parent.element);
     } else {
       assert(parent is FunctionExpression);
       functionType = getStaticType(parent);
@@ skipping 32 matching lines @@
     }
     if (type.isDynamic) {
       return type;
     } else if (type is InterfaceType && type.element == expectedType.element) {
       return type.typeArguments[0];
     } else {
       // Malformed type - fallback on analyzer error.
       return null;
     }
   }
-}
-
-class RestrictedRules extends TypeRules {
-  final StrongModeOptions options;
-  DownwardsInference inferrer;
-
-  RestrictedRules(TypeProvider provider, {this.options}) : super(provider) {
-    inferrer = new DownwardsInference(this);
-  }
 
   DartType getStaticType(Expression expr) {
     return expr.staticType ?? provider.dynamicType;
   }
 
   bool _isBottom(DartType t, {bool dynamicIsBottom: false}) {
     if (t.isDynamic && dynamicIsBottom) return true;
     // TODO(vsm): We need direct support for non-nullability in DartType.
     // This should check on "true/nonnullable" Bottom
     if (t.isBottom) return true;
@@ skipping 607 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }