Make type system changes backwards compatible

pkg/analyzer/lib/src/generated/constant.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.constant;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
@@ skipping 224 matching lines @@
    */
   final ConstantEvaluationValidator validator;
 
   /**
    * Initialize a newly created [ConstantEvaluationEngine].  The [typeProvider]
    * is used to access known types.  [_declaredVariables] is the set of
    * variables declared on the command line using '-D'.  The [validator], if
    * given, is used to verify correct dependency analysis when running unit
    * tests.
    */
-  ConstantEvaluationEngine(
-      this.typeProvider, this.typeSystem, this._declaredVariables,
-      {ConstantEvaluationValidator validator})
+  ConstantEvaluationEngine(this.typeProvider, this._declaredVariables,
+      {ConstantEvaluationValidator validator, TypeSystem typeSystem})
       : validator = validator != null
             ? validator
-            : new ConstantEvaluationValidator_ForProduction();
+            : new ConstantEvaluationValidator_ForProduction(),
+        typeSystem = typeSystem != null ? typeSystem : new TypeSystemImpl();
 
   /**
    * Check that the arguments to a call to fromEnvironment() are correct. The
    * [arguments] are the AST nodes of the arguments. The [argumentValues] are
    * the values of the unnamed arguments. The [namedArgumentValues] are the
    * values of the named arguments. The [expectedDefaultValueType] is the
    * allowed type of the "defaultValue" parameter (if present). Note:
    * "defaultValue" is always allowed to be null. Return `true` if the arguments
    * are correct, `false` if there is an error.
    */
@@ skipping 891 matching lines @@
   /**
    * The type system primitives.
    */
   final TypeSystem _typeSystem;
 
   /**
    * Initialize a newly created evaluator to evaluate expressions in the given
    * [source]. The [typeProvider] is the type provider used to access known
    * types.
    */
-  ConstantEvaluator(this._source, this._typeProvider, this._typeSystem);
+  ConstantEvaluator(this._source, this._typeProvider, {TypeSystem typeSystem})
+      : _typeSystem = typeSystem != null ? typeSystem : new TypeSystemImpl();
 
   EvaluationResult evaluate(Expression expression) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
     DartObjectImpl result = expression.accept(new ConstantVisitor(
-        new ConstantEvaluationEngine(
-            _typeProvider, _typeSystem, new DeclaredVariables()),
+        new ConstantEvaluationEngine(_typeProvider, new DeclaredVariables(),
+            typeSystem: _typeSystem),
         errorReporter));
     if (result != null) {
       return EvaluationResult.forValue(result);
     }
     return EvaluationResult.forErrors(errorListener.errors);
   }
 }
 
 /**
  * A visitor used to traverse the AST structures of all of the compilation units
@@ skipping 122 matching lines @@
   final ConstantEvaluationEngine evaluationEngine;
 
   final AnalysisContext _context;
 
   /**
    * Initialize a newly created constant value computer. The [typeProvider] is
    * the type provider used to access known types. The [declaredVariables] is
    * the set of variables declared on the command line using '-D'.
    */
   ConstantValueComputer(this._context, TypeProvider typeProvider,
-      TypeSystem typeSystem, DeclaredVariables declaredVariables,
-      [ConstantEvaluationValidator validator])
+      DeclaredVariables declaredVariables,
+      [ConstantEvaluationValidator validator, TypeSystem typeSystem])
       : evaluationEngine = new ConstantEvaluationEngine(
-            typeProvider, typeSystem, declaredVariables,
-            validator: validator);
+            typeProvider, declaredVariables,
+            validator: validator, typeSystem: typeSystem);
 
   /**
    * Add the constants in the given compilation [unit] to the list of constants
    * whose value needs to be computed.
    */
   void add(CompilationUnit unit, Source source, Source librarySource) {
     ConstantFinder constantFinder =
         new ConstantFinder(_context, source, librarySource);
     unit.accept(constantFinder);
     _constantsToCompute.addAll(constantFinder.constantsToCompute);
@@ skipping 3973 matching lines @@
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }