Abstract over the type system.

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 
@@ skipping 411 matching lines @@
    */
   List<Source> get sources;
 
   /**
    * Return a type provider for this context or throw [AnalysisException] if
    * either `dart:core` or `dart:async` cannot be resolved.
    */
   TypeProvider get typeProvider;
 
   /**
+   * Return a type system for this context.
+   */
+  TypeSystem get typeSystem;
+
+  /**
    * Add the given [listener] to the list of objects that are to be notified
    * when various analysis results are produced in this context.
    */
   void addListener(AnalysisListener listener);
 
   /**
    * Apply the given [delta] to change the level of analysis that will be
    * performed for the sources known to this context.
    */
   void applyAnalysisDelta(AnalysisDelta delta);
@@ skipping 591 matching lines @@
    * Cached information used in incremental analysis or `null` if none.
    */
   IncrementalAnalysisCache _incrementalAnalysisCache;
 
   /**
    * The [TypeProvider] for this context, `null` if not yet created.
    */
   TypeProvider _typeProvider;
 
   /**
+   * The [TypeSystem] for this context, `null` if not yet created.
+   */
+  TypeSystem _typeSystem;
+
+  /**
    * The object used to manage the list of sources that need to be analyzed.
    */
   WorkManager _workManager = new WorkManager();
 
   /**
    * The [Stopwatch] of the current "perform tasks cycle".
    */
   Stopwatch _performAnalysisTaskStopwatch;
 
   /**
@@ skipping 490 matching lines @@
   }
 
   /**
    * Sets the [TypeProvider] for this context.
    */
   void set typeProvider(TypeProvider typeProvider) {
     _typeProvider = typeProvider;
   }
 
   @override
+  TypeSystem get typeSystem {
+    if (_typeSystem == null) {
+      _typeSystem = TypeSystem.create(this);
+    }
+    return _typeSystem;
+  }
+
+  @override
   void addListener(AnalysisListener listener) {
     if (!_listeners.contains(listener)) {
       _listeners.add(listener);
     }
   }
 
   @override
   void applyAnalysisDelta(AnalysisDelta delta) {
     ChangeSet changeSet = new ChangeSet();
     delta.analysisLevels.forEach((Source source, AnalysisLevel level) {
@@ skipping 6902 matching lines @@
   @override
   accept(AnalysisTaskVisitor visitor) =>
       visitor.visitGenerateDartErrorsTask(this);
 
   @override
   void internalPerform() {
     PerformanceStatistics.errors.makeCurrentWhile(() {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       TypeProvider typeProvider = context.typeProvider;
+      TypeSystem typeSystem = context.typeSystem;
       //
       // Validate the directives
       //
       validateDirectives(context, source, _unit, errorListener);
       //
       // Use the ConstantVerifier to verify the use of constants.
       // This needs to happen before using the ErrorVerifier because some error
       // codes need the computed constant values.
       //
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, libraryElement, typeProvider);
 //      _unit.accept(constantVerifier);
       //
       // Use the ErrorVerifier to compute the rest of the errors.
       //
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           libraryElement,
           typeProvider,
+          typeSystem,
           new InheritanceManager(libraryElement),
           context.analysisOptions.enableSuperMixins);
       _unit.accept(errorVerifier);
       _errors = errorListener.getErrorsForSource(source);
     });
   }
 
   /**
    * Check each directive in the given compilation unit to see if the referenced source exists and
    * report an error if it does not.
@@ skipping 2416 matching lines @@
     }
     return "resolve unit ${librarySource.fullName}";
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartUnitTask(this);
 
   @override
   void internalPerform() {
     TypeProvider typeProvider = _libraryElement.context.typeProvider;
+    TypeSystem typeSystem = _libraryElement.context.typeSystem;
     CompilationUnit unit = context.computeResolvableCompilationUnit(source);
     if (unit == null) {
       throw new AnalysisException(
           "Internal error: computeResolvableCompilationUnit returned a value without a parsed Dart unit");
     }
     //
     // Resolve names in declarations.
     //
     new DeclarationResolver().resolve(unit, _find(_libraryElement, source));
     //
     // Resolve the type names.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     TypeResolverVisitor typeResolverVisitor = new TypeResolverVisitor(
         _libraryElement, source, typeProvider, errorListener);
     unit.accept(typeResolverVisitor);
     //
     // Resolve the rest of the structure
     //
     InheritanceManager inheritanceManager =
         new InheritanceManager(_libraryElement);
     ResolverVisitor resolverVisitor = new ResolverVisitor(
-        _libraryElement, source, typeProvider, errorListener,
+        _libraryElement, source, typeProvider, typeSystem, errorListener,
         inheritanceManager: inheritanceManager);
     unit.accept(resolverVisitor);
     //
     // Perform additional error checking.
     //
     PerformanceStatistics.errors.makeCurrentWhile(() {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           _libraryElement,
           typeProvider,
+          typeSystem,
           inheritanceManager,
           context.analysisOptions.enableSuperMixins);
       unit.accept(errorVerifier);
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _libraryElement, typeProvider);
 //       unit.accept(constantVerifier);
     });
@@ skipping 1075 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }