Make type system changes backwards compatible

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/context/cache.dart'
@@ skipping 1087 matching lines @@
       node is MethodDeclaration ||
       node is TopLevelVariableDeclaration;
 
   /**
    * Compute a value for all of the constants in the given [node].
    */
   void _computeConstants(AstNode node) {
     // compute values
     {
       CompilationUnit unit = node.getAncestor((n) => n is CompilationUnit);
-      ConstantValueComputer computer = new ConstantValueComputer(
-          _context, _typeProvider, _typeSystem, _context.declaredVariables);
+      ConstantValueComputer computer = new ConstantValueComputer(_context,
+          _typeProvider, _context.declaredVariables, null, _typeSystem);
       computer.add(unit, _source, _librarySource);
       computer.computeValues();
     }
     // validate
     {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
-      ConstantVerifier constantVerifier = new ConstantVerifier(
-          errorReporter,
-          _definingLibrary,
-          _typeProvider,
-          _typeSystem,
-          _context.declaredVariables);
+      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter,
+          _definingLibrary, _typeProvider, _context.declaredVariables);
       node.accept(constantVerifier);
     }
   }
 
   /**
    * Starting at [node], find the smallest AST node that can be resolved
    * independently of any other nodes. Return the node that was found.
    *
    * [node] - the node at which the search is to begin
    *
@@ skipping 43 matching lines @@
       }
       // resolve variables
       {
         VariableResolverVisitor visitor = new VariableResolverVisitor(
             _definingLibrary, _source, _typeProvider, errorListener,
             nameScope: scope);
         node.accept(visitor);
       }
       // resolve references
       {
-        ResolverVisitor visitor = new ResolverVisitor(_definingLibrary, _source,
-            _typeProvider, _typeSystem, errorListener,
+        ResolverVisitor visitor = new ResolverVisitor(
+            _definingLibrary, _source, _typeProvider, errorListener,
             nameScope: scope);
         if (_resolutionContext.enclosingClassDeclaration != null) {
           visitor.visitClassDeclarationIncrementally(
               _resolutionContext.enclosingClassDeclaration);
         }
         if (node is Comment) {
           visitor.resolveOnlyCommentInFunctionBody = true;
           node = node.parent;
         }
         visitor.initForIncrementalResolution();
@@ skipping 138 matching lines @@
 
   void _verify(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           _definingLibrary,
           _typeProvider,
-          _typeSystem,
           new InheritanceManager(_definingLibrary),
           _context.analysisOptions.enableSuperMixins);
       if (_resolutionContext.enclosingClassDeclaration != null) {
         errorVerifier.visitClassDeclarationIncrementally(
             _resolutionContext.enclosingClassDeclaration);
       }
       node.accept(errorVerifier);
       _verifyErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('verify');
@@ skipping 764 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }