Make type system changes backwards compatible

pkg/analyzer/test/generated/all_the_rest_test.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.all_the_rest_test;
 
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 851 matching lines @@
     expect(unit, isNotNull);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember declaration = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
         TopLevelVariableDeclaration, declaration);
     NodeList<VariableDeclaration> variables =
         (declaration as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
     ConstantEvaluator evaluator = new ConstantEvaluator(
-        source, analysisContext.typeProvider, analysisContext.typeSystem);
+        source, analysisContext.typeProvider,
+        typeSystem: analysisContext.typeSystem);
     return evaluator.evaluate(variables[0].initializer);
   }
 }
 
 @reflectiveTest
 class ConstantFinderTest extends EngineTestCase {
   AstNode _node;
   TypeProvider _typeProvider;
   AnalysisContext _context;
   Source _source;
@@ skipping 1471 matching lines @@
     ConstTopLevelVariableElementImpl varElement = varDecl.element;
     return varElement.evaluationResult;
   }
 
   ConstantValueComputer _makeConstantValueComputer() {
     ConstantEvaluationValidator_ForTest validator =
         new ConstantEvaluationValidator_ForTest();
     validator.computer = new ConstantValueComputer(
         analysisContext2,
         analysisContext2.typeProvider,
-        analysisContext2.typeSystem,
         analysisContext2.declaredVariables,
-        validator);
+        validator,
+        analysisContext2.typeSystem);
     return validator.computer;
   }
 
   void _validate(bool shouldBeValid, VariableDeclarationList declarationList) {
     for (VariableDeclaration declaration in declarationList.variables) {
       VariableElementImpl element = declaration.element as VariableElementImpl;
       expect(element, isNotNull);
       EvaluationResultImpl result = element.evaluationResult;
       if (shouldBeValid) {
         expect(result.value, isNotNull);
@@ skipping 10 matching lines @@
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.integer(0);
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(false), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     _assertValue(
         0,
         expression.accept(new ConstantVisitor(
-            new ConstantEvaluationEngine(new TestTypeProvider(),
-                new TypeSystemImpl(), new DeclaredVariables()),
+            new ConstantEvaluationEngine(
+                new TestTypeProvider(), new DeclaredVariables(),
+                typeSystem: new TypeSystemImpl()),
             errorReporter)));
     errorListener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_nonBooleanCondition() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.integer(0);
     NullLiteral conditionExpression = AstFactory.nullLiteral();
     ConditionalExpression expression = AstFactory.conditionalExpression(
         conditionExpression, thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     DartObjectImpl result = expression.accept(new ConstantVisitor(
-        new ConstantEvaluationEngine(new TestTypeProvider(),
-            new TypeSystemImpl(), new DeclaredVariables()),
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables(),
+            typeSystem: new TypeSystemImpl()),
         errorReporter));
     expect(result, isNull);
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
   }
 
   void test_visitConditionalExpression_nonConstantElse() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.identifier3("x");
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(true), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     DartObjectImpl result = expression.accept(new ConstantVisitor(
-        new ConstantEvaluationEngine(new TestTypeProvider(),
-            new TypeSystemImpl(), new DeclaredVariables()),
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables(),
+            typeSystem: new TypeSystemImpl()),
         errorReporter));
     expect(result, isNull);
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTANT]);
   }
 
   void test_visitConditionalExpression_nonConstantThen() {
     Expression thenExpression = AstFactory.identifier3("x");
     Expression elseExpression = AstFactory.integer(0);
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(true), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     DartObjectImpl result = expression.accept(new ConstantVisitor(
-        new ConstantEvaluationEngine(new TestTypeProvider(),
-            new TypeSystemImpl(), new DeclaredVariables()),
+        new ConstantEvaluationEngine(
+            new TestTypeProvider(), new DeclaredVariables(),
+            typeSystem: new TypeSystemImpl()),
         errorReporter));
     expect(result, isNull);
     errorListener
         .assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTANT]);
   }
 
   void test_visitConditionalExpression_true() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.integer(0);
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(true), thenExpression, elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     _assertValue(
         1,
         expression.accept(new ConstantVisitor(
-            new ConstantEvaluationEngine(new TestTypeProvider(),
-                new TypeSystemImpl(), new DeclaredVariables()),
+            new ConstantEvaluationEngine(
+                new TestTypeProvider(), new DeclaredVariables(),
+                typeSystem: new TypeSystemImpl()),
             errorReporter)));
     errorListener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_className() {
     CompilationUnit compilationUnit = resolveSource('''
 const a = C;
 class C {}
 ''');
     DartObjectImpl result = _evaluateConstant(compilationUnit, 'a', null);
@@ skipping 52 matching lines @@
   }
 
   DartObjectImpl _evaluateConstant(CompilationUnit compilationUnit, String name,
       Map<String, DartObjectImpl> lexicalEnvironment) {
     Source source = compilationUnit.element.source;
     Expression expression =
         findTopLevelConstantExpression(compilationUnit, name);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     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,
         lexicalEnvironment: lexicalEnvironment));
     errorListener.assertNoErrors();
     return result;
   }
 }
 
 @reflectiveTest
 class ContentCacheTest {
   void test_setContents() {
@@ skipping 6748 matching lines @@
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }