Replace reset() arguments with resetWith() invocation.

pkg/analyzer/test/generated/resolver_test_case.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.generated.resolver_test_case;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisResult;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:test/test.dart';
 
 import '../src/dart/analysis/physical_sdk.dart' as physical_sdk;
 import 'analysis_context_factory.dart';
 import 'test_support.dart';
 
 /**
@@ skipping 601 matching lines @@
         }
       }
     }
     return null;
     // Not found
   }
 
   /**
    * Re-create the analysis context being used by the test case.
    */
-  void reset({List<List<String>> packages}) {
+  void reset() {
+    resetWith();
+  }
+
+  /**
+   * Re-create the analysis context being used by the test with the either given
+   * [options] or [packages].
+   */
+  void resetWith({AnalysisOptions options, List<List<String>> packages}) {
+    if (options != null && packages != null) {
+      fail('Only packages or options can be specified.');
+    }
     if (enableNewAnalysisDriver) {
-      PerformanceLog log = new PerformanceLog(_logBuffer);
-      AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
+      options ??= new AnalysisOptionsImpl();
+      DartSdk sdk =
+          options.strongMode ? physical_sdk.strongSdk : physical_sdk.sdk;
 
       List<UriResolver> resolvers = <UriResolver>[
-        new DartUriResolver(physical_sdk.sdk),
+        new DartUriResolver(sdk),
         new ResourceUriResolver(resourceProvider)
       ];
       if (packages != null) {
         var packageMap = <String, List<Folder>>{};
         packages.forEach((args) {
           String name = args[0];
           String path =
               resourceProvider.convertPath('/packages/$name/$name.dart');
           String content = args[1];
           File file = resourceProvider.newFile(path, content);
           packageMap[name] = <Folder>[file.parent];
         });
         resolvers.add(new PackageMapUriResolver(resourceProvider, packageMap));
       }
       SourceFactory sourceFactory = new SourceFactory(resolvers);
 
-      driver = new AnalysisDriver(
-          scheduler,
-          log,
-          resourceProvider,
-          new MemoryByteStore(),
-          _fileContentOverlay,
-          sourceFactory,
-          new AnalysisOptionsImpl());
+      PerformanceLog log = new PerformanceLog(_logBuffer);
+      AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
+      driver = new AnalysisDriver(scheduler, log, resourceProvider,
+          new MemoryByteStore(), _fileContentOverlay, sourceFactory, options);
       scheduler.start();
     } else {
       if (packages != null) {
         var packageMap = <String, String>{};
         packages.forEach((args) {
           String name = args[0];
           String content = args[1];
           packageMap['package:$name/$name.dart'] = content;
         });
         analysisContext2 = AnalysisContextFactory.contextWithCoreAndPackages(
             packageMap,
             resourceProvider: resourceProvider);
+      } else if (options != null) {
+        analysisContext2 = AnalysisContextFactory.contextWithCoreAndOptions(
+            options,
+            resourceProvider: resourceProvider);
       } else {
         analysisContext2 = AnalysisContextFactory.contextWithCore(
             resourceProvider: resourceProvider);
       }
     }
   }
 
   /**
-   * Re-create the analysis context being used by the test case and set the
-   * [options] in the newly created context to the given [options].
-   */
-  void resetWithOptions(AnalysisOptions options) {
-    // TODO(scheglov) remove duplication
-    if (enableNewAnalysisDriver) {
-      PerformanceLog log = new PerformanceLog(_logBuffer);
-      AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
-
-      List<UriResolver> resolvers = <UriResolver>[
-        new DartUriResolver(
-            options.strongMode ? physical_sdk.strongSdk : physical_sdk.sdk),
-        new ResourceUriResolver(resourceProvider)
-      ];
-      SourceFactory sourceFactory = new SourceFactory(resolvers);
-      driver = new AnalysisDriver(scheduler, log, resourceProvider,
-          new MemoryByteStore(), _fileContentOverlay, sourceFactory, options);
-      scheduler.start();
-    } else {
-      analysisContext2 = AnalysisContextFactory.contextWithCoreAndOptions(
-          options,
-          resourceProvider: resourceProvider);
-    }
-  }
-
-  /**
    * Given a library and all of its parts, resolve the contents of the library and the contents of
    * the parts. This assumes that the sources for the library and its parts have already been added
    * to the content provider using the method [addNamedSource].
    *
    * @param librarySource the source for the compilation unit that defines the library
    * @return the element representing the resolved library
    * @throws AnalysisException if the analysis could not be performed
    */
   LibraryElement resolve2(Source librarySource) =>
       analysisContext2.computeLibraryElement(librarySource);
@@ skipping 31 matching lines @@
     return null;
   }
 
   Future<Null> resolveWithAndWithoutExperimental(
       List<String> strSources,
       List<ErrorCode> codesWithoutExperimental,
       List<ErrorCode> codesWithExperimental) async {
     // Setup analysis context as non-experimental
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 //    options.enableDeferredLoading = false;
-    resetWithOptions(options);
+    resetWith(options: options);
     // Analysis and assertions
     Source source = await resolveSources(strSources);
     await computeAnalysisResult(source);
     assertErrors(source, codesWithoutExperimental);
     verify([source]);
     // Setup analysis context as experimental
     reset();
     // Analysis and assertions
     source = await resolveSources(strSources);
     await computeAnalysisResult(source);
@@ skipping 150 matching lines @@
     }
   }
 }
 
 class TestAnalysisResult {
   final Source source;
   final CompilationUnit unit;
   final List<AnalysisError> errors;
   TestAnalysisResult(this.source, this.unit, this.errors);
 }