Abstract over the type system.

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 896 matching lines @@
    * The context the compilation unit being resolved in.
    */
   AnalysisContext _context;
 
   /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
+   * The type system primitives.
+   */
+  TypeSystem _typeSystem;
+
+  /**
    * The element for the library containing the compilation unit being resolved.
    */
   LibraryElementImpl _definingLibrary;
 
   /**
    * The [DartEntry] corresponding to the source being resolved.
    */
   DartEntry oldEntry;
 
   /**
@@ skipping 58 matching lines @@
       this._definingUnit,
       this._updateOffset,
       this._updateEndOld,
       this._updateEndNew) {
     _updateDelta = _updateEndNew - _updateEndOld;
     _definingLibrary = _definingUnit.library;
     _librarySource = _definingLibrary.source;
     _source = _definingUnit.source;
     _context = _definingUnit.context;
     _typeProvider = _context.typeProvider;
+    _typeSystem = _context.typeSystem;
   }
 
   /**
    * Resolve [node], reporting any errors or warnings to the given listener.
    *
    * [node] - the root of the AST structure to be resolved.
    *
    * Returns `true` if resolution was successful.
    */
   bool resolve(AstNode node) {
@@ skipping 88 matching lines @@
       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, _context.declaredVariables);
+          _context, _typeProvider, _typeSystem, _context.declaredVariables);
       computer.add(unit, _source, _librarySource);
       computer.computeValues();
     }
     // validate
     {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
-      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter,
-          _definingLibrary, _typeProvider, _context.declaredVariables);
+      ConstantVerifier constantVerifier = new ConstantVerifier(
+          errorReporter,
+          _definingLibrary,
+          _typeProvider,
+          _typeSystem,
+          _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, errorListener,
+        ResolverVisitor visitor = new ResolverVisitor(_definingLibrary, _source,
+            _typeProvider, _typeSystem, 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);
 }