Tighten up a bunch of types in test.dart.

tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 397 matching lines @@
   String createPubspecCheckoutDirectory(Path directoryOfPubspecYaml) {
     var sdk = configuration['use_sdk'] ? 'sdk' : '';
     return createGeneratedTestDirectoryHelper(
         "pubspec_checkouts", sdk, directoryOfPubspecYaml, "");
   }
 
   String createPubPackageBuildsDirectory(Path directoryOfPubspecYaml) {
     return createGeneratedTestDirectoryHelper(
         "pub_package_builds", 'public_packages', directoryOfPubspecYaml, "");
   }
-
-  /**
-   * Helper function for discovering the packages in the dart repository.
-   */
-  Future<List> listDir(Path path, Function isValid) {
-    var dir = new Directory(path.toNativePath());
-    return dir.exists().then((exists) {
-      if (!exists) return [];
-      return dir
-          .list(recursive: false)
-          .where((fse) => fse is Directory)
-          .map((FileSystemEntity entity) {
-            var directory = entity as Directory;
-            var fullPath = directory.absolute.path;
-            var packageName = new Path(fullPath).filename;
-            if (isValid(packageName)) {
-              return [packageName, path.append(packageName).toNativePath()];
-            }
-            return null;
-          })
-          .where((name) => name != null)
-          .toList();
-    });
-  }
 }
 
 Future<Iterable<String>> ccTestLister(String runnerPath) {
   return Process.run(runnerPath, ["--list"]).then((ProcessResult result) {
     if (result.exitCode != 0) {
       throw "Failed to list tests: '$runnerPath --list'. "
           "Process exited with ${result.exitCode}";
     }
     return result.stdout
         .split('\n')
         .map((line) => line.trim())
-        .where((name) => name.length > 0);
+        .where((name) => name.isNotEmpty);
   });
 }
 
 /**
  * A specialized [TestSuite] that runs tests written in C to unit test
  * the Dart virtual machine and its API.
  *
  * The tests are compiled into a monolithic executable by the build step.
  * The executable lists its tests when run with the --list command line flag.
  * Individual tests are run by specifying them on the command line.
@@ skipping 105 matching lines @@
  * directory, and creates [TestCase]s that compile and/or run them.
  */
 class StandardTestSuite extends TestSuite {
   final Path suiteDir;
   final List<String> statusFilePaths;
   TestExpectations testExpectations;
   List<TestInformation> cachedTests;
   final Path dartDir;
   Predicate<String> isTestFilePredicate;
   final bool listRecursively;
-  final extraVmOptions;
+  final List<String> extraVmOptions;
   List<Uri> _dart2JsBootstrapDependencies;
 
   StandardTestSuite(Map configuration, String suiteName, Path suiteDirectory,
       this.statusFilePaths,
       {this.isTestFilePredicate, bool recursive: false})
       : dartDir = TestUtils.dartDir,
         listRecursively = recursive,
         suiteDir = TestUtils.dartDir.join(suiteDirectory),
         extraVmOptions = TestUtils.getExtraVmOptions(configuration),
         super(configuration, suiteName) {
@@ skipping 69 matching lines @@
 
   List<String> additionalOptions(Path filePath) => [];
 
   forEachTest(Function onTest, Map testCache, [VoidFunction onDone]) async {
     await updateDartium();
     doTest = onTest;
     testExpectations = await readExpectations();
 
     // Check if we have already found and generated the tests for this suite.
     if (!testCache.containsKey(suiteName)) {
-      cachedTests = testCache[suiteName] = [];
+      cachedTests = testCache[suiteName] = <TestInformation>[];
       await enqueueTests();
     } else {
       for (var info in testCache[suiteName]) {
         enqueueTestCaseFromTestInformation(info);
       }
     }
     testExpectations = null;
     cachedTests = null;
     doTest = null;
     if (onDone != null) onDone();
@@ skipping 163 matching lines @@
   }
 
   void enqueueStandardTest(List<Command> baseCommands, TestInformation info,
       String testName, Set<Expectation> expectations) {
     var commonArguments =
         commonArgumentsFromFile(info.filePath, info.optionsFromFile);
 
     List<List<String>> vmOptionsList = getVmOptions(info.optionsFromFile);
     assert(!vmOptionsList.isEmpty);
 
-    for (var vmOptionsVarient = 0;
-        vmOptionsVarient < vmOptionsList.length;
-        vmOptionsVarient++) {
-      var vmOptions = vmOptionsList[vmOptionsVarient];
+    for (var vmOptionsVariant = 0;
+        vmOptionsVariant < vmOptionsList.length;
+        vmOptionsVariant++) {
+      var vmOptions = vmOptionsList[vmOptionsVariant];
       var allVmOptions = vmOptions;
       if (!extraVmOptions.isEmpty) {
         allVmOptions = new List.from(vmOptions)..addAll(extraVmOptions);
       }
 
       var commands = baseCommands.toList();
       commands.addAll(
-          makeCommands(info, vmOptionsVarient, allVmOptions, commonArguments));
+          makeCommands(info, vmOptionsVariant, allVmOptions, commonArguments));
       enqueueNewTestCase(new TestCase(
           '$suiteName/$testName', commands, configuration, expectations,
           isNegative: isNegative(info), info: info));
     }
   }
 
   bool expectCompileError(TestInformation info) {
     return info.hasCompileError ||
         (configuration['checked'] && info.hasCompileErrorIfChecked);
   }
 
   bool isNegative(TestInformation info) {
     bool negative = expectCompileError(info) ||
         (configuration['checked'] && info.isNegativeIfChecked);
     if (info.hasRuntimeError && hasRuntime) {
       negative = true;
     }
     return negative;
   }
 
-  List<Command> makeCommands(
-      TestInformation info, int vmOptionsVarient, var vmOptions, var args) {
-    List<Command> commands = <Command>[];
-    CompilerConfiguration compilerConfiguration =
-        new CompilerConfiguration(configuration);
+  List<Command> makeCommands(TestInformation info, int vmOptionsVarient,
+      List<String> vmOptions, List<String> args) {
+    var commands = <Command>[];
+    var compilerConfiguration = new CompilerConfiguration(configuration);
     List<String> sharedOptions = info.optionsFromFile['sharedOptions'];
 
-    List<String> compileTimeArguments = <String>[];
+    var compileTimeArguments = <String>[];
     String tempDir;
     if (compilerConfiguration.hasCompiler) {
       compileTimeArguments = compilerConfiguration.computeCompilerArguments(
           vmOptions, sharedOptions, args);
       // Avoid doing this for analyzer.
       var path = info.filePath;
       if (vmOptionsVarient != 0) {
         // Ensure a unique directory for each test case.
         path = path.join(new Path(vmOptionsVarient.toString()));
       }
       tempDir = createCompilationOutputDirectory(path);
 
       List<String> otherResources = info.optionsFromFile['otherResources'];
-      for (String name in otherResources) {
-        Path namePath = new Path(name);
-        Path fromPath = info.filePath.directoryPath.join(namePath);
+      for (var name in otherResources) {
+        var namePath = new Path(name);
+        var fromPath = info.filePath.directoryPath.join(namePath);
         new File('$tempDir/$name').parent.createSync(recursive: true);
         new File(fromPath.toNativePath()).copySync('$tempDir/$name');
       }
     }
 
     CommandArtifact compilationArtifact =
         compilerConfiguration.computeCompilationArtifact(
             buildDir,
             tempDir,
             CommandBuilder.instance,
@@ skipping 118 matching lines @@
    * JavaScript.  This function creates a working directory to hold the
    * JavaScript version of the test, and copies the appropriate framework
    * files to that directory.  It creates a [BrowserTestCase], which has
    * two sequential steps to be run by the [ProcessQueue] when the test is
    * executed: a compilation step and an execution step, both with the
    * appropriate executable and arguments. The [expectations] object can be
    * either a Set<String> if the test is a regular test, or a Map<String
    * subTestName, Set<String>> if we are running a browser multi-test (one
    * compilation and many browser runs).
    */
-  void enqueueBrowserTest(List<Command> baseCommands, Path packageRoot,
-      Path packages, TestInformation info, String testName, expectations) {
+  void enqueueBrowserTest(
+      List<Command> baseCommands,
+      Path packageRoot,
+      Path packages,
+      TestInformation info,
+      String testName,
+      /* Set<Expectation> | Map<String, Set<Expectation>> */ dynamic
+          expectations) {
     RegExp badChars = new RegExp('[-=/]');
     List VmOptionsList = getVmOptions(info.optionsFromFile);
     bool multipleOptions = VmOptionsList.length > 1;
     for (var vmOptions in VmOptionsList) {
       String optionsName =
           multipleOptions ? vmOptions.join('-').replaceAll(badChars, '') : '';
       String tempDir = createOutputDirectory(info.filePath, optionsName);
       enqueueBrowserTestWithOptions(baseCommands, packageRoot, packages, info,
           testName, expectations, vmOptions, tempDir);
     }
   }
 
   void enqueueBrowserTestWithOptions(
       List<Command> baseCommands,
       Path packageRoot,
       Path packages,
       TestInformation info,
       String testName,
-      expectations,
+      /* Set<Expectation> | Map<String, Set<Expectation>> */ expectations,
       List<String> vmOptions,
       String tempDir) {
     // TODO(Issue 14651): If we're on dartium, we need to pass [packageRoot]
     // on to the browser (it may be test specific).
 
     Path filePath = info.filePath;
     String filename = filePath.toString();
 
     final String compiler = configuration['compiler'];
     final String runtime = configuration['runtime'];
@@ skipping 156 matching lines @@
       // Create BrowserTestCase and queue it.
       var fullTestName = multitest ? '$testName/$subtestName' : testName;
       var expectation = multitest ? expectations[fullTestName] : expectations;
       var testCase = new BrowserTestCase('$suiteName/$fullTestName', commandSet,
           configuration, expectation, info, isNegative(info), fullHtmlPath);
 
       enqueueNewTestCase(testCase);
     }
   }
 
-  void enqueueHtmlTest(
-      HtmlTestInformation info, String testName, expectations) {
+  void enqueueHtmlTest(HtmlTestInformation info, String testName,
+      Set<Expectation> expectations) {
     final String compiler = configuration['compiler'];
     final String runtime = configuration['runtime'];
     // Html tests work only with the browser controller.
     if (!TestUtils.isBrowserRuntime(runtime) || runtime == 'drt') {
       return;
     }
     bool compileToJS = (compiler == 'dart2js');
 
     final Path filePath = info.filePath;
     final String tempDir = createOutputDirectory(filePath, '');
     final Uri tempUri = new Uri.file('$tempDir/');
     String contents = htmlTest.getContents(info, compileToJS);
-    final commands = [];
+    final commands = <Command>[];
 
     void Fail(String message) {
       var msg = "$message: ${info.filePath}";
       DebugLogger.warning(msg);
       contents = htmlTest.makeFailingHtmlFile(msg);
     }
 
     if (info.scripts.length > 0) {
       Uri testUri = new Uri.file(filePath.toNativePath());
       for (String scriptPath in info.scripts) {
@@ skipping 34 matching lines @@
         fullHtmlPath, configuration, info.expectedMessages, !isNegative(info)));
     String testDisplayName = '$suiteName/$testName';
     var testCase = new BrowserTestCase(testDisplayName, commands, configuration,
         expectations, info, isNegative(info), fullHtmlPath);
     enqueueNewTestCase(testCase);
     return;
   }
 
   /** Helper to create a compilation command for a single input file. */
   Command _compileCommand(String inputFile, String outputFile, String compiler,
-      String dir, optionsFromFile) {
+      String dir, Map optionsFromFile) {
     assert(compiler == 'dart2js');
     List<String> args;
     if (compilerPath.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args = [compilerPath];
     } else {
       args = [];
     }
     args.addAll(TestUtils.standardOptions(configuration));
     String packages = packagesArgument(
         optionsFromFile['packageRoot'], optionsFromFile['packages']);
     if (packages != null) args.add(packages);
     args.add('--out=$outputFile');
     args.add(inputFile);
     List<String> options = optionsFromFile['sharedOptions'];
     if (options != null) args.addAll(options);
     return CommandBuilder.instance.getCompilationCommand(
         compiler,
         outputFile,
         !useSdk,
         dart2JsBootstrapDependencies,
         compilerPath,
         args,
         environmentOverrides);
   }
 
   /** Helper to create a Polymer deploy command for a single HTML file. */
   Command _polymerDeployCommand(
-      String inputFile, String outputDir, optionsFromFile) {
+      String inputFile, String outputDir, Map optionsFromFile) {
     List<String> args = [];
     String packages = packagesArgument(
         optionsFromFile['packageRoot'], optionsFromFile['packages']);
     if (packages != null) args.add(packages);
     args
       ..add('package:polymer/deploy.dart')
       ..add('--test')
       ..add(inputFile)
       ..add('--out')
       ..add(outputDir)
@@ skipping 167 matching lines @@
     // TODO(gram) Clean these up once the old directives are not supported.
     RegExp domImportRegExp = new RegExp(
         r"^[#]?import.*dart:(html|web_audio|indexed_db|svg|web_sql)",
         multiLine: true);
 
     var bytes = new File(filePath.toNativePath()).readAsBytesSync();
     String contents = decodeUtf8(bytes);
     bytes = null;
 
     // Find the options in the file.
-    List<List> result = new List<List>();
+    var result = <List<String>>[];
     List<String> dartOptions;
     List<String> sharedOptions;
     String packageRoot;
     String packages;
 
     Iterable<Match> matches = testOptionsRegExp.allMatches(contents);
     for (var match in matches) {
       result.add(match[1].split(' ').where((e) => e != '').toList());
     }
     if (result.isEmpty) result.add([]);
@@ skipping 117 matching lines @@
       'dart_precompiled',
       'vm',
       'drt',
       'dartium',
       'ContentShellOnAndroid',
       'DartiumOnAndroid'
     ];
     var needsVmOptions = COMPILERS.contains(configuration['compiler']) &&
         RUNTIMES.contains(configuration['runtime']);
     if (!needsVmOptions) return [[]];
-    final vmOptions = optionsFromFile['vmOptions'];
-    return vmOptions;
+    return optionsFromFile['vmOptions'];
   }
 
   /**
    * Read options from a co19 test file.
    *
    * The reason this is different from [readOptionsFromFile] is that
    * co19 is developed based on a contract which defines certain test
    * tags. These tags may appear unused, but should not be removed
    * without consulting with the co19 team.
    *
@@ skipping 33 matching lines @@
 
 /// Used for testing packages in on off settings, i.e., we pass in the actual
 /// directory that we want to test.
 class PKGTestSuite extends StandardTestSuite {
   PKGTestSuite(Map configuration, Path directoryPath)
       : super(configuration, directoryPath.filename, directoryPath,
             ["$directoryPath/.status"],
             isTestFilePredicate: (f) => f.endsWith('_test.dart'),
             recursive: true);
 
-  void enqueueBrowserTest(List<Command> baseCommands, Path packageRoot,
-      packages, TestInformation info, String testName, expectations) {
+  void enqueueBrowserTest(
+      List<Command> baseCommands,
+      Path packageRoot,
+      packages,
+      TestInformation info,
+      String testName,
+      /* Set<Expectation> | Map<String, Set<Expectation>> */ dynamic
+          expectations) {
     String runtime = configuration['runtime'];
     Path filePath = info.filePath;
     Path dir = filePath.directoryPath;
     String nameNoExt = filePath.filenameWithoutExtension;
     Path customHtmlPath = dir.append('$nameNoExt.html');
     File customHtml = new File(customHtmlPath.toNativePath());
     if (!customHtml.existsSync()) {
       super.enqueueBrowserTest(
           baseCommands, packageRoot, packages, info, testName, expectations);
     } else {
       Path relativeHtml = customHtmlPath.relativeTo(TestUtils.dartDir);
-      List<Command> commands = []..addAll(baseCommands);
+      var commands = baseCommands.toList();
       var fullPath = _createUrlPathFromFile(customHtmlPath);
 
       commands.add(CommandBuilder.instance.getBrowserTestCommand(
           runtime, fullPath, configuration, !isNegative(info)));
       String testDisplayName = '$suiteName/$testName';
       enqueueNewTestCase(new BrowserTestCase(
           testDisplayName,
           commands,
           configuration,
           expectations,
@@ skipping 101 matching lines @@
     }
     return _cache[path];
   }
 }
 
 class TestUtils {
   /**
    * Any script using TestUtils must set dartDirUri to a file:// URI
    * pointing to the root of the Dart checkout.
    */
-  static setDartDirUri(uri) {
+  static void setDartDirUri(Uri uri) {
     dartDirUri = uri;
     dartDir = new Path(uri.toFilePath());
   }
 
   static Random rand = new Random.secure();
   static Uri dartDirUri;
   static Path dartDir;
   static LastModifiedCache lastModifiedCache = new LastModifiedCache();
   static ExistsCache existsCache = new ExistsCache();
   static Path currentWorkingDirectory = new Path(Directory.current.path);
@@ skipping 76 matching lines @@
           throw new Exception('Can\'t delete path $native_path. '
               'This path might be too long');
         }
       });
     } else {
       var dir = new Directory(path);
       return dir.delete(recursive: true);
     }
   }
 
-  static deleteTempSnapshotDirectory(Map configuration) {
+  static void deleteTempSnapshotDirectory(Map configuration) {
     if (configuration['compiler'] == 'dart2app' ||
         configuration['compiler'] == 'dart2appjit' ||
         configuration['compiler'] == 'precompiler') {
       var checked = configuration['checked'] ? '-checked' : '';
       var strong = configuration['strong'] ? '-strong' : '';
       var minified = configuration['minified'] ? '-minified' : '';
       var csp = configuration['csp'] ? '-csp' : '';
       var sdk = configuration['use_sdk'] ? '-sdk' : '';
       var dirName = "${configuration['compiler']}"
           "$checked$strong$minified$csp$sdk";
@@ skipping 118 matching lines @@
 
   static String configurationDir(Map configuration) {
     // This returns the correct configuration directory (the last component
     // of the output directory path) for regular dart checkouts.
     // Dartium checkouts use the --build-directory option to pass in the
     // correct build directory explicitly.
     // We allow our code to have been cross compiled, i.e., that there
     // is an X in front of the arch. We don't allow both a cross compiled
     // and a normal version to be present (except if you specifically pass
     // in the build_directory).
-    var mode;
+    String mode;
     switch (configuration['mode']) {
       case 'debug':
         mode = 'Debug';
         break;
       case 'release':
         mode = 'Release';
         break;
       case 'product':
         mode = 'Product';
         break;
       default:
         throw 'Unrecognized mode configuration: ${configuration['mode']}';
     }
-    var os;
+    String os;
     switch (configuration['system']) {
       case 'android':
         os = 'Android';
         break;
       case 'fuchsia':
       case 'linux':
       case 'macos':
       case 'windows':
         os = '';
         break;
@@ skipping 110 matching lines @@
       }
       if (path.length > WINDOWS_SHORTEN_PATH_LIMIT) {
         ++shortNameCounter;
         var pathEnd = path.substring(path.length - WINDOWS_PATH_END_LENGTH);
         path = "short${shortNameCounter}_$pathEnd";
       }
     }
     return path;
   }
 }