Roll Observatory packages and add a roll script

packages/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 52 matching lines @@
    * The type representing the type 'int'.
    */
   InterfaceType _intType;
 
   /**
    * The object providing access to the types defined by the language.
    */
   final TypeProvider _typeProvider;
 
   /**
+   * The type system primitives
+   */
+  TypeSystem _typeSystem;
+
+  /**
    * The manager for the inheritance mappings.
    */
   final InheritanceManager _inheritanceManager;
 
   /**
    * A flag indicating whether the visitor is currently within a constructor
    * declaration that is 'const'.
    *
    * See [visitConstructorDeclaration].
    */
@@ skipping 165 matching lines @@
   HashSet<String> _namesForReferenceToDeclaredVariableInInitializer =
       new HashSet<String>();
 
   /**
    * A list of types used by the [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]
    * and [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
 
   /**
+   * If `true`, mixins are allowed to inherit from types other than Object, and
+   * are allowed to reference `super`.
+   */
+  final bool enableSuperMixins;
+
+  /**
    * Initialize a newly created error verifier.
    */
   ErrorVerifier(this._errorReporter, this._currentLibrary, this._typeProvider,
-      this._inheritanceManager) {
+      this._inheritanceManager, this.enableSuperMixins) {
     this._isInSystemLibrary = _currentLibrary.source.isInSystemLibrary;
     this._hasExtUri = _currentLibrary.hasExtUri;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
     _boolType = _typeProvider.boolType;
     _intType = _typeProvider.intType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = _typeProvider.nonSubtypableTypes;
+    _typeSystem = _currentLibrary.context.typeSystem;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     _checkForInvalidAnnotationFromDeferredLibrary(node);
     return super.visitAnnotation(node);
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
@@ skipping 287 matching lines @@
     return super.visitDefaultFormalParameter(node);
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
     _checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
 
   @override
+  Object visitEnumDeclaration(EnumDeclaration node) {
+    ClassElement outerClass = _enclosingClass;
+    try {
+      _isInNativeClass = false;
+      _enclosingClass = node.element;
+      return super.visitEnumDeclaration(node);
+    } finally {
+      _enclosingClass = outerClass;
+    }
+  }
+
+  @override
   Object visitExportDirective(ExportDirective node) {
     ExportElement exportElement = node.element;
     if (exportElement != null) {
       LibraryElement exportedLibrary = exportElement.exportedLibrary;
       _checkForAmbiguousExport(node, exportElement, exportedLibrary);
       _checkForExportDuplicateLibraryName(node, exportElement, exportedLibrary);
       _checkForExportInternalLibrary(node, exportElement);
     }
     return super.visitExportDirective(node);
   }
@@ skipping 261 matching lines @@
       _enclosingFunction = previousFunction;
       _isInStaticMethod = false;
     }
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     SimpleIdentifier methodName = node.methodName;
     if (target != null) {
-      bool isConditional = node.operator.type == sc.TokenType.QUESTION_PERIOD;
-      ClassElement typeReference =
-          ElementResolver.getTypeReference(target, isConditional);
+      ClassElement typeReference = ElementResolver.getTypeReference(target);
       _checkForStaticAccessToInstanceMember(typeReference, methodName);
       _checkForInstanceAccessToStaticMember(typeReference, methodName);
     } else {
       _checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
     }
     return super.visitMethodInvocation(node);
   }
 
   @override
   Object visitNativeClause(NativeClause node) {
@@ skipping 16 matching lines @@
   Object visitPostfixExpression(PostfixExpression node) {
     _checkForAssignmentToFinal(node.operand);
     _checkForIntNotAssignable(node.operand);
     return super.visitPostfixExpression(node);
   }
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.parent is! Annotation) {
       ClassElement typeReference =
-          ElementResolver.getTypeReference(node.prefix, false);
+          ElementResolver.getTypeReference(node.prefix);
       SimpleIdentifier name = node.identifier;
       _checkForStaticAccessToInstanceMember(typeReference, name);
       _checkForInstanceAccessToStaticMember(typeReference, name);
     }
     return super.visitPrefixedIdentifier(node);
   }
 
   @override
   Object visitPrefixExpression(PrefixExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression operand = node.operand;
     if (operatorType == sc.TokenType.BANG) {
       _checkForNonBoolNegationExpression(operand);
     } else if (operatorType.isIncrementOperator) {
       _checkForAssignmentToFinal(operand);
     }
     _checkForIntNotAssignable(operand);
     return super.visitPrefixExpression(node);
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) {
-    bool isConditional = node.operator.type == sc.TokenType.QUESTION_PERIOD;
     ClassElement typeReference =
-        ElementResolver.getTypeReference(node.realTarget, isConditional);
+        ElementResolver.getTypeReference(node.realTarget);
     SimpleIdentifier propertyName = node.propertyName;
     _checkForStaticAccessToInstanceMember(typeReference, propertyName);
     _checkForInstanceAccessToStaticMember(typeReference, propertyName);
     return super.visitPropertyAccess(node);
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     _isInConstructorInitializer = true;
@@ skipping 165 matching lines @@
    * See [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS].
    */
   bool _checkExpectedTwoMapTypeArguments(TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 2) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS, typeArguments,
+        StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS,
+        typeArguments,
         [num]);
     return true;
   }
 
   /**
    * Verify that the given [constructor] declaration does not violate any of the
    * error codes relating to the initialization of fields in the enclosing
    * class.
    *
    * See [_initialFieldElementsMap],
@@ skipping 25 matching lines @@
       if (parameter is FieldFormalParameter) {
         FieldElement fieldElement =
             (parameter.element as FieldFormalParameterElementImpl).field;
         INIT_STATE state = fieldElementsMap[fieldElement];
         if (state == INIT_STATE.NOT_INIT) {
           fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_FIELD_FORMAL;
         } else if (state == INIT_STATE.INIT_IN_DECLARATION) {
           if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR,
-                formalParameter.identifier, [fieldElement.displayName]);
+                formalParameter.identifier,
+                [fieldElement.displayName]);
             foundError = true;
           }
         } else if (state == INIT_STATE.INIT_IN_FIELD_FORMAL) {
           if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES,
-                formalParameter.identifier, [fieldElement.displayName]);
+                formalParameter.identifier,
+                [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     // Visit all of the initializers
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
     for (ConstructorInitializer constructorInitializer in initializers) {
       if (constructorInitializer is RedirectingConstructorInvocation) {
         return false;
@@ skipping 16 matching lines @@
               foundError = true;
             }
           } else if (state == INIT_STATE.INIT_IN_FIELD_FORMAL) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER,
                 fieldName);
             foundError = true;
           } else if (state == INIT_STATE.INIT_IN_INITIALIZERS) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
-                fieldName, [fieldElement.displayName]);
+                fieldName,
+                [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     // Prepare a list of not initialized fields.
     List<FieldElement> notInitFinalFields = <FieldElement>[];
     fieldElementsMap.forEach((FieldElement fieldElement, INIT_STATE state) {
       if (state == INIT_STATE.NOT_INIT) {
         if (fieldElement.isFinal) {
           notInitFinalFields.add(fieldElement);
         }
       }
     });
     // Visit all of the states in the map to ensure that none were never
     // initialized.
     fieldElementsMap.forEach((FieldElement fieldElement, INIT_STATE state) {
       if (state == INIT_STATE.NOT_INIT) {
         if (fieldElement.isConst) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.CONST_NOT_INITIALIZED,
-              constructor.returnType, [fieldElement.name]);
+              constructor.returnType,
+              [fieldElement.name]);
           foundError = true;
         }
       }
     });
     if (notInitFinalFields.isNotEmpty) {
       foundError = true;
       AnalysisErrorWithProperties analysisError;
       if (notInitFinalFields.length == 1) {
         analysisError = _errorReporter.newErrorWithProperties(
             StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_1,
-            constructor.returnType, [notInitFinalFields[0].name]);
+            constructor.returnType,
+            [notInitFinalFields[0].name]);
       } else if (notInitFinalFields.length == 2) {
         analysisError = _errorReporter.newErrorWithProperties(
             StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_2,
-            constructor.returnType, [
-          notInitFinalFields[0].name,
-          notInitFinalFields[1].name
-        ]);
+            constructor.returnType,
+            [notInitFinalFields[0].name, notInitFinalFields[1].name]);
       } else {
         analysisError = _errorReporter.newErrorWithProperties(
             StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_3_PLUS,
             constructor.returnType, [
           notInitFinalFields[0].name,
           notInitFinalFields[1].name,
           notInitFinalFields.length - 2
         ]);
       }
       analysisError.setProperty(
@@ skipping 16 matching lines @@
    * [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE], and
    * [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES].
    */
   bool _checkForAllInvalidOverrideErrorCodes(
       ExecutableElement executableElement,
-      ExecutableElement overriddenExecutable, List<ParameterElement> parameters,
-      List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
+      ExecutableElement overriddenExecutable,
+      List<ParameterElement> parameters,
+      List<AstNode> parameterLocations,
+      SimpleIdentifier errorNameTarget) {
     bool isGetter = false;
     bool isSetter = false;
     if (executableElement is PropertyAccessorElement) {
       PropertyAccessorElement accessorElement = executableElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
     String executableElementName = executableElement.name;
     FunctionType overridingFT = executableElement.type;
     FunctionType overriddenFT = overriddenExecutable.type;
@@ skipping 40 matching lines @@
         _errorReporter.reportErrorForNode(
             StaticWarningCode.INVALID_OVERRIDE_NAMED, errorNameTarget, [
           overriddenParamName,
           overriddenExecutable.enclosingElement.displayName
         ]);
         return true;
       }
     }
     // SWC.INVALID_METHOD_OVERRIDE_RETURN_TYPE
     if (overriddenFTReturnType != VoidTypeImpl.instance &&
-        !overridingFTReturnType.isAssignableTo(overriddenFTReturnType)) {
-      _errorReporter.reportTypeErrorForNode(!isGetter
+        !_typeSystem.isAssignableTo(
+            overridingFTReturnType, overriddenFTReturnType)) {
+      _errorReporter.reportTypeErrorForNode(
+          !isGetter
               ? StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE
               : StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE,
-          errorNameTarget, [
+          errorNameTarget,
+          [
         overridingFTReturnType,
         overriddenFTReturnType,
         overriddenExecutable.enclosingElement.displayName
       ]);
       return true;
     }
     // SWC.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
     if (parameterLocations == null) {
       return false;
     }
     int parameterIndex = 0;
     for (int i = 0; i < overridingNormalPT.length; i++) {
-      if (!overridingNormalPT[i].isAssignableTo(overriddenNormalPT[i])) {
-        _errorReporter.reportTypeErrorForNode(!isSetter
+      if (!_typeSystem.isAssignableTo(
+          overridingNormalPT[i], overriddenNormalPT[i])) {
+        _errorReporter.reportTypeErrorForNode(
+            !isSetter
                 ? StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
                 : StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE,
-            parameterLocations[parameterIndex], [
+            parameterLocations[parameterIndex],
+            [
           overridingNormalPT[i],
           overriddenNormalPT[i],
           overriddenExecutable.enclosingElement.displayName
         ]);
         return true;
       }
       parameterIndex++;
     }
     // SWC.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
     for (int i = 0; i < overriddenPositionalPT.length; i++) {
-      if (!overridingPositionalPT[i]
-          .isAssignableTo(overriddenPositionalPT[i])) {
+      if (!_typeSystem.isAssignableTo(
+          overridingPositionalPT[i], overriddenPositionalPT[i])) {
         _errorReporter.reportTypeErrorForNode(
             StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE,
             parameterLocations[parameterIndex], [
           overridingPositionalPT[i],
           overriddenPositionalPT[i],
           overriddenExecutable.enclosingElement.displayName
         ]);
         return true;
       }
       parameterIndex++;
     }
     // SWC.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE &
     // SWC.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
     for (String overriddenName in overriddenNamedPT.keys) {
       DartType overridingType = overridingNamedPT[overriddenName];
       if (overridingType == null) {
         // Error, this is never reached- INVALID_OVERRIDE_NAMED would have been
         // created above if this could be reached.
         continue;
       }
       DartType overriddenType = overriddenNamedPT[overriddenName];
-      if (!overriddenType.isAssignableTo(overridingType)) {
+      if (!_typeSystem.isAssignableTo(overriddenType, overridingType)) {
         // lookup the parameter for the error to select
         ParameterElement parameterToSelect = null;
         AstNode parameterLocationToSelect = null;
         for (int i = 0; i < parameters.length; i++) {
           ParameterElement parameter = parameters[i];
           if (parameter.parameterKind == ParameterKind.NAMED &&
               overriddenName == parameter.name) {
             parameterToSelect = parameter;
             parameterLocationToSelect = parameterLocations[i];
             break;
@@ skipping 125 matching lines @@
   /**
    * Check the given [executableElement] against override-error codes. This
    * method computes the given executableElement is overriding and calls
    * [_checkForAllInvalidOverrideErrorCodes] when the [InheritanceManager]
    * returns a [MultiplyInheritedExecutableElement], this method loops through
    * the list in the [MultiplyInheritedExecutableElement]. The [parameters] are
    * the parameters of the executable element. The [errorNameTarget] is the node
    * to report problems on.
    */
   bool _checkForAllInvalidOverrideErrorCodesForExecutable(
-      ExecutableElement executableElement, List<ParameterElement> parameters,
-      List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
+      ExecutableElement executableElement,
+      List<ParameterElement> parameters,
+      List<AstNode> parameterLocations,
+      SimpleIdentifier errorNameTarget) {
     //
     // Compute the overridden executable from the InheritanceManager
     //
     List<ExecutableElement> overriddenExecutables = _inheritanceManager
         .lookupOverrides(_enclosingClass, executableElement.name);
     if (_checkForInstanceMethodNameCollidesWithSuperclassStatic(
         executableElement, errorNameTarget)) {
       return true;
     }
     for (ExecutableElement overriddenElement in overriddenExecutables) {
@@ skipping 92 matching lines @@
         problemReported = true;
       } else {
         ClassElement mixinElement = (mixinType as InterfaceType).element;
         if (_checkForExtendsOrImplementsDeferredClass(
             mixinName, CompileTimeErrorCode.MIXIN_DEFERRED_CLASS)) {
           problemReported = true;
         }
         if (_checkForMixinDeclaresConstructor(mixinName, mixinElement)) {
           problemReported = true;
         }
-        if (_checkForMixinInheritsNotFromObject(mixinName, mixinElement)) {
+        if (!enableSuperMixins &&
+            _checkForMixinInheritsNotFromObject(mixinName, mixinElement)) {
           problemReported = true;
         }
         if (_checkForMixinReferencesSuper(mixinName, mixinElement)) {
           problemReported = true;
         }
       }
     }
     return problemReported;
   }
 
@@ skipping 30 matching lines @@
         //
         // Prepare the constructor name
         //
         String constructorStrName = constructorTypeName.name.name;
         if (redirectedConstructor.name != null) {
           constructorStrName += ".${redirectedConstructor.name.name}";
         }
         ErrorCode errorCode = (declaration.constKeyword != null
             ? CompileTimeErrorCode.REDIRECT_TO_MISSING_CONSTRUCTOR
             : StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
-        _errorReporter.reportErrorForNode(errorCode, redirectedConstructor, [
-          constructorStrName,
-          redirectedType.displayName
-        ]);
+        _errorReporter.reportErrorForNode(errorCode, redirectedConstructor,
+            [constructorStrName, redirectedType.displayName]);
         return true;
       }
       return false;
     }
     FunctionType redirectedType = redirectedElement.type;
     DartType redirectedReturnType = redirectedType.returnType;
     //
     // Report specific problem when return type is incompatible
     //
     FunctionType constructorType = declaration.element.type;
     DartType constructorReturnType = constructorType.returnType;
-    if (!redirectedReturnType.isAssignableTo(constructorReturnType)) {
+    if (!_typeSystem.isAssignableTo(
+        redirectedReturnType, constructorReturnType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE,
-          redirectedConstructor, [redirectedReturnType, constructorReturnType]);
+          redirectedConstructor,
+          [redirectedReturnType, constructorReturnType]);
       return true;
     }
     //
     // Check parameters
     //
-    if (!redirectedType.isSubtypeOf(constructorType)) {
+    if (!_typeSystem.isSubtypeOf(redirectedType, constructorType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE,
-          redirectedConstructor, [redirectedType, constructorType]);
+          redirectedConstructor,
+          [redirectedType, constructorType]);
       return true;
     }
     return false;
   }
 
   /**
    * Check that the return [statement] of the form <i>return e;</i> is not in a
    * generative constructor.
    *
    * Check that return statements without expressions are not in a generative
@@ skipping 22 matching lines @@
         return false;
       }
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR,
           returnExpression);
       return true;
     }
     // RETURN_WITHOUT_VALUE
     if (returnExpression == null) {
       if (_inGenerator ||
-          _computeReturnTypeForMethod(null)
-              .isAssignableTo(expectedReturnType)) {
+          _typeSystem.isAssignableTo(
+              _computeReturnTypeForMethod(null), expectedReturnType)) {
         return false;
       }
       _hasReturnWithoutValue = true;
       _errorReporter.reportErrorForNode(
           StaticWarningCode.RETURN_WITHOUT_VALUE, statement);
       return true;
     } else if (_inGenerator) {
       // RETURN_IN_GENERATOR
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.RETURN_IN_GENERATOR, statement);
@@ skipping 17 matching lines @@
       return false;
     }
     // check exported names
     Namespace namespace =
         new NamespaceBuilder().createExportNamespaceForDirective(exportElement);
     Map<String, Element> definedNames = namespace.definedNames;
     for (String name in definedNames.keys) {
       Element element = definedNames[name];
       Element prevElement = _exportedElements[name];
       if (element != null && prevElement != null && prevElement != element) {
-        _errorReporter.reportErrorForNode(CompileTimeErrorCode.AMBIGUOUS_EXPORT,
-            directive, [
+        _errorReporter.reportErrorForNode(
+            CompileTimeErrorCode.AMBIGUOUS_EXPORT, directive, [
           name,
           prevElement.library.definingCompilationUnit.displayName,
           element.library.definingCompilationUnit.displayName
         ]);
         return true;
       } else {
         _exportedElements[name] = element;
       }
     }
     return false;
   }
 
   /**
    * Verify that the given [expression] can be assigned to its corresponding
    * parameters. The [expectedStaticType] is the expected static type of the
    * parameter. The [actualStaticType] is the actual static type of the
    * argument.
    *
    * This method corresponds to
    * [BestPracticesVerifier.checkForArgumentTypeNotAssignable].
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
-  bool _checkForArgumentTypeNotAssignable(Expression expression,
-      DartType expectedStaticType, DartType actualStaticType,
+  bool _checkForArgumentTypeNotAssignable(
+      Expression expression,
+      DartType expectedStaticType,
+      DartType actualStaticType,
       ErrorCode errorCode) {
     //
     // Warning case: test static type information
     //
     if (actualStaticType != null && expectedStaticType != null) {
-      if (!actualStaticType.isAssignableTo(expectedStaticType)) {
+      if (!_typeSystem.isAssignableTo(actualStaticType, expectedStaticType)) {
         _errorReporter.reportTypeErrorForNode(
             errorCode, expression, [actualStaticType, expectedStaticType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify that the given [argument] can be assigned to its corresponding
@@ skipping 24 matching lines @@
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableWithExpectedTypes(
-      Expression expression, DartType expectedStaticType,
-      ErrorCode errorCode) => _checkForArgumentTypeNotAssignable(
+          Expression expression,
+          DartType expectedStaticType,
+          ErrorCode errorCode) =>
+      _checkForArgumentTypeNotAssignable(
           expression, expectedStaticType, getStaticType(expression), errorCode);
 
   /**
    * Verify that the arguments in the given [argumentList] can be assigned to
    * their corresponding parameters.
    *
    * This method corresponds to
    * [BestPracticesVerifier.checkForArgumentTypesNotAssignableInList].
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
@@ skipping 20 matching lines @@
    */
   bool _checkForAssignability(Expression expression, InterfaceType type,
       ErrorCode errorCode, List<Object> arguments) {
     if (expression == null) {
       return false;
     }
     DartType expressionType = expression.staticType;
     if (expressionType == null) {
       return false;
     }
-    if (expressionType.isAssignableTo(type)) {
+    if (_typeSystem.isAssignableTo(expressionType, type)) {
       return false;
     }
     _errorReporter.reportErrorForNode(errorCode, expression, arguments);
     return true;
   }
 
   /**
    * Verify that the given [expression] is not final.
    *
    * See [StaticWarningCode.ASSIGNMENT_TO_CONST],
@@ skipping 23 matching lines @@
       if (element.isConst) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.ASSIGNMENT_TO_CONST, expression);
         return true;
       }
       if (element.isFinal) {
         if (element is FieldElementImpl &&
             element.setter == null &&
             element.isSynthetic) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER, highlightedNode,
+              StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER,
+              highlightedNode,
               [element.name, element.enclosingElement.displayName]);
           return true;
         }
         _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FINAL,
             highlightedNode, [element.name]);
         return true;
       }
       return false;
     }
     if (element is FunctionElement) {
@@ skipping 114 matching lines @@
             memberName, _currentLibrary);
       } else if (method.isSetter) {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteSetter(
             memberName, _currentLibrary);
       } else {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteMethod(
             memberName, _currentLibrary);
       }
       if (overriddenMember == null) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, nameNode, [
-          memberName,
-          _enclosingClass.displayName
-        ]);
+            StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
+            nameNode,
+            [memberName, _enclosingClass.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify all possible conflicts of the given [constructor]'s name with other
    * constructors and members of the same class. The [constructorElement] is the
    * constructor's element.
@@ skipping 14 matching lines @@
     for (ConstructorElement otherConstructor in constructors) {
       if (identical(otherConstructor, constructorElement)) {
         continue;
       }
       if (name == otherConstructor.name) {
         if (name == null || name.length == 0) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, constructor);
         } else {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, constructor,
+              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME,
+              constructor,
               [name]);
         }
         return true;
       }
     }
     // conflict with class member
     if (constructorName != null &&
         constructorElement != null &&
         !constructorName.isSynthetic) {
       // fields
       FieldElement field = classElement.getField(name);
       if (field != null) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD,
-            constructor, [name]);
+            constructor,
+            [name]);
         return true;
       }
       // methods
       MethodElement method = classElement.getMethod(name);
       if (method != null) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD,
-            constructor, [name]);
+            constructor,
+            [name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify that the [_enclosingClass] does not have a method and getter pair
    * with the same name on, via inheritance.
    *
    * See [CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD], and
    * [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER].
    */
   bool _checkForConflictingGetterAndMethod() {
     if (_enclosingClass == null) {
       return false;
     }
     bool hasProblem = false;
     // method declared in the enclosing class vs. inherited getter
     for (MethodElement method in _enclosingClass.methods) {
       String name = method.name;
       // find inherited property accessor (and can be only getter)
       ExecutableElement inherited =
           _inheritanceManager.lookupInheritance(_enclosingClass, name);
       if (inherited is! PropertyAccessorElement) {
         continue;
       }
       // report problem
       hasProblem = true;
-      _errorReporter.reportErrorForOffset(
-          CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD, method.nameOffset,
-          name.length, [
+      _errorReporter.reportErrorForElement(
+          CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD, method, [
         _enclosingClass.displayName,
         inherited.enclosingElement.displayName,
         name
       ]);
     }
     // getter declared in the enclosing class vs. inherited method
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (!accessor.isGetter) {
         continue;
       }
       String name = accessor.name;
       // find inherited method
       ExecutableElement inherited =
           _inheritanceManager.lookupInheritance(_enclosingClass, name);
       if (inherited is! MethodElement) {
         continue;
       }
       // report problem
       hasProblem = true;
-      _errorReporter.reportErrorForOffset(
-          CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER,
-          accessor.nameOffset, name.length, [
+      _errorReporter.reportErrorForElement(
+          CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER, accessor, [
         _enclosingClass.displayName,
         inherited.enclosingElement.displayName,
         name
       ]);
     }
     // done
     return hasProblem;
   }
 
   /**
@@ skipping 45 matching lines @@
       }
       // prepare "super" type to report its name
       ClassElement superElementClass =
           superElement.enclosingElement as ClassElement;
       InterfaceType superElementType = superElementClass.type;
       // report problem
       hasProblem = true;
       if (getter) {
         _errorReporter.reportErrorForElement(
             StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER,
-            accessor, [superElementType.displayName]);
+            accessor,
+            [superElementType.displayName]);
       } else {
         _errorReporter.reportErrorForElement(
             StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER,
-            accessor, [superElementType.displayName]);
+            accessor,
+            [superElementType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   /**
    * Verify that the enclosing class does not have a setter with the same name
    * as the given instance method declaration.
    *
@@ skipping 61 matching lines @@
             addThisMemberToTheMap = false;
           }
         } else if (isSetter) {
           String methodName = name.name;
           ClassMember conflictingMethod = memberHashMap[methodName];
           if (conflictingMethod != null &&
               conflictingMethod is MethodDeclaration &&
               !conflictingMethod.isGetter) {
             // report problem
             _errorReporter.reportErrorForNode(
-                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2, name, [
-              _enclosingClass.displayName,
-              name.name
-            ]);
+                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2,
+                name,
+                [_enclosingClass.displayName, name.name]);
             foundError = true;
             addThisMemberToTheMap = false;
           }
         }
         // Finally, add this member into the HashMap.
         if (addThisMemberToTheMap) {
           if (method.isSetter) {
             memberHashMap["${name.name}="] = method;
           } else {
             memberHashMap[name.name] = method;
@@ skipping 35 matching lines @@
     // OK, also static
     if (setter.isStatic) {
       return false;
     }
     // prepare "setter" type to report its name
     ClassElement setterClass = setter.enclosingElement as ClassElement;
     InterfaceType setterType = setterClass.type;
     // report problem
     _errorReporter.reportErrorForNode(
         StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER,
-        nameNode, [setterType.displayName]);
+        nameNode,
+        [setterType.displayName]);
     return true;
   }
 
   /**
    * Verify that the enclosing class does not have an instance member with the
    * same name as the given static [method] declaration.
    *
    * See [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER].
    */
   bool _checkForConflictingStaticSetterAndInstanceMember(
@@ skipping 27 matching lines @@
     // OK, also static
     if (member.isStatic) {
       return false;
     }
     // prepare "member" type to report its name
     ClassElement memberClass = member.enclosingElement as ClassElement;
     InterfaceType memberType = memberClass.type;
     // report problem
     _errorReporter.reportErrorForNode(
         StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER,
-        nameNode, [memberType.displayName]);
+        nameNode,
+        [memberType.displayName]);
     return true;
   }
 
   /**
    * Verify all conflicts between type variable and enclosing class.
    * TODO(scheglov)
    *
    * See [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS], and
    * [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER].
    */
   bool _checkForConflictingTypeVariableErrorCodes(
       ClassDeclaration declaration) {
     bool problemReported = false;
     for (TypeParameterElement typeParameter in _enclosingClass.typeParameters) {
       String name = typeParameter.name;
       // name is same as the name of the enclosing class
       if (_enclosingClass.name == name) {
-        _errorReporter.reportErrorForOffset(
+        _errorReporter.reportErrorForElement(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS,
-            typeParameter.nameOffset, name.length, [name]);
+            typeParameter,
+            [name]);
         problemReported = true;
       }
       // check members
       if (_enclosingClass.getMethod(name) != null ||
           _enclosingClass.getGetter(name) != null ||
           _enclosingClass.getSetter(name) != null) {
-        _errorReporter.reportErrorForOffset(
+        _errorReporter.reportErrorForElement(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER,
-            typeParameter.nameOffset, name.length, [name]);
+            typeParameter,
+            [name]);
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
    * Verify that if the given [constructor] declaration is 'const' then there
    * are no invocations of non-'const' super constructors.
    *
@@ skipping 18 matching lines @@
     // try to find and check super constructor invocation
     for (ConstructorInitializer initializer in constructor.initializers) {
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation superInvocation = initializer;
         ConstructorElement element = superInvocation.staticElement;
         if (element == null || element.isConst) {
           return false;
         }
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
-            superInvocation, [element.enclosingElement.displayName]);
+            superInvocation,
+            [element.enclosingElement.displayName]);
         return true;
       }
     }
     // no explicit super constructor invocation, check default constructor
     InterfaceType supertype = _enclosingClass.supertype;
     if (supertype == null) {
       return false;
     }
     if (supertype.isObject) {
       return false;
     }
     ConstructorElement unnamedConstructor =
         supertype.element.unnamedConstructor;
     if (unnamedConstructor == null) {
       return false;
     }
     if (unnamedConstructor.isConst) {
       return false;
     }
     // default constructor is not 'const', report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
-        constructor.returnType, [supertype.displayName]);
+        constructor.returnType,
+        [supertype.displayName]);
     return true;
   }
 
   /**
    * Verify that if the given [constructor] declaration is 'const' then there
    * are no non-final instance variable. The [constructorElement] is the
    * constructor element.
    *
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD].
    */
@@ skipping 20 matching lines @@
    * creating a deferred type. The [constructorName] is the constructor name,
    * always non-`null`. The [typeName] is the name of the type defining the
    * constructor, always non-`null`.
    *
    * See [CompileTimeErrorCode.CONST_DEFERRED_CLASS].
    */
   bool _checkForConstDeferredClass(InstanceCreationExpression expression,
       ConstructorName constructorName, TypeName typeName) {
     if (typeName.isDeferred) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_DEFERRED_CLASS, constructorName,
+          CompileTimeErrorCode.CONST_DEFERRED_CLASS,
+          constructorName,
           [typeName.name.name]);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given throw [expression] is not enclosed in a 'const'
    * constructor declaration.
    *
@@ skipping 26 matching lines @@
    * Verify that the given instance creation [expression] is not being invoked
    * on an abstract class. The [typeName] is the [TypeName] of the
    * [ConstructorName] from the [InstanceCreationExpression], this is the AST
    * node that the error is attached to. The [type] is the type being
    * constructed with this [InstanceCreationExpression].
    *
    * See [StaticWarningCode.CONST_WITH_ABSTRACT_CLASS], and
    * [StaticWarningCode.NEW_WITH_ABSTRACT_CLASS].
    */
   bool _checkForConstOrNewWithAbstractClass(
-      InstanceCreationExpression expression, TypeName typeName,
+      InstanceCreationExpression expression,
+      TypeName typeName,
       InterfaceType type) {
     if (type.element.isAbstract) {
       ConstructorElement element = expression.staticElement;
       if (element != null && !element.isFactory) {
         if ((expression.keyword as sc.KeywordToken).keyword ==
             sc.Keyword.CONST) {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName);
         } else {
           _errorReporter.reportErrorForNode(
@@ skipping 83 matching lines @@
    * constructor name, always non-`null`. The [typeName] is the name of the type
    * defining the constructor, always non-`null`.
    *
    * This method assumes that the instance creation was tested to be 'const'
    * before being called.
    *
    * See [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR], and
    * [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT].
    */
   bool _checkForConstWithUndefinedConstructor(
-      InstanceCreationExpression expression, ConstructorName constructorName,
+      InstanceCreationExpression expression,
+      ConstructorName constructorName,
       TypeName typeName) {
     // OK if resolved
     if (expression.staticElement != null) {
       return false;
     }
     DartType type = typeName.type;
     if (type is InterfaceType) {
       ClassElement element = type.element;
       if (element != null && element.isEnum) {
         // We have already reported the error.
         return false;
       }
     }
     Identifier className = typeName.name;
     // report as named or default constructor absence
     SimpleIdentifier name = constructorName.name;
     if (name != null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR, name, [
-        className,
-        name
-      ]);
+          CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR,
+          name,
+          [className, name]);
     } else {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
-          constructorName, [className]);
+          constructorName,
+          [className]);
     }
     return true;
   }
 
   /**
    * Verify that there are no default parameters in the given function type
    * [alias].
    *
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS].
    */
@@ skipping 128 matching lines @@
     // determine the display name, use the extended display name if the
     // enclosing class of the inherited member is in a different source
     String displayName;
     Element enclosingElement = inheritedMember.enclosingElement;
     if (enclosingElement.source == _enclosingClass.source) {
       displayName = enclosingElement.displayName;
     } else {
       displayName = enclosingElement.getExtendedDisplayName(null);
     }
     // report problem
-    _errorReporter.reportErrorForOffset(
+    _errorReporter.reportErrorForElement(
         CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE,
-        staticMember.nameOffset, name.length, [name, displayName]);
+        staticMember,
+        [name, displayName]);
     return true;
   }
 
   /**
    * Verify that if the given list [literal] has type arguments then there is
    * exactly one. The [typeArguments] are the type arguments.
    *
    * See [StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS].
    */
   bool _checkForExpectedOneListTypeArgument(
       ListLiteral literal, TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 1) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS, typeArguments,
+        StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS,
+        typeArguments,
         [num]);
     return true;
   }
 
   /**
    * Verify that the given export [directive] has a unique name among other
    * exported libraries. The [exportElement] is the [ExportElement] retrieved
    * from the node, if the element in the node was `null`, then this method is
    * not called. The [exportedLibrary] is the library element containing the
    * exported element.
    *
    * See [CompileTimeErrorCode.EXPORT_DUPLICATED_LIBRARY_NAME].
    */
   bool _checkForExportDuplicateLibraryName(ExportDirective directive,
       ExportElement exportElement, LibraryElement exportedLibrary) {
     if (exportedLibrary == null) {
       return false;
     }
     String name = exportedLibrary.name;
     // check if there is other exported library with the same name
     LibraryElement prevLibrary = _nameToExportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != exportedLibrary) {
-        if (name.isEmpty) {
-          _errorReporter.reportErrorForNode(
-              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_UNNAMED, directive, [
-            prevLibrary.definingCompilationUnit.displayName,
-            exportedLibrary.definingCompilationUnit.displayName
-          ]);
-        } else {
+        if (!name.isEmpty) {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAMED, directive, [
             prevLibrary.definingCompilationUnit.displayName,
             exportedLibrary.definingCompilationUnit.displayName,
             name
           ]);
         }
         return true;
       }
     } else {
@@ skipping 21 matching lines @@
     String uri = exportElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, directive,
+        CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY,
+        directive,
         [directive.uri]);
     return true;
   }
 
   /**
    * Verify that the given extends [clause] does not extend a deferred class.
    *
    * See [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS].
    */
   bool _checkForExtendsDeferredClass(ExtendsClause clause) {
@@ skipping 80 matching lines @@
    * [_checkForAllMixinErrorCodes],
    * [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS],
    * [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS], and
    * [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS].
    */
   bool _checkForExtendsOrImplementsDisallowedClass(
       TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic) {
       return false;
     }
+    // The SDK implementation may implement disallowed types. For example,
+    // JSNumber in dart2js and _Smi in Dart VM both implement int.
+    if (_currentLibrary.source.isInSystemLibrary) {
+      return false;
+    }
     DartType superType = typeName.type;
     for (InterfaceType disallowedType
         in _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT) {
       if (superType != null && superType == disallowedType) {
         // if the violating type happens to be 'num', we need to rule out the
         // case where the enclosing class is 'int' or 'double'
         if (superType == _typeProvider.numType) {
           AstNode grandParent = typeName.parent.parent;
           // Note: this is a corner case that won't happen often, so adding a
           // field currentClass (see currentFunction) to ErrorVerifier isn't
@@ skipping 39 matching lines @@
     // prepare expression type
     Expression expression = initializer.expression;
     if (expression == null) {
       return false;
     }
     // test the static type of the expression
     DartType staticType = getStaticType(expression);
     if (staticType == null) {
       return false;
     }
-    if (staticType.isAssignableTo(fieldType)) {
+    if (_typeSystem.isAssignableTo(staticType, fieldType)) {
       return false;
     }
     // report problem
     if (_isEnclosingConstructorConst) {
       // TODO(paulberry): this error should be based on the actual type of the
       // constant, not the static type.  See dartbug.com/21119.
       _errorReporter.reportTypeErrorForNode(
           CheckedModeCompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE,
-          expression, [staticType, fieldType]);
+          expression,
+          [staticType, fieldType]);
     }
     _errorReporter.reportTypeErrorForNode(
-        StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [
-      staticType,
-      fieldType
-    ]);
+        StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE,
+        expression,
+        [staticType, fieldType]);
     return true;
     // TODO(brianwilkerson) Define a hint corresponding to these errors and
     // report it if appropriate.
 //        // test the propagated type of the expression
 //        Type propagatedType = expression.getPropagatedType();
 //        if (propagatedType != null && propagatedType.isAssignableTo(fieldType)) {
 //          return false;
 //        }
 //        // report problem
 //        if (isEnclosingConstructorConst) {
@@ skipping 59 matching lines @@
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     if (!list.isSynthetic) {
       NodeList<VariableDeclaration> variables = list.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           if (list.isConst) {
             _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name,
+                CompileTimeErrorCode.CONST_NOT_INITIALIZED,
+                variable.name,
                 [variable.name.name]);
           } else if (list.isFinal) {
             _errorReporter.reportErrorForNode(
-                StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name,
+                StaticWarningCode.FINAL_NOT_INITIALIZED,
+                variable.name,
                 [variable.name.name]);
           }
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
@@ skipping 28 matching lines @@
    * respectively.  If not, report the error using [returnType].
    */
   void _checkForIllegalReturnType(TypeName returnType) {
     if (returnType == null) {
       // No declared return type, so the return type must be dynamic, which is
       // assignable to everything.
       return;
     }
     if (_enclosingFunction.isAsynchronous) {
       if (_enclosingFunction.isGenerator) {
-        if (!_enclosingFunction.returnType
-            .isAssignableTo(_typeProvider.streamDynamicType)) {
+        if (!_typeSystem.isAssignableTo(
+            _enclosingFunction.returnType, _typeProvider.streamDynamicType)) {
           _errorReporter.reportErrorForNode(
               StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE,
               returnType);
         }
       } else {
-        if (!_enclosingFunction.returnType
-            .isAssignableTo(_typeProvider.futureDynamicType)) {
+        if (!_typeSystem.isAssignableTo(
+            _enclosingFunction.returnType, _typeProvider.futureDynamicType)) {
           _errorReporter.reportErrorForNode(
               StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE, returnType);
         }
       }
     } else if (_enclosingFunction.isGenerator) {
-      if (!_enclosingFunction.returnType
-          .isAssignableTo(_typeProvider.iterableDynamicType)) {
+      if (!_typeSystem.isAssignableTo(
+          _enclosingFunction.returnType, _typeProvider.iterableDynamicType)) {
         _errorReporter.reportErrorForNode(
             StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE,
             returnType);
       }
     }
   }
 
   /**
    * Verify that the given implements [clause] does not implement classes that
    * are deferred.
@@ skipping 121 matching lines @@
     // prepare imported library
     LibraryElement nodeLibrary = importElement.importedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
     // check if there is another imported library with the same name
     LibraryElement prevLibrary = _nameToImportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
-        if (name.isEmpty) {
-          _errorReporter.reportErrorForNode(
-              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_UNNAMED, directive, [
-            prevLibrary.definingCompilationUnit.displayName,
-            nodeLibrary.definingCompilationUnit.displayName
-          ]);
-        } else {
+        if (!name.isEmpty) {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAMED, directive, [
             prevLibrary.definingCompilationUnit.displayName,
             nodeLibrary.definingCompilationUnit.displayName,
             name
           ]);
         }
         return true;
       }
     } else {
@@ skipping 21 matching lines @@
     String uri = importElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, directive,
+        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
+        directive,
         [directive.uri]);
     return true;
   }
 
   /**
    * For each class declaration, this method is called which verifies that all
    * inherited members are inherited consistently.
    *
    * See [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE].
    */
@@ skipping 38 matching lines @@
     // OK, top-level element
     if (executableElement.enclosingElement is! ClassElement) {
       return false;
     }
     // OK, instance member
     if (!executableElement.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name,
+        StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER,
+        name,
         [name.name]);
     return true;
   }
 
   /**
    * Check whether the given [executableElement] collides with the name of a
    * static method in one of its superclasses, and reports the appropriate
    * warning if it does. The [errorNameTarget] is the node to report problems
    * on.
    *
@@ skipping 20 matching lines @@
         if (fieldElt != null) {
           // Ignore if private in a different library - cannot collide.
           if (executableElementPrivate &&
               _currentLibrary != superclassLibrary) {
             continue;
           }
           // instance vs. static
           if (fieldElt.isStatic) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC,
-                errorNameTarget, [
-              executableElementName,
-              fieldElt.enclosingElement.displayName
-            ]);
+                errorNameTarget,
+                [executableElementName, fieldElt.enclosingElement.displayName]);
             return true;
           }
         }
         // Check methods.
         List<MethodElement> methodElements = superclassElement.methods;
         for (MethodElement methodElement in methodElements) {
           // We need the same name.
           if (methodElement.name != executableElementName) {
             continue;
           }
@@ skipping 65 matching lines @@
    */
   bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null)
         ? getStaticType(lhs)
         : leftVariableElement.type;
     DartType staticRightType = getStaticType(rhs);
-    if (!staticRightType.isAssignableTo(leftType)) {
+    if (!_typeSystem.isAssignableTo(staticRightType, leftType)) {
       _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [
-        staticRightType,
-        leftType
-      ]);
+          StaticTypeWarningCode.INVALID_ASSIGNMENT,
+          rhs,
+          [staticRightType, leftType]);
       return true;
     }
     return false;
   }
 
   /**
    * Given an [assignment] using a compound assignment operator, this verifies
    * that the given assignment is valid. The [lhs] is the left hand side
    * expression. The [rhs] is the right hand side expression.
    *
    * See [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   bool _checkForInvalidCompoundAssignment(
       AssignmentExpression assignment, Expression lhs, Expression rhs) {
     if (lhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null)
         ? getStaticType(lhs)
         : leftVariableElement.type;
     MethodElement invokedMethod = assignment.staticElement;
     if (invokedMethod == null) {
       return false;
     }
     DartType rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
-    if (!rightType.isAssignableTo(leftType)) {
+    if (!_typeSystem.isAssignableTo(rightType, leftType)) {
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightType, leftType]);
       return true;
     }
     return false;
   }
 
   /**
    * Check the given [initializer] to ensure that the field being initialized is
    * a valid field. The [fieldName] is the field name from the
    * [ConstructorFieldInitializer]. The [staticElement] is the static element
    * from the name in the [ConstructorFieldInitializer].
    */
   void _checkForInvalidField(ConstructorFieldInitializer initializer,
       SimpleIdentifier fieldName, Element staticElement) {
     if (staticElement is FieldElement) {
       FieldElement fieldElement = staticElement;
       if (fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD,
-            initializer, [fieldName]);
+            initializer,
+            [fieldName]);
       } else if (fieldElement.isStatic) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, initializer,
+            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD,
+            initializer,
             [fieldName]);
       }
     } else {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, initializer,
+          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD,
+          initializer,
           [fieldName]);
       return;
     }
   }
 
   /**
    * Check to see whether the given function [body] has a modifier associated
    * with it, and report it as an error if it does.
    */
   bool _checkForInvalidModifierOnBody(
@@ skipping 51 matching lines @@
     if (typeNames.length < 1) {
       return false;
     }
     DartType listElementType = typeNames[0].type;
     // Check every list element.
     bool hasProblems = false;
     for (Expression element in literal.elements) {
       if (literal.constKeyword != null) {
         // TODO(paulberry): this error should be based on the actual type of the
         // list element, not the static type.  See dartbug.com/21119.
-        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(element,
+        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
+            element,
             listElementType,
             CheckedModeCompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
       }
-      if (_checkForArgumentTypeNotAssignableWithExpectedTypes(element,
+      if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
+          element,
           listElementType,
           StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
    * Verify that the key/value of entries of the given map [literal] are
@@ skipping 20 matching lines @@
     for (MapLiteralEntry entry in entries) {
       Expression key = entry.key;
       Expression value = entry.value;
       if (literal.constKeyword != null) {
         // TODO(paulberry): this error should be based on the actual type of the
         // list element, not the static type.  See dartbug.com/21119.
         if (_checkForArgumentTypeNotAssignableWithExpectedTypes(key, keyType,
             CheckedModeCompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
-        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(value,
+        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
+            value,
             valueType,
             CheckedModeCompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
           key, keyType, StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
@@ skipping 15 matching lines @@
       return false;
     }
     String className = _enclosingClass.name;
     if (className == null) {
       return false;
     }
     bool problemReported = false;
     // check accessors
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (className == accessor.name) {
-        _errorReporter.reportErrorForOffset(
-            CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME, accessor.nameOffset,
-            className.length);
+        _errorReporter.reportErrorForElement(
+            CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME, accessor);
         problemReported = true;
       }
     }
     // don't check methods, they would be constructors
     // done
     return problemReported;
   }
 
   /**
    * Check to make sure that all similarly typed accessors are of the same type
@@ skipping 60 matching lines @@
       getterType = _getGetterType(propertyAccessorElement);
       setterType = _getSetterType(counterpartAccessor);
     } else if (propertyAccessorElement.isSetter) {
       setterType = _getSetterType(propertyAccessorElement);
       getterType = _getGetterType(counterpartAccessor);
     }
     // If either types are not assignable to each other, report an error
     // (if the getter is null, it is dynamic which is assignable to everything).
     if (setterType != null &&
         getterType != null &&
-        !getterType.isAssignableTo(setterType)) {
+        !_typeSystem.isAssignableTo(getterType, setterType)) {
       if (enclosingClassForCounterpart == null) {
         _errorReporter.reportTypeErrorForNode(
             StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES,
-            accessorDeclaration, [accessorTextName, setterType, getterType]);
+            accessorDeclaration,
+            [accessorTextName, setterType, getterType]);
         return true;
       } else {
         _errorReporter.reportTypeErrorForNode(
             StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE,
             accessorDeclaration, [
           accessorTextName,
           setterType,
           getterType,
           enclosingClassForCounterpart.displayName
         ]);
@@ skipping 42 matching lines @@
       String constantName = _getConstantName((member as SwitchCase).expression);
       if (constantName != null) {
         constantNames.remove(constantName);
       }
     }
     int nameCount = constantNames.length;
     if (nameCount == 0) {
       return false;
     }
     for (int i = 0; i < nameCount; i++) {
-      _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH, statement,
+      int offset = statement.offset;
+      int end = statement.rightParenthesis.end;
+      _errorReporter.reportErrorForOffset(
+          CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH,
+          offset,
+          end - offset,
           [constantNames[i]]);
     }
     return true;
   }
 
   /**
    * Verify that the given function [body] does not contain return statements
    * that both have and do not have return values.
    *
    * See [StaticWarningCode.MIXED_RETURN_TYPES].
@@ skipping 23 matching lines @@
    * constructor. The [mixinName] is the node to report problem on. The
    * [mixinElement] is the mixing to evaluate.
    *
    * See [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR].
    */
   bool _checkForMixinDeclaresConstructor(
       TypeName mixinName, ClassElement mixinElement) {
     for (ConstructorElement constructor in mixinElement.constructors) {
       if (!constructor.isSynthetic && !constructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName,
+            CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR,
+            mixinName,
             [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Report the error [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS] if
    * appropriate.
@@ skipping 13 matching lines @@
    *
    * See [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT].
    */
   bool _checkForMixinInheritsNotFromObject(
       TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
       if (!mixinSupertype.isObject ||
           !mixinElement.isMixinApplication && mixinElement.mixins.length != 0) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName,
+            CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT,
+            mixinName,
             [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify that the given mixin does not reference 'super'. The [mixinName] is
    * the node to report problem on. The [mixinElement] is the mixing to
    * evaluate.
    *
    * See [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER].
    */
   bool _checkForMixinReferencesSuper(
       TypeName mixinName, ClassElement mixinElement) {
-    if (mixinElement.hasReferenceToSuper) {
+    if (!enableSuperMixins && mixinElement.hasReferenceToSuper) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MIXIN_REFERENCES_SUPER, mixinName,
+          CompileTimeErrorCode.MIXIN_REFERENCES_SUPER,
+          mixinName,
           [mixinElement.name]);
     }
     return false;
   }
 
   /**
    * Verify that the given [constructor] has at most one 'super' initializer.
    *
    * See [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS].
    */
@@ skipping 29 matching lines @@
    * Verify that the given instance creation [expression] invokes an existing
    * constructor. The [constructorName] is the constructor name. The [typeName]
    * is the name of the type defining the constructor.
    *
    * This method assumes that the instance creation was tested to be 'new'
    * before being called.
    *
    * See [StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR].
    */
   bool _checkForNewWithUndefinedConstructor(
-      InstanceCreationExpression expression, ConstructorName constructorName,
+      InstanceCreationExpression expression,
+      ConstructorName constructorName,
       TypeName typeName) {
     // OK if resolved
     if (expression.staticElement != null) {
       return false;
     }
     DartType type = typeName.type;
     if (type is InterfaceType) {
       ClassElement element = type.element;
       if (element != null && element.isEnum) {
         // We have already reported the error.
         return false;
       }
     }
     // prepare class name
     Identifier className = typeName.name;
     // report as named or default constructor absence
     SimpleIdentifier name = constructorName.name;
     if (name != null) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR, name, [
-        className,
-        name
-      ]);
+          StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR,
+          name,
+          [className, name]);
     } else {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
-          constructorName, [className]);
+          constructorName,
+          [className]);
     }
     return true;
   }
 
   /**
    * Check that if the given class [declaration] implicitly calls default
    * constructor of its superclass, there should be such default constructor -
    * implicit or explicit.
    *
    * See [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT].
@@ skipping 15 matching lines @@
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     // try to find default generative super constructor
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, declaration.name,
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR,
+            declaration.name,
             [superUnnamedConstructor]);
         return true;
       }
       if (superUnnamedConstructor.isDefaultConstructor &&
           _enclosingClass
               .isSuperConstructorAccessible(superUnnamedConstructor)) {
         return true;
       }
     }
     // report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT,
-        declaration.name, [superType.displayName]);
+        declaration.name,
+        [superType.displayName]);
     return true;
   }
 
   /**
    * Check that the given class declaration overrides all members required by
    * its superclasses and interfaces. The [classNameNode] is the
    * [SimpleIdentifier] to be used if there is a violation, this is either the
    * named from the [ClassDeclaration] or from the [ClassTypeAlias].
    *
    * See [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE],
@@ skipping 75 matching lines @@
         if ((elt is MethodElement && !elt.isAbstract) ||
             (elt is PropertyAccessorElement && !elt.isAbstract)) {
           // Since we are comparing two function types, we need to do the
           // appropriate type substitutions first ().
           FunctionType foundConcreteFT = _inheritanceManager
               .substituteTypeArgumentsInMemberFromInheritance(
                   concreteType, memberName, enclosingType);
           FunctionType requiredMemberFT = _inheritanceManager
               .substituteTypeArgumentsInMemberFromInheritance(
                   requiredMemberType, memberName, enclosingType);
-          if (foundConcreteFT.isSubtypeOf(requiredMemberFT)) {
+          if (_typeSystem.isSubtypeOf(foundConcreteFT, requiredMemberFT)) {
             continue;
           }
         }
       }
       // The not qualifying concrete executable element was found, add it to the
       // list.
       missingOverrides.add(executableElt);
     }
     // Now that we have the set of missing overrides, generate a warning on this
     // class.
@@ skipping 25 matching lines @@
       } else {
         newStrMember = "$prefix'${missingOverridesArray[i].displayName}'";
       }
       stringMembersArrayListSet.add(newStrMember);
     }
     List<String> stringMembersArray = new List.from(stringMembersArrayListSet);
     AnalysisErrorWithProperties analysisError;
     if (stringMembersArray.length == 1) {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE,
-          classNameNode, [stringMembersArray[0]]);
+          classNameNode,
+          [stringMembersArray[0]]);
     } else if (stringMembersArray.length == 2) {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO,
-          classNameNode, [stringMembersArray[0], stringMembersArray[1]]);
+          classNameNode,
+          [stringMembersArray[0], stringMembersArray[1]]);
     } else if (stringMembersArray.length == 3) {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE,
           classNameNode, [
         stringMembersArray[0],
         stringMembersArray[1],
         stringMembersArray[2]
       ]);
     } else if (stringMembersArray.length == 4) {
       analysisError = _errorReporter.newErrorWithProperties(
@@ skipping 22 matching lines @@
   }
 
   /**
    * Check to ensure that the [condition] is of type bool, are. Otherwise an
    * error is reported on the expression.
    *
    * See [StaticTypeWarningCode.NON_BOOL_CONDITION].
    */
   bool _checkForNonBoolCondition(Expression condition) {
     DartType conditionType = getStaticType(condition);
-    if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
+    if (conditionType != null &&
+        !_typeSystem.isAssignableTo(conditionType, _boolType)) {
       _errorReporter.reportErrorForNode(
           StaticTypeWarningCode.NON_BOOL_CONDITION, condition);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given assert [statement] has either a 'bool' or
    * '() -> bool' input.
    *
    * See [StaticTypeWarningCode.NON_BOOL_EXPRESSION].
    */
   bool _checkForNonBoolExpression(AssertStatement statement) {
     Expression expression = statement.condition;
     DartType type = getStaticType(expression);
     if (type is InterfaceType) {
-      if (!type.isAssignableTo(_boolType)) {
+      if (!_typeSystem.isAssignableTo(type, _boolType)) {
         _errorReporter.reportErrorForNode(
             StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression);
         return true;
       }
     } else if (type is FunctionType) {
       FunctionType functionType = type;
       if (functionType.typeArguments.length == 0 &&
-          !functionType.returnType.isAssignableTo(_boolType)) {
+          !_typeSystem.isAssignableTo(functionType.returnType, _boolType)) {
         _errorReporter.reportErrorForNode(
             StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Checks to ensure that the given [expression] is assignable to bool.
    *
    * See [StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION].
    */
   bool _checkForNonBoolNegationExpression(Expression expression) {
     DartType conditionType = getStaticType(expression);
-    if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
+    if (conditionType != null &&
+        !_typeSystem.isAssignableTo(conditionType, _boolType)) {
       _errorReporter.reportErrorForNode(
           StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION, expression);
       return true;
     }
     return false;
   }
 
   /**
    * Verify the given map [literal] either:
    * * has `const modifier`
@@ skipping 230 matching lines @@
           RedirectingConstructorInvocation invocation = initializer;
           ConstructorElement redirectingElement = invocation.staticElement;
           if (redirectingElement == null) {
             String enclosingTypeName = _enclosingClass.displayName;
             String constructorStrName = enclosingTypeName;
             if (invocation.constructorName != null) {
               constructorStrName += ".${invocation.constructorName.name}";
             }
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR,
-                invocation, [constructorStrName, enclosingTypeName]);
+                invocation,
+                [constructorStrName, enclosingTypeName]);
           } else {
             if (redirectingElement.isFactory) {
               _errorReporter.reportErrorForNode(
                   CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR,
                   initializer);
             }
           }
         }
         numRedirections++;
       }
@@ skipping 123 matching lines @@
         return false;
       }
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
         staticReturnType,
         expectedReturnType,
         _enclosingFunction.displayName
       ]);
       return true;
     }
-    if (staticReturnType.isAssignableTo(expectedReturnType)) {
+    if (_typeSystem.isAssignableTo(staticReturnType, expectedReturnType)) {
       return false;
     }
     _errorReporter.reportTypeErrorForNode(
-        StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
-      staticReturnType,
-      expectedReturnType,
-      _enclosingFunction.displayName
-    ]);
+        StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
+        returnExpression,
+        [staticReturnType, expectedReturnType, _enclosingFunction.displayName]);
     return true;
     // TODO(brianwilkerson) Define a hint corresponding to the warning and
     // report it if appropriate.
 //        Type propagatedReturnType = returnExpression.getPropagatedType();
 //        boolean isPropagatedAssignable = propagatedReturnType.isAssignableTo(expectedReturnType);
 //        if (isStaticAssignable || isPropagatedAssignable) {
 //          return false;
 //        }
 //        errorReporter.reportTypeErrorForNode(
 //            StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
@@ skipping 49 matching lines @@
     NodeList<SwitchMember> members = statement.members;
     for (SwitchMember switchMember in members) {
       if (switchMember is! SwitchCase) {
         continue;
       }
       SwitchCase switchCase = switchMember as SwitchCase;
       // prepare 'case' type
       Expression caseExpression = switchCase.expression;
       DartType caseType = getStaticType(caseExpression);
       // check types
-      if (expressionType.isAssignableTo(caseType)) {
+      if (_typeSystem.isAssignableTo(expressionType, caseType)) {
         return false;
       }
       // report problem
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, expression, [
-        expressionType,
-        caseType
-      ]);
+          StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE,
+          expression,
+          [expressionType, caseType]);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given function type [alias] does not reference itself
    * directly.
    *
    * See [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF].
@@ skipping 54 matching lines @@
     bool foundError = false;
     for (int i = 0; i < loopThroughIndex; i++) {
       TypeName argTypeName = typeNameArgList[i];
       DartType argType = argTypeName.type;
       DartType boundType = boundingElts[i].bound;
       if (argType != null && boundType != null) {
         if (typeArguments.length != 0 &&
             typeArguments.length == typeParameters.length) {
           boundType = boundType.substitute2(typeArguments, typeParameters);
         }
-        if (!argType.isSubtypeOf(boundType)) {
+        if (!_typeSystem.isSubtypeOf(argType, boundType)) {
           ErrorCode errorCode;
           if (_isInConstInstanceCreation) {
             errorCode = CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
           } else {
             errorCode = StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
           }
           _errorReporter.reportTypeErrorForNode(
               errorCode, argTypeName, [argType, boundType]);
           foundError = true;
         }
@@ skipping 31 matching lines @@
     DartType bound = element.bound;
     if (bound == null) {
       return false;
     }
     // OK, type parameter is not supertype of its bound
     if (!bound.isMoreSpecificThan(element.type)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, parameter,
+        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND,
+        parameter,
         [element.displayName]);
     return true;
   }
 
   /**
    * Check that if the given generative [constructor] has neither an explicit
    * super constructor invocation nor a redirecting constructor invocation, that
    * the superclass has a default generative constructor.
    *
    * See [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT],
@@ skipping 35 matching lines @@
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR,
-            constructor.returnType, [superUnnamedConstructor]);
+            constructor.returnType,
+            [superUnnamedConstructor]);
         return true;
       }
       if (!superUnnamedConstructor.isDefaultConstructor ||
           !_enclosingClass
               .isSuperConstructorAccessible(superUnnamedConstructor)) {
         int offset;
         int length;
         {
           Identifier returnType = constructor.returnType;
           SimpleIdentifier name = constructor.name;
           offset = returnType.offset;
           length = (name != null ? name.end : returnType.end) - offset;
         }
         _errorReporter.reportErrorForOffset(
-            CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT, offset,
-            length, [superType.displayName]);
+            CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT,
+            offset,
+            length,
+            [superType.displayName]);
       }
       return false;
     }
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
-        constructor.returnType, [superElement.name]);
+        constructor.returnType,
+        [superElement.name]);
     return true;
   }
 
   /**
    * Check that if the given [name] is a reference to a static member it is
    * defined in the enclosing class rather than in a superclass.
    *
    * See [StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER].
    */
   bool _checkForUnqualifiedReferenceToNonLocalStaticMember(
       SimpleIdentifier name) {
     Element element = name.staticElement;
     if (element == null || element is TypeParameterElement) {
       return false;
     }
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
       return false;
     }
     if ((element is MethodElement && !element.isStatic) ||
         (element is PropertyAccessorElement && !element.isStatic)) {
       return false;
     }
     if (identical(enclosingElement, _enclosingClass)) {
       return false;
     }
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER,
-        name, [name.name]);
+        name,
+        [name.name]);
     return true;
   }
 
   void _checkForValidField(FieldFormalParameter parameter) {
     ParameterElement element = parameter.element;
     if (element is FieldFormalParameterElement) {
       FieldElement fieldElement = element.field;
       if (fieldElement == null || fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-            parameter, [parameter.identifier.name]);
+            parameter,
+            [parameter.identifier.name]);
       } else {
         ParameterElement parameterElement = parameter.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement;
           DartType declaredType = fieldFormal.type;
           DartType fieldType = fieldElement.type;
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-                parameter, [parameter.identifier.name]);
+                parameter,
+                [parameter.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD,
-                parameter, [parameter.identifier.name]);
+                parameter,
+                [parameter.identifier.name]);
           } else if (declaredType != null &&
               fieldType != null &&
-              !declaredType.isAssignableTo(fieldType)) {
+              !_typeSystem.isAssignableTo(declaredType, fieldType)) {
             _errorReporter.reportTypeErrorForNode(
                 StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE,
-                parameter, [declaredType, fieldType]);
+                parameter,
+                [declaredType, fieldType]);
           }
         } else {
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-                parameter, [parameter.identifier.name]);
+                parameter,
+                [parameter.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD,
-                parameter, [parameter.identifier.name]);
+                parameter,
+                [parameter.identifier.name]);
           }
         }
       }
     }
 //        else {
 //        // TODO(jwren) Report error, constructor initializer variable is a top level element
 //        // (Either here or in ErrorVerifier.checkForAllFinalInitializedErrorCodes)
 //        }
   }
 
@@ skipping 55 matching lines @@
         "<<" == name ||
         ">>" == name ||
         "[]" == name) {
       expected = 1;
     } else if ("~" == name) {
       expected = 0;
     }
     if (expected != -1 && numParameters != expected) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR,
-          nameNode, [name, expected, numParameters]);
+          nameNode,
+          [name, expected, numParameters]);
       return true;
     }
     // check for operator "-"
     if ("-" == name && numParameters > 1) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS,
