Fix strong mode warnings and errors.

lib/src/ast.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.
 
 import 'package:path/path.dart' as p;
 import 'package:collection/collection.dart';
 
 import 'utils.dart';
 
 const _SEPARATOR = 0x2F; // "/"
 
 /// A node in the abstract syntax tree for a glob.
 abstract class AstNode {
   /// The cached regular expression that this AST was compiled into.
   RegExp _regExp;
 
   /// Whether this node matches case-sensitively or not.
   final bool caseSensitive;
 
   /// Whether this glob could match an absolute path.
   ///
   /// Either this or [canMatchRelative] or both will be true.
-  final bool canMatchAbsolute = false;
+  bool get canMatchAbsolute => false;
 
   /// Whether this glob could match a relative path.
   ///
   /// Either this or [canMatchRelative] or both will be true.
-  final bool canMatchRelative = true;
+  bool get canMatchRelative => true;
 
   AstNode._(this.caseSensitive);
 
   /// Returns a new glob with all the options bubbled to the top level.
   ///
   /// In particular, this returns a glob AST with two guarantees:
   ///
   /// 1. There are no [OptionsNode]s other than the one at the top level.
   /// 2. It matches the same set of paths as [this].
   ///
@@ skipping 40 matching lines @@
       var nextSequences = node.flattenOptions().options;
       sequences = sequences.expand((sequence) {
         return nextSequences.map((nextSequence) {
           return sequence.toList()..addAll(nextSequence.nodes);
         });
       });
     }
 
     return new OptionsNode(sequences.map((sequence) {
       // Combine any adjacent LiteralNodes in [sequence].
-      return new SequenceNode(sequence.fold([], (combined, node) {
+      return new SequenceNode(sequence.fold/*<List<AstNode>>*/([], (combined, node) {
         if (combined.isEmpty || combined.last is! LiteralNode ||
             node is! LiteralNode) {
           return combined..add(node);
         }
 
         combined[combined.length - 1] = new LiteralNode(
-            combined.last.text + node.text, caseSensitive: caseSensitive);
+            // TODO(nweiz): Avoid casting when sdk#25565 is fixed.
+            (combined.last as LiteralNode).text + (node as LiteralNode).text,
+            caseSensitive: caseSensitive);
         return combined;
       }), caseSensitive: caseSensitive);
     }), caseSensitive: caseSensitive);
   }
 
   /// Splits this glob into components along its path separators.
   ///
   /// For example, given the glob `foo/*/*.dart`, this would return three globs:
   /// `foo`, `*`, and `*.dart`.
   ///
   /// Path separators within options nodes are not split. For example,
   /// `foo/{bar,baz/bang}/qux` will return three globs: `foo`, `{bar,baz/bang}`,
   /// and `qux`.
   ///
   /// [context] is used to determine what absolute roots look like for this
   /// glob.
   List<SequenceNode> split(p.Context context) {
-    var componentsToReturn = [];
-    var currentComponent;
+    var componentsToReturn = <SequenceNode>[];
+    List<AstNode> currentComponent;
 
-    addNode(node) {
+    addNode(AstNode node) {
       if (currentComponent == null) currentComponent = [];
       currentComponent.add(node);
     }
 
     finishComponent() {
       if (currentComponent == null) return;
       componentsToReturn.add(
           new SequenceNode(currentComponent, caseSensitive: caseSensitive));
       currentComponent = null;
     }
 
     for (var node in nodes) {
-      if (node is! LiteralNode || !node.text.contains('/')) {
+      if (node is! LiteralNode) {
         addNode(node);
         continue;
       }
 
-      var text = node.text;
+      // TODO(nweiz): Avoid casting when sdk#25565 is fixed.
+      var literal = node as LiteralNode;
+      if (!literal.text.contains('/')) {
+        addNode(literal);
+        continue;
+      }
+
+      var text = literal.text;
       if (context.style == p.Style.windows) text = text.replaceAll("/", "\\");
       var components = context.split(text);
 
       // If the first component is absolute, that means it's a separator (on
       // Windows some non-separator things are also absolute, but it's invalid
       // to have "C:" show up in the middle of a path anyway).
       if (context.isAbsolute(components.first)) {
         // If this is the first component, it's the root.
         if (componentsToReturn.isEmpty && currentComponent == null) {
           var root = components.first;
@@ skipping 14 matching lines @@
       // For each component except the last one, add a separate sequence to
       // [sequences] containing only that component.
       for (var component in components.take(components.length - 1)) {
         addNode(new LiteralNode(component, caseSensitive: caseSensitive));
         finishComponent();
       }
 
       // For the final component, only end its sequence (by adding a new empty
       // sequence) if it ends with a separator.
       addNode(new LiteralNode(components.last, caseSensitive: caseSensitive));
-      if (node.text.endsWith('/')) finishComponent();
+      if (literal.text.endsWith('/')) finishComponent();
     }
 
     finishComponent();
     return componentsToReturn;
   }
 
   String _toRegExp() => nodes.map((node) => node._toRegExp()).join();
 
   bool operator==(Object other) => other is SequenceNode &&
       const IterableEquality().equals(nodes, other.nodes);
@@ skipping 200 matching lines @@
         super._(caseSensitive);
 
   String _toRegExp() => regExpQuote(text);
 
   bool operator==(Object other) => other is LiteralNode && other.text == text;
 
   int get hashCode => text.hashCode;
 
   String toString() => text;
 }