Make type system changes backwards compatible

pkg/analyzer/lib/src/generated/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.resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'constant.dart';
@@ skipping 64 matching lines @@
   /**
    * The type system primitives
    */
   TypeSystem _typeSystem;
 
   /**
    * Create a new instance of the [BestPracticesVerifier].
    *
    * @param errorReporter the error reporter
    */
-  BestPracticesVerifier(
-      this._errorReporter, TypeProvider typeProvider, this._typeSystem)
-      : _futureNullType = typeProvider.futureNullType;
+  BestPracticesVerifier(this._errorReporter, TypeProvider typeProvider,
+      {TypeSystem typeSystem})
+      : _futureNullType = typeProvider.futureNullType,
+        _typeSystem = (typeSystem != null) ? typeSystem : new TypeSystemImpl();
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     _checkForUnnecessaryCast(node);
@@ skipping 743 matching lines @@
   final ErrorReporter _errorReporter;
 
   /**
    * The type provider used to access the known types.
    */
   final TypeProvider _typeProvider;
 
   /**
    * The type system in use.
    */
-  final TypeSystem _typeSystem;
+  TypeSystem _typeSystem;
 
   /**
    * The set of variables declared using '-D' on the command line.
    */
   final DeclaredVariables declaredVariables;
 
   /**
    * The type representing the type 'bool'.
    */
   InterfaceType _boolType;
@@ skipping 17 matching lines @@
    * The current library that is being analyzed.
    */
   final LibraryElement _currentLibrary;
 
   /**
    * Initialize a newly created constant verifier.
    *
    * @param errorReporter the error reporter by which errors will be reported
    */
   ConstantVerifier(this._errorReporter, this._currentLibrary,
-      this._typeProvider, this._typeSystem, this.declaredVariables) {
+      this._typeProvider, this.declaredVariables) {

[Paul Berry, 2015/09/18 05:19:25]

Nit: how about this instead:

ConstantVerifier(this._errorReporter, LibraryElement currentLibrary,
    this._typeProvider, this.declaredVariables)
  : _currentLibrary = currentLibrary,
    _typeSystem = currentLibrary.context.typeSystem {
  ...
}

That way we can keep the "final" modifier on the declaration of the _typeSystem
field.

[Leaf, 2015/09/18 16:59:04]

Done.

     this._boolType = _typeProvider.boolType;
     this._intType = _typeProvider.intType;
     this._numType = _typeProvider.numType;
     this._stringType = _typeProvider.stringType;
+    this._typeSystem = _currentLibrary.context.typeSystem;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     super.visitAnnotation(node);
     // check annotation creation
     Element element = node.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element;
       // should 'const' constructor
@@ skipping 33 matching lines @@
   }
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (node.isConst) {
       // We need to evaluate the constant to see if any errors occur during its
       // evaluation.
       ConstructorElement constructor = node.staticElement;
       if (constructor != null) {
         ConstantEvaluationEngine evaluationEngine =
-            new ConstantEvaluationEngine(
-                _typeProvider, _typeSystem, declaredVariables);
+            new ConstantEvaluationEngine(_typeProvider, declaredVariables,
+                typeSystem: _typeSystem);
         ConstantVisitor constantVisitor =
             new ConstantVisitor(evaluationEngine, _errorReporter);
         evaluationEngine.evaluateConstructorCall(
             node,
             node.argumentList.arguments,
             constructor,
             constantVisitor,
             _errorReporter);
       }
     }
@@ skipping 53 matching lines @@
                 [type.displayName]);
           }
         }
       } else {
         // Note: we throw the errors away because this isn't actually a const.
         AnalysisErrorListener errorListener =
             AnalysisErrorListener.NULL_LISTENER;
         ErrorReporter subErrorReporter =
             new ErrorReporter(errorListener, _errorReporter.source);
         DartObjectImpl result = key.accept(new ConstantVisitor(
-            new ConstantEvaluationEngine(
-                _typeProvider, _typeSystem, declaredVariables),
+            new ConstantEvaluationEngine(_typeProvider, declaredVariables,
+                typeSystem: _typeSystem),
             subErrorReporter));
         if (result != null) {
           if (keys.contains(result)) {
             invalidKeys.add(key);
           } else {
             keys.add(result);
           }
         } else {
           reportEqualKeys = false;
         }
@@ skipping 185 matching lines @@
    *
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
   DartObjectImpl _validate(Expression expression, ErrorCode errorCode) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter subErrorReporter =
         new ErrorReporter(errorListener, _errorReporter.source);
     DartObjectImpl result = expression.accept(new ConstantVisitor(
-        new ConstantEvaluationEngine(
-            _typeProvider, _typeSystem, declaredVariables),
+        new ConstantEvaluationEngine(_typeProvider, declaredVariables,
+            typeSystem: _typeSystem),
         subErrorReporter));
     _reportErrors(errorListener.errors, errorCode);
     return result;
   }
 
   /**
    * Validate that if the passed arguments are constant expressions.
    *
    * @param argumentList the argument list to evaluate
    */
@@ skipping 87 matching lines @@
               in fieldDeclaration.fields.variables) {
             Expression initializer = variableDeclaration.initializer;
             if (initializer != null) {
               // Ignore any errors produced during validation--if the constant
               // can't be eavluated we'll just report a single error.
               AnalysisErrorListener errorListener =
                   AnalysisErrorListener.NULL_LISTENER;
               ErrorReporter subErrorReporter =
                   new ErrorReporter(errorListener, _errorReporter.source);
               DartObjectImpl result = initializer.accept(new ConstantVisitor(
-                  new ConstantEvaluationEngine(
-                      _typeProvider, _typeSystem, declaredVariables),
+                  new ConstantEvaluationEngine(_typeProvider, declaredVariables,
+                      typeSystem: _typeSystem),
                   subErrorReporter));
               if (result == null) {
                 _errorReporter.reportErrorForNode(
                     CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
                     errorSite,
                     [variableDeclaration.name.name]);
               }
             }
           }
         }
       }
     }
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
   void _validateInitializerExpression(
       List<ParameterElement> parameterElements, Expression expression) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter subErrorReporter =
         new ErrorReporter(errorListener, _errorReporter.source);
     DartObjectImpl result = expression.accept(
-        new _ConstantVerifier_validateInitializerExpression(
-            _typeProvider,
-            _typeSystem,
-            subErrorReporter,
-            this,
-            parameterElements,
-            declaredVariables));
+        new _ConstantVerifier_validateInitializerExpression(_typeProvider,
+            subErrorReporter, this, parameterElements, declaredVariables,
+            typeSystem: _typeSystem));
     _reportErrors(errorListener.errors,
         CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
     if (result != null) {
       _reportErrorIfFromDeferredLibrary(expression,
           CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY);
     }
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
@@ skipping 113 matching lines @@
   /**
    *  The type system for this visitor
    */
   final TypeSystem _typeSystem;
 
   /**
    * Create a new instance of the [DeadCodeVerifier].
    *
    * @param errorReporter the error reporter
    */
-  DeadCodeVerifier(this._errorReporter, this._typeSystem);
+  DeadCodeVerifier(this._errorReporter, {TypeSystem typeSystem})
+      : this._typeSystem =
+            (typeSystem != null) ? typeSystem : new TypeSystemImpl();
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     bool isAmpAmp = operator.type == sc.TokenType.AMPERSAND_AMPERSAND;
     bool isBarBar = operator.type == sc.TokenType.BAR_BAR;
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       if (!_isDebugConstant(lhsCondition)) {
         EvaluationResultImpl lhsResult = _getConstantBooleanValue(lhsCondition);
@@ skipping 3299 matching lines @@
       }
       _library.accept(new UnusedLocalElementsVerifier(
           _errorListener, _usedLocalElementsVisitor.usedElements));
     });
   }
 
   void _generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     unit.accept(_usedImportedElementsVisitor);
     // dead code analysis
-    unit.accept(new DeadCodeVerifier(errorReporter, _context.typeSystem));
+    unit.accept(
+        new DeadCodeVerifier(errorReporter, typeSystem: _context.typeSystem));
     unit.accept(_usedLocalElementsVisitor);
     // dart2js analysis
     if (_enableDart2JSHints) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices
-    unit.accept(new BestPracticesVerifier(
-        errorReporter, _context.typeProvider, _context.typeSystem));
+    unit.accept(new BestPracticesVerifier(errorReporter, _context.typeProvider,
+        typeSystem: _context.typeSystem));
     unit.accept(new OverrideVerifier(errorReporter, _manager));
     // Find to-do comments
     new ToDoFinder(errorReporter).findIn(unit);
     // pub analysis
     // TODO(danrubel/jwren) Commented out until bugs in the pub verifier are
     // fixed
     //    unit.accept(new PubVerifier(context, errorReporter));
   }
 }
 