-          nameNode, [numParameters]);
+          nameNode,
+          [numParameters]);
       return true;
     }
     // OK
     return false;
   }
 
   /**
    * Verify that the given setter [parameterList] has only one required
    * parameter. The [setterName] is the name of the setter to report problems
    * on.
@@ skipping 39 matching lines @@
     DartType impliedReturnType;
     if (isYieldEach) {
       impliedReturnType = staticYieldedType;
     } else if (_enclosingFunction.isAsynchronous) {
       impliedReturnType =
           _typeProvider.streamType.substitute4(<DartType>[staticYieldedType]);
     } else {
       impliedReturnType =
           _typeProvider.iterableType.substitute4(<DartType>[staticYieldedType]);
     }
-    if (!impliedReturnType.isAssignableTo(declaredReturnType)) {
+    if (!_typeSystem.isAssignableTo(impliedReturnType, declaredReturnType)) {
       _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, yieldExpression, [
-        impliedReturnType,
-        declaredReturnType
-      ]);
+          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
+          yieldExpression,
+          [impliedReturnType, declaredReturnType]);
       return true;
     }
     if (isYieldEach) {
       // Since the declared return type might have been "dynamic", we need to
       // also check that the implied return type is assignable to generic
       // Stream/Iterable.
       DartType requiredReturnType;
       if (_enclosingFunction.isAsynchronous) {
         requiredReturnType = _typeProvider.streamDynamicType;
       } else {
         requiredReturnType = _typeProvider.iterableDynamicType;
       }
-      if (!impliedReturnType.isAssignableTo(requiredReturnType)) {
+      if (!_typeSystem.isAssignableTo(impliedReturnType, requiredReturnType)) {
         _errorReporter.reportTypeErrorForNode(
-            StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, yieldExpression, [
-          impliedReturnType,
-          requiredReturnType
-        ]);
+            StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
+            yieldExpression,
+            [impliedReturnType, requiredReturnType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify that if the given class [declaration] implements the class Function
    * that it has a concrete implementation of the call method.
    *
    * See [StaticWarningCode.FUNCTION_WITHOUT_CALL].
    */
   bool _checkImplementsFunctionWithoutCall(ClassDeclaration declaration) {
     if (declaration.isAbstract) {
       return false;
     }
     ClassElement classElement = declaration.element;
     if (classElement == null) {
       return false;
     }
-    if (!classElement.type.isSubtypeOf(_typeProvider.functionType)) {
+    if (!_typeSystem.isSubtypeOf(
+        classElement.type, _typeProvider.functionType)) {
       return false;
     }
     // If there is a noSuchMethod method, then don't report the warning,
     // see dartbug.com/16078
     if (classElement.getMethod(FunctionElement.NO_SUCH_METHOD_METHOD_NAME) !=
         null) {
       return false;
     }
     ExecutableElement callMethod = _inheritanceManager.lookupMember(
         classElement, FunctionElement.CALL_METHOD_NAME);
@@ skipping 23 matching lines @@
     ImplementsClause implementsClause = declaration.implementsClause;
     if (implementsClause == null) {
       return false;
     }
     // check interfaces
     bool hasProblem = false;
     for (TypeName interfaceNode in implementsClause.interfaces) {
       if (interfaceNode.type == superType) {
         hasProblem = true;
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS, interfaceNode,
+            CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS,
+            interfaceNode,
             [superType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   DartType _computeReturnTypeForMethod(Expression returnExpression) {
     // This method should never be called for generators, since generators are
     // never allowed to contain return statements with expressions.
@@ skipping 298 matching lines @@
       if (size > 1) {
         // Construct a string showing the cyclic implements path:
         // "A, B, C, D, A"
         String separator = ", ";
         StringBuffer buffer = new StringBuffer();
         for (int i = 0; i < size; i++) {
           buffer.write(path[i].displayName);
           buffer.write(separator);
         }
         buffer.write(element.displayName);
-        _errorReporter.reportErrorForOffset(
+        _errorReporter.reportErrorForElement(
             CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
-            _enclosingClass.nameOffset, enclosingClassName.length, [
-          enclosingClassName,
-          buffer.toString()
-        ]);
+            _enclosingClass,
+            [enclosingClassName, buffer.toString()]);
         return true;
       } else {
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
-        _errorReporter.reportErrorForOffset(_getBaseCaseErrorCode(element),
-            _enclosingClass.nameOffset, enclosingClassName.length,
-            [enclosingClassName]);
+        _errorReporter.reportErrorForElement(_getBaseCaseErrorCode(element),
+            _enclosingClass, [enclosingClassName]);
         return true;
       }
     }
     if (path.indexOf(element) > 0) {
       return false;
     }
     path.add(element);
     // n-case
     InterfaceType supertype = element.supertype;
     if (supertype != null &&
@@ skipping 84 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }