Abstract over the type system.

pkg/analyzer/lib/src/task/dart.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 1497 matching lines @@
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: UNIT_INPUT is not needed.  It is merely a bookkeeping dependency
     // to ensure that resolution has occurred before we attempt to determine
     // constant dependencies.
     //
     ConstantEvaluationTarget constant = target;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
+    TypeSystem typeSystem = context.typeSystem;
     //
     // Compute dependencies.
     //
     List<ConstantEvaluationTarget> dependencies = <ConstantEvaluationTarget>[];
-    new ConstantEvaluationEngine(typeProvider, context.declaredVariables)
+    new ConstantEvaluationEngine(
+            typeProvider, typeSystem, context.declaredVariables)
         .computeDependencies(constant, dependencies.add);
     //
     // Record outputs.
     //
     outputs[CONSTANT_DEPENDENCIES] = dependencies;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
@@ skipping 65 matching lines @@
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: DEPENDENCIES_INPUT is not needed.  It is merely a bookkeeping
     // dependency to ensure that the constants that this constant depends on
     // are computed first.
     ConstantEvaluationTarget constant = target;
     AnalysisContext context = constant.context;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
+    TypeSystem typeSystem = context.typeSystem;
     //
     // Compute the value of the constant, or report an error if there was a
     // cycle.
     //
     ConstantEvaluationEngine constantEvaluationEngine =
