Remove ConstantFinder constructor parameters.

pkg/analyzer/test/src/dart/constant/evaluation_test.dart

 // Copyright (c) 2016, 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.test.constant_test;
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 257 matching lines @@
       Source source = addSource(r'''
   const int a = c;
   const int b = a;
   const int c = b;''');
       LibraryElement libraryElement = resolve2(source);
       CompilationUnit unit =
           analysisContext.resolveCompilationUnit(source, libraryElement);
       analysisContext.computeErrors(source);
       expect(unit, isNotNull);
       ConstantValueComputer computer = _makeConstantValueComputer();
-      computer.add(unit, source, source);
+      computer.add(unit);
       computer.computeValues();
       NodeList<CompilationUnitMember> members = unit.declarations;
       expect(members, hasLength(3));
       _validate(false, (members[0] as TopLevelVariableDeclaration).variables);
       _validate(false, (members[1] as TopLevelVariableDeclaration).variables);
       _validate(false, (members[2] as TopLevelVariableDeclaration).variables);
     } finally {
       AnalysisEngine.instance.logger = Logger.NULL;
     }
   }
 
   void test_computeValues_dependentVariables() {
     Source source = addSource(r'''
 const int b = a;
 const int a = 0;''');
     LibraryElement libraryElement = resolve2(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit, source, source);
+    computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(2));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (members[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_empty() {
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.computeValues();
@@ skipping 14 matching lines @@
 const int b = a;
 const int d = c;''');
     LibraryElement libraryElement = resolve2(librarySource);
     CompilationUnit libraryUnit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(libraryUnit, isNotNull);
     CompilationUnit partUnit =
         analysisContext.resolveCompilationUnit(partSource, libraryElement);
     expect(partUnit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(libraryUnit, librarySource, librarySource);
-    computer.add(partUnit, partSource, librarySource);
+    computer.add(libraryUnit);
+    computer.add(partUnit);
     computer.computeValues();
     NodeList<CompilationUnitMember> libraryMembers = libraryUnit.declarations;
     expect(libraryMembers, hasLength(2));
     _validate(
         true, (libraryMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(
         true, (libraryMembers[1] as TopLevelVariableDeclaration).variables);
     NodeList<CompilationUnitMember> partMembers = libraryUnit.declarations;
     expect(partMembers, hasLength(2));
     _validate(true, (partMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (partMembers[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_singleVariable() {
     Source source = addSource("const int a = 0;");
     LibraryElement libraryElement = resolve2(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit, source, source);
+    computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     expect(members, hasLength(1));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_value_depends_on_enum() {
     Source source = addSource('''
 enum E { id0, id1 }
 const E e = E.id0;
 ''');
     LibraryElement libraryElement = resolve2(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit, source, source);
+    computer.add(unit);
     computer.computeValues();
     TopLevelVariableDeclaration declaration = unit.declarations
         .firstWhere((member) => member is TopLevelVariableDeclaration);
     _validate(true, declaration.variables);
   }
 
   void test_dependencyOnConstructor() {
     // x depends on "const A()"
     _assertProperDependencies(r'''
 class A {
@@ skipping 809 matching lines @@
   }
 
   void _assertProperDependencies(String sourceText,
       [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     Source source = addSource(sourceText);
     LibraryElement element = resolve2(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, element);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit, source, source);
+    computer.add(unit);
     computer.computeValues();
     assertErrors(source, expectedErrorCodes);
   }
 
   Map<String, DartObjectImpl> _assertType(
       EvaluationResultImpl result, String typeName) {
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.type.displayName, typeName);
     return value.fields;
@@ skipping 159 matching lines @@
     VariableDeclaration varDecl =
         findTopLevelDeclaration(compilationUnit, name);
     ConstTopLevelVariableElementImpl varElement = varDecl.element;
     return varElement.evaluationResult;
   }
 
   ConstantValueComputer _makeConstantValueComputer() {
     ConstantEvaluationValidator_ForTest validator =
         new ConstantEvaluationValidator_ForTest(analysisContext2);
     validator.computer = new ConstantValueComputer(
-        analysisContext2,
         analysisContext2.typeProvider,
         analysisContext2.declaredVariables,
         validator,
         analysisContext2.typeSystem);
     return validator.computer;
   }
 
   void _validate(bool shouldBeValid, VariableDeclarationList declarationList) {
     for (VariableDeclaration declaration in declarationList.variables) {
       VariableElementImpl element = declaration.element as VariableElementImpl;
@@ skipping 200 matching lines @@
     ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
     DartObjectImpl result = expression.accept(new ConstantVisitor(
         new ConstantEvaluationEngine(typeProvider, new DeclaredVariables(),
             typeSystem: typeSystem),
         errorReporter,
         lexicalEnvironment: lexicalEnvironment));
     errorListener.assertNoErrors();
     return result;
   }
 }