@@ skipping 3474 matching lines @@
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void _performConstantEvaluation() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       ConstantValueComputer computer = new ConstantValueComputer(
           analysisContext,
           _typeProvider,
-          _typeSystem,
-          analysisContext.declaredVariables);
+          analysisContext.declaredVariables,
+          null,
+          _typeSystem);
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             if (unit != null) {
               computer.add(unit, source, library.librarySource);
             }
           } on AnalysisException catch (exception, stackTrace) {
             AnalysisEngine.instance.logger.logError(
                 "Internal Error: Could not access AST for ${source.fullName} during constant evaluation",
                 new CaughtException(exception, stackTrace));
           }
         }
       }
       computer.computeValues();
       // As a temporary workaround for issue 21572, run ConstantVerifier now.
       // TODO(paulberry): remove this workaround once issue 21572 is fixed.
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             ErrorReporter errorReporter =
                 new ErrorReporter(_errorListener, source);
             ConstantVerifier constantVerifier = new ConstantVerifier(
                 errorReporter,
                 library.libraryElement,
                 _typeProvider,
-                _typeSystem,
                 analysisContext.declaredVariables);
             unit.accept(constantVerifier);
           } on AnalysisException catch (exception, stackTrace) {
             AnalysisEngine.instance.logger.logError(
                 "Internal Error: Could not access AST for ${source.fullName} "
                 "during constant verification",
                 new CaughtException(exception, stackTrace));
           }
         }
       }
@@ skipping 12 matching lines @@
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
         ast.accept(new VariableResolverVisitor(library.libraryElement, source,
             _typeProvider, library.errorListener,
             nameScope: library.libraryScope));
         ResolverVisitorFactory visitorFactory =
             analysisContext.resolverVisitorFactory;
         ResolverVisitor visitor = visitorFactory != null
             ? visitorFactory(library, source, _typeProvider)
             : new ResolverVisitor(library.libraryElement, source, _typeProvider,
-                _typeSystem, library.errorListener,
+                library.errorListener,
                 nameScope: library.libraryScope,
                 inheritanceManager: library.inheritanceManager);
         ast.accept(visitor);
       }
     });
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
@@ skipping 422 matching lines @@
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void _performConstantEvaluation() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       ConstantValueComputer computer = new ConstantValueComputer(
           analysisContext,
           _typeProvider,
-          _typeSystem,
-          analysisContext.declaredVariables);
+          analysisContext.declaredVariables,
+          null,
+          _typeSystem);
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit
             in library.resolvableCompilationUnits) {
           CompilationUnit ast = unit.compilationUnit;
           if (ast != null) {
             computer.add(ast, unit.source, library.librarySource);
           }
         }
       }
       computer.computeValues();
       // As a temporary workaround for issue 21572, run ConstantVerifier now.
       // TODO(paulberry): remove this workaround once issue 21572 is fixed.
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit
             in library.resolvableCompilationUnits) {
           CompilationUnit ast = unit.compilationUnit;
           ErrorReporter errorReporter =
               new ErrorReporter(_errorListener, unit.source);
           ConstantVerifier constantVerifier = new ConstantVerifier(
               errorReporter,
               library.libraryElement,
               _typeProvider,
-              _typeSystem,
               analysisContext.declaredVariables);
           ast.accept(constantVerifier);
         }
       }
     });
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
@@ skipping 15 matching lines @@
    */
   void _resolveReferencesAndTypesInLibrary(ResolvableLibrary library) {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (ResolvableCompilationUnit unit
           in library.resolvableCompilationUnits) {
         Source source = unit.source;
         CompilationUnit ast = unit.compilationUnit;
         ast.accept(new VariableResolverVisitor(library.libraryElement, source,
             _typeProvider, library.libraryScope.errorListener,
             nameScope: library.libraryScope));
-        ResolverVisitor visitor = new ResolverVisitor(
-            library.libraryElement,
-            source,
-            _typeProvider,
-            _typeSystem,
-            library._libraryScope.errorListener,
+        ResolverVisitor visitor = new ResolverVisitor(library.libraryElement,
+            source, _typeProvider, library._libraryScope.errorListener,
             nameScope: library._libraryScope,
             inheritanceManager: library.inheritanceManager);
         ast.accept(visitor);
       }
     });
   }
 
   /**
    * Report that the async library could not be resolved in the given
    * [analysisContext] and throw an exception.  [asyncLibrarySource] is the source
@@ skipping 728 matching lines @@
    * listener that will be informed of any errors that are found during
    * resolution. The [nameScope] is the scope used to resolve identifiers in the
    * node that will first be visited.  If `null` or unspecified, a new
    * [LibraryScope] will be created based on [definingLibrary] and
    * [typeProvider]. The [inheritanceManager] is used to perform inheritance
    * lookups.  If `null` or unspecified, a new [InheritanceManager] will be
    * created based on [definingLibrary]. The [typeAnalyzerFactory] is used to
    * create the type analyzer.  If `null` or unspecified, a type analyzer of
    * type [StaticTypeAnalyzer] will be created.
    */
-  PartialResolverVisitor(
-      LibraryElement definingLibrary,
-      Source source,
-      TypeProvider typeProvider,
-      TypeSystem typeSystem,
-      AnalysisErrorListener errorListener,
+  PartialResolverVisitor(LibraryElement definingLibrary, Source source,
+      TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope,
       InheritanceManager inheritanceManager,
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : strongMode = definingLibrary.context.analysisOptions.strongMode,
-        super(definingLibrary, source, typeProvider, typeSystem,
+        super(definingLibrary, source, typeProvider,
             new DisablableErrorListener(errorListener));
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     if (_shouldBeSkipped(node)) {
       return null;
     }
     return super.visitBlockFunctionBody(node);
   }
 
@@ skipping 611 matching lines @@
   /**
    * The object used to resolve the element associated with the current node.
    */
   ElementResolver elementResolver;
 
   /**
    * The object used to compute the type associated with the current node.
    */
   StaticTypeAnalyzer typeAnalyzer;
 
+  /*
+  * The type system in use during resolution.
+  */
+  TypeSystem typeSystem;
+
   /**
    * The class element representing the class containing the current node,
    * or `null` if the current node is not contained in a class.
    */
   ClassElement enclosingClass = null;
 
   /**
    * The class declaration representing the class containing the current node, or `null` if
    * the current node is not contained in a class.
    */
@@ skipping 47 matching lines @@
    * listener that will be informed of any errors that are found during
    * resolution. The [nameScope] is the scope used to resolve identifiers in the
    * node that will first be visited.  If `null` or unspecified, a new
    * [LibraryScope] will be created based on [definingLibrary] and
    * [typeProvider]. The [inheritanceManager] is used to perform inheritance
    * lookups.  If `null` or unspecified, a new [InheritanceManager] will be
    * created based on [definingLibrary]. The [typeAnalyzerFactory] is used to
    * create the type analyzer.  If `null` or unspecified, a type analyzer of
    * type [StaticTypeAnalyzer] will be created.
    */
-  ResolverVisitor(
-      LibraryElement definingLibrary,
-      Source source,
-      TypeProvider typeProvider,
-      TypeSystem typeSystem,
-      AnalysisErrorListener errorListener,
+  ResolverVisitor(LibraryElement definingLibrary, Source source,
+      TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope,
       InheritanceManager inheritanceManager,
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     if (inheritanceManager == null) {
       this._inheritanceManager = new InheritanceManager(definingLibrary);
     } else {
       this._inheritanceManager = inheritanceManager;
     }
     this.elementResolver = new ElementResolver(this);
+    this.typeSystem = definingLibrary.context.typeSystem;
     if (typeAnalyzerFactory == null) {
-      this.typeAnalyzer = new StaticTypeAnalyzer(this, typeSystem);
+      this.typeAnalyzer = new StaticTypeAnalyzer(this);
     } else {
       this.typeAnalyzer = typeAnalyzerFactory(this);
     }
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    *
    * Deprecated.  Please use unnamed constructor instead.
    */
   @deprecated
-  ResolverVisitor.con1(Library library, Source source,
-      TypeProvider typeProvider, TypeSystem typeSystem,
+  ResolverVisitor.con1(
+      Library library, Source source, TypeProvider typeProvider,
       {StaticTypeAnalyzerFactory typeAnalyzerFactory})
-      : this(library.libraryElement, source, typeProvider, typeSystem,
-            library.errorListener,
+      : this(
+            library.libraryElement, source, typeProvider, library.errorListener,
             nameScope: library.libraryScope,
             inheritanceManager: library.inheritanceManager,
             typeAnalyzerFactory: typeAnalyzerFactory);
 
   /**
    * Return the element representing the function containing the current node, or `null` if
    * the current node is not contained in a function.
    *
    * @return the element representing the function containing the current node
    */
@@ skipping 5385 matching lines @@
 
 class _ConstantVerifier_validateInitializerExpression extends ConstantVisitor {
   final ConstantVerifier verifier;
 
   List<ParameterElement> parameterElements;
 
   TypeSystem _typeSystem;
 
   _ConstantVerifier_validateInitializerExpression(
       TypeProvider typeProvider,
-      TypeSystem typeSystem,
       ErrorReporter errorReporter,
       this.verifier,
       this.parameterElements,
-      DeclaredVariables declaredVariables)
-      : _typeSystem = typeSystem,
+      DeclaredVariables declaredVariables,
+      {TypeSystem typeSystem})
+      : _typeSystem = (typeSystem != null) ? typeSystem : new TypeSystemImpl(),
         super(
-            new ConstantEvaluationEngine(
-                typeProvider, typeSystem, declaredVariables),
+            new ConstantEvaluationEngine(typeProvider, declaredVariables,
+                typeSystem: typeSystem),
             errorReporter);
 
   @override
   DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         DartType type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
@@ skipping 138 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }