Tighten up a bunch of types in test.dart.

tools/testing/dart/status_file_parser.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.
 
 library status_file_parser;
 
 import "dart:async";
 import "dart:convert" show LineSplitter, UTF8;
 import "dart:io";
 
 import "path.dart";
 import "status_expression.dart";
 
+typedef void Action();
+
 class Expectation {
   // Possible outcomes of running a test.
   static Expectation PASS = byName('Pass');
   static Expectation CRASH = byName('Crash');
   static Expectation TIMEOUT = byName('Timeout');
   static Expectation FAIL = byName('Fail');
 
   // Special 'FAIL' cases
   static Expectation RUNTIME_ERROR = byName('RuntimeError');
   static Expectation COMPILETIME_ERROR = byName('CompileTimeError');
@@ skipping 34 matching lines @@
     }
     return _AllExpectations[name];
   }
 
   // Keep a map of all possible Expectation objects, initialized lazily.
   static Map<String, Expectation> _AllExpectations;
   static void _initialize() {
     if (_AllExpectations == null) {
       _AllExpectations = new Map<String, Expectation>();
 
-      Expectation build(prettyName, {group: null, isMetaExpectation: false}) {
+      Expectation build(String prettyName,
+          {Expectation group, bool isMetaExpectation: false}) {
         var expectation = new Expectation._(prettyName,
             group: group, isMetaExpectation: isMetaExpectation);
         assert(!_AllExpectations.containsKey(expectation.name));
         return _AllExpectations[expectation.name] = expectation;
       }
 
       var fail = build("Fail");
       var crash = build("Crash");
       var timeout = build("Timeout");
       build("Pass");
@@ skipping 23 matching lines @@
     }
   }
 
   final String prettyName;
   final String name;
   final Expectation group;
   // Indicates whether this expectation cannot be a test outcome (i.e. it is a
   // "meta marker").
   final bool isMetaExpectation;
 
-  Expectation._(prettyName,
+  Expectation._(this.prettyName,
       {Expectation this.group: null, bool this.isMetaExpectation: false})
-      : prettyName = prettyName,
-        name = prettyName.toLowerCase();
+      : name = prettyName.toLowerCase();
 
   bool canBeOutcomeOf(Expectation expectation) {
     Expectation outcome = this;
     if (outcome == IGNORE) return true;
     while (outcome != null) {
       if (outcome == expectation) {
         return true;
       }
       outcome = outcome.group;
     }
@@ skipping 31 matching lines @@
 
   bool isEnabled(environment) =>
       condition == null || condition.evaluate(environment);
 
   String toString() {
     return "Section: $condition";
   }
 }
 
 Future<TestExpectations> ReadTestExpectations(
-    List<String> statusFilePaths, Map environment) {
+    List<String> statusFilePaths, Map<String, String> environment) {
   var testExpectations = new TestExpectations();
   return Future.wait(statusFilePaths.map((String statusFile) {
     return ReadTestExpectationsInto(testExpectations, statusFile, environment);
   })).then((_) => testExpectations);
 }
 
-Future ReadTestExpectationsInto(
-    TestExpectations expectations, String statusFilePath, environment) {
-  var completer = new Completer();
-  List<Section> sections = new List<Section>();
+Future ReadTestExpectationsInto(TestExpectations expectations,
+    String statusFilePath, Map<String, String> environment) {
+  var completer = new Completer<Null>();
+  var sections = <Section>[];
 
   void sectionsRead() {
     for (Section section in sections) {
       if (section.isEnabled(environment)) {
         for (var rule in section.testRules) {
           expectations.addRule(rule, environment);
         }
       }
     }
     completer.complete();
   }
 
   ReadConfigurationInto(new Path(statusFilePath), sections, sectionsRead);
   return completer.future;
 }
 
-void ReadConfigurationInto(Path path, sections, onDone) {
+void ReadConfigurationInto(Path path, List<Section> sections, Action onDone) {
   StatusFile statusFile = new StatusFile(path);
   File file = new File(path.toNativePath());
   if (!file.existsSync()) {
     throw new Exception('Cannot find test status file $path');
   }
   int lineNumber = 0;
   Stream<String> lines =
       file.openRead().transform(UTF8.decoder).transform(new LineSplitter());
 
   Section currentSection = new Section.always(statusFile, -1);
@@ skipping 56 matching lines @@
 
   bool get hasIssue => issue != null;
 
   String toString() => 'TestRule($name, $expression, $issue)';
 }
 
 class TestExpectations {
   // Only create one copy of each Set<Expectation>.
   // We just use .toString as a key, so we may make a few
   // sets that only differ in their toString element order.
-  static Map _cachedSets = new Map();
+  static Map<String, Set<Expectation>> _cachedSets = {};
 
-  Map _map;
+  Map<String, Set<Expectation>> _map;
   bool _preprocessed = false;
-  Map _regExpCache;
-  Map _keyToRegExps;
+  Map<String, RegExp> _regExpCache;
+  Map<String, List<RegExp>> _keyToRegExps;
 
   /**
    * Create a TestExpectations object. See the [expectations] method
    * for an explanation of matching.
    */
-  TestExpectations() : _map = new Map();
+  TestExpectations() : _map = {};
 
   /**
    * Add a rule to the expectations.
    */
-  void addRule(testRule, environment) {
+  void addRule(TestRule testRule, environment) {
     // Once we have started using the expectations we cannot add more
     // rules.
     if (_preprocessed) {
       throw "TestExpectations.addRule: cannot add more rules";
     }
     var names = testRule.expression.evaluate(environment);
     var expectations = names.map((name) => Expectation.byName(name));
-    _map.putIfAbsent(testRule.name, () => new Set()).addAll(expectations);
+    _map
+        .putIfAbsent(testRule.name, () => new Set<Expectation>())
+        .addAll(expectations);
   }
 
   /**
    * Compute the expectations for a test based on the filename.
    *
    * For every (key, expectation) pair. Match the key with the file
    * name. Return the union of the expectations for all the keys
    * that match.
    *
    * Normal matching splits the key and the filename into path
    * components and checks that the anchored regular expression
    * "^$keyComponent\$" matches the corresponding filename component.
    */
   Set<Expectation> expectations(String filename) {
-    var result = new Set();
+    var result = new Set<Expectation>();
     var splitFilename = filename.split('/');
 
     // Create mapping from keys to list of RegExps once and for all.
     _preprocessForMatching();
 
-    _map.forEach((key, expectation) {
-      List regExps = _keyToRegExps[key];
+    _map.forEach((key, Set<Expectation> expectations) {
+      List<RegExp> regExps = _keyToRegExps[key];
       if (regExps.length > splitFilename.length) return;
       for (var i = 0; i < regExps.length; i++) {
         if (!regExps[i].hasMatch(splitFilename[i])) return;
       }
       // If all components of the status file key matches the filename
       // add the expectations to the result.
-      result.addAll(expectation);
+      result.addAll(expectations);
     });
 
     // If no expectations were found the expectation is that the test
     // passes.
     if (result.isEmpty) {
       result.add(Expectation.PASS);
     }
     return _cachedSets.putIfAbsent(result.toString(), () => result);
   }
 
   // Preprocess the expectations for matching against
   // filenames. Generate lists of regular expressions once and for all
   // for each key.
   void _preprocessForMatching() {
     if (_preprocessed) return;
 
-    _keyToRegExps = new Map();
-    _regExpCache = new Map();
+    _keyToRegExps = {};
+    _regExpCache = {};
 
     _map.forEach((key, expectations) {
       if (_keyToRegExps[key] != null) return;
       var splitKey = key.split('/');
-      var regExps = new List(splitKey.length);
+      var regExps = new List<RegExp>(splitKey.length);
       for (var i = 0; i < splitKey.length; i++) {
         var component = splitKey[i];
         var regExp = _regExpCache[component];
         if (regExp == null) {
           var pattern = "^${splitKey[i]}\$".replaceAll('*', '.*');
           regExp = new RegExp(pattern);
           _regExpCache[component] = regExp;
         }
         regExps[i] = regExp;
       }
       _keyToRegExps[key] = regExps;
     });
 
     _regExpCache = null;
     _preprocessed = true;
   }
 }