-        new ConstantEvaluationEngine(typeProvider, context.declaredVariables);
+        new ConstantEvaluationEngine(
+            typeProvider, typeSystem, context.declaredVariables);
     if (dependencyCycle == null) {
       constantEvaluationEngine.computeConstantValue(constant);
     } else {
       List<ConstantEvaluationTarget> constantsInCycle =
           <ConstantEvaluationTarget>[];
       for (WorkItem workItem in dependencyCycle) {
         if (workItem.descriptor == DESCRIPTOR) {
           constantsInCycle.add(workItem.target);
         }
       }
@@ skipping 711 matching lines @@
     //
     // Prepare inputs.
     //
     CompilationUnit unit = getRequiredInput(RESOLVED_UNIT_INPUT);
     List<UsedImportedElements> usedImportedElementsList =
         getRequiredInput(USED_IMPORTED_ELEMENTS_INPUT);
     List<UsedLocalElements> usedLocalElementsList =
         getRequiredInput(USED_LOCAL_ELEMENTS_INPUT);
     CompilationUnitElement unitElement = unit.element;
     LibraryElement libraryElement = unitElement.library;
+    TypeSystem typeSystem = context.typeSystem;
+
     //
     // Generate errors.
     //
-    unit.accept(new DeadCodeVerifier(errorReporter));
+    unit.accept(new DeadCodeVerifier(errorReporter, typeSystem));
     // Verify imports.
     {
       ImportsVerifier verifier = new ImportsVerifier();
       verifier.addImports(unit);
       usedImportedElementsList.forEach(verifier.removeUsedElements);
       verifier.generateDuplicateImportHints(errorReporter);
       verifier.generateUnusedImportHints(errorReporter);
     }
     // Unused local elements.
     {
       UsedLocalElements usedElements =
           new UsedLocalElements.merge(usedLocalElementsList);
       UnusedLocalElementsVerifier visitor =
           new UnusedLocalElementsVerifier(errorListener, usedElements);
       unitElement.accept(visitor);
     }
     // Dart2js analysis.
     if (analysisOptions.dart2jsHint) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices.
     InheritanceManager inheritanceManager =
         new InheritanceManager(libraryElement);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
-    unit.accept(new BestPracticesVerifier(errorReporter, typeProvider));
+
+    unit.accept(
+        new BestPracticesVerifier(errorReporter, typeProvider, typeSystem));
     unit.accept(new OverrideVerifier(errorReporter, inheritanceManager));
     // Find to-do comments.
     new ToDoFinder(errorReporter).findIn(unit);
     //
     // Record outputs.
     //
     outputs[HINTS] = errorListener.errors;
   }
 
   /**
@@ skipping 64 matching lines @@
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
+    TypeSystem typeSystem = context.typeSystem;
     //
     // Infer instance members.
     //
     if (context.analysisOptions.strongMode) {
       InstanceMemberInferrer inferrer =
-          new InstanceMemberInferrer(typeProvider);
+          new InstanceMemberInferrer(typeProvider, typeSystem);
       inferrer.inferCompilationUnit(unit.element);
     }
     //
     // Record outputs.
     //
     outputs[RESOLVED_UNIT7] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
@@ skipping 182 matching lines @@
     //
     // Prepare inputs.
     //
     // Note: DEPENDENCIES_INPUT is not needed.  It is merely a bookkeeping
     // dependency to ensure that the variables that this variable references
     // have types inferred before inferring the type of this variable.
     //
     VariableElementImpl variable = target;
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
+    TypeSystem typeSystem = context.typeSystem;
     RecordingErrorListener errorListener = new RecordingErrorListener();
     if (dependencyCycle == null) {
       //
       // Re-resolve the variable's initializer so that the inferred types of other
       // variables will be propagated.
       //
       NodeLocator locator = new NodeLocator(variable.nameOffset);
       AstNode node = locator.searchWithin(unit);
       VariableDeclaration declaration = node
           .getAncestor((AstNode ancestor) => ancestor is VariableDeclaration);
       if (declaration == null || declaration.name != node) {
         throw new AnalysisException(
             "NodeLocator failed to find a variable's declaration");
       }
       Expression initializer = declaration.initializer;
       ResolutionEraser.erase(initializer, eraseDeclarations: false);
       ResolutionContext resolutionContext =
           ResolutionContextBuilder.contextFor(initializer, errorListener);
-      ResolverVisitor visitor = new ResolverVisitor(
-          variable.library, variable.source, typeProvider, errorListener,
+      ResolverVisitor visitor = new ResolverVisitor(variable.library,
+          variable.source, typeProvider, typeSystem, errorListener,
           nameScope: resolutionContext.scope);
       if (resolutionContext.enclosingClassDeclaration != null) {
         visitor.prepareToResolveMembersInClass(
             resolutionContext.enclosingClassDeclaration);
       }
       visitor.initForIncrementalResolution();
       initializer.accept(visitor);
       //
       // Record the type of the variable.
       //
@@ skipping 438 matching lines @@
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
+    TypeSystem typeSystem = context.typeSystem;
     //
     // Resolve references.
     //
     InheritanceManager inheritanceManager =
         new InheritanceManager(libraryElement);
-    PartialResolverVisitor visitor = new PartialResolverVisitor(
-        libraryElement, unitElement.source, typeProvider, errorListener,
+    PartialResolverVisitor visitor = new PartialResolverVisitor(libraryElement,
+        unitElement.source, typeProvider, typeSystem, errorListener,
         inheritanceManager: inheritanceManager);
     unit.accept(visitor);
     //
     // Record outputs.
     //
     outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = visitor.staticVariables;
     outputs[PARTIALLY_RESOLVE_REFERENCES_ERRORS] =
         removeDuplicateErrors(errorListener.errors);
     outputs[RESOLVED_UNIT5] = unit;
   }
@@ skipping 195 matching lines @@
     //
     // Prepare inputs.
     //
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Resolve function bodies.
     //
     CompilationUnitElement unitElement = unit.element;
     RecordingErrorListener errorListener = new RecordingErrorListener();
+    TypeSystem typeSystem = context.typeSystem;
     for (CompilationUnitMember unitMember in unit.declarations) {
       if (unitMember is FunctionDeclaration) {
         _resolveFunctionBody(unitMember.functionExpression.body, unitElement,
-            typeProvider, errorListener);
+            typeProvider, typeSystem, errorListener);
       } else if (unitMember is ClassDeclaration) {
         for (ClassMember classMember in unitMember.members) {
           if (classMember is ConstructorDeclaration) {
-            _resolveFunctionBody(
-                classMember.body, unitElement, typeProvider, errorListener);
+            _resolveFunctionBody(classMember.body, unitElement, typeProvider,
+                typeSystem, errorListener);
           } else if (classMember is MethodDeclaration) {
-            _resolveFunctionBody(
-                classMember.body, unitElement, typeProvider, errorListener);
+            _resolveFunctionBody(classMember.body, unitElement, typeProvider,
+                typeSystem, errorListener);
           }
         }
       }
     }
     //
     // Record outputs.
     //
     outputs[RESOLVE_FUNCTION_BODIES_ERRORS] = errorListener.errors;
     outputs[RESOLVED_UNIT8] = unit;
   }
 
   void _resolveFunctionBody(
       FunctionBody functionBody,
       CompilationUnitElement unitElement,
       TypeProvider typeProvider,
+      TypeSystem typeSystem,
       RecordingErrorListener errorListener) {
     ResolutionContext resolutionContext =
         ResolutionContextBuilder.contextFor(functionBody, errorListener);
-    ResolverVisitor visitor = new ResolverVisitor(
-        unitElement.library, unitElement.source, typeProvider, errorListener,
+    ResolverVisitor visitor = new ResolverVisitor(unitElement.library,
+        unitElement.source, typeProvider, typeSystem, errorListener,
         nameScope: resolutionContext.scope);
     if (resolutionContext.enclosingClassDeclaration != null) {
       visitor.prepareToResolveMembersInClass(
           resolutionContext.enclosingClassDeclaration);
     }
     Declaration declaration = functionBody.getAncestor((AstNode node) =>
         node is ConstructorDeclaration ||
             node is FunctionDeclaration ||
             node is MethodDeclaration);
     visitor.initForIncrementalResolution(declaration);
@@ skipping 480 matching lines @@
     RecordingErrorListener errorListener = new RecordingErrorListener();
     Source source = getRequiredSource();
     errorReporter = new ErrorReporter(errorListener, source);
     //
     // Prepare inputs.
     //
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     LibraryElement libraryElement = unitElement.library;
+    TypeSystem typeSystem = context.typeSystem;
     //
     // Validate the directives.
     //
     validateDirectives(unit);
     //
     // Use the ConstantVerifier to compute errors.
     //
-    ConstantVerifier constantVerifier = new ConstantVerifier(
-        errorReporter, libraryElement, typeProvider, context.declaredVariables);
+    ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter,
+        libraryElement, typeProvider, typeSystem, context.declaredVariables);
     unit.accept(constantVerifier);
     //
     // Use the ErrorVerifier to compute errors.
     //
     ErrorVerifier errorVerifier = new ErrorVerifier(
         errorReporter,
         libraryElement,
         typeProvider,
+        typeSystem,
         new InheritanceManager(libraryElement),
         context.analysisOptions.enableSuperMixins);
     unit.accept(errorVerifier);
     //
     // Record outputs.
     //
     outputs[VERIFY_ERRORS] = removeDuplicateErrors(errorListener.errors);
   }
 
   /**
@@ skipping 171 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }