More steps toward making server strong mode clean

pkg/analysis_server/lib/src/watch_manager.dart

 // Copyright (c) 2015, 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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core' hide Resource;
 
@@ skipping 158 matching lines @@
   /**
    * The folder for which information is being maintained. This is `null` for
    * the unique "root" node that maintains references to all of the top-level
    * folders being watched.
    */
   final Folder folder;
 
   /**
    * The parent of this node.
    */
-  WatchNode parent;
+  WatchNode<T> parent;
 
   /**
    * The information for the children of this node.
    */
-  final List<WatchNode> _children = <WatchNode>[];
+  final List<WatchNode<T>> _children = <WatchNode<T>>[];
 
   /**
    * The tokens that were used to register interest in watching this folder.
    */
   final Set<T> tokens = new HashSet<T>();
 
   /**
    * The subscription being used to watch the folder, or `null` if the folder
    * is being watched as part of a containing folder (in other words, if the
    * parent is not the special "root").
    */
   StreamSubscription<WatchEvent> subscription;
 
   /**
    * Initialize a newly created node to represent the given [folder].
    */
   WatchNode(this.folder);
 
   /**
    * Return a list containing the children of this node.
    */
-  Iterable<WatchNode> get children => _children;
+  Iterable<WatchNode<T>> get children => _children;
 
   /**
    * Remove this node from the tree of watched folders.
    */
   void delete() {
     if (parent != null) {
       parent._removeChild(this);
       parent = null;
     }
   }
 
   /**
    * Return the highest node reachable from this node that contains the given
    * [filePath]. If no other node is found, return this node, even if this node
    * does not contain the path.
    */
-  WatchNode findParent(String filePath) {
+  WatchNode<T> findParent(String filePath) {
     if (_children == null) {
       return this;
     }
-    for (WatchNode childNode in _children) {
+    for (WatchNode<T> childNode in _children) {
       if (childNode.folder.isOrContains(filePath)) {
         return childNode.findParent(filePath);
       }
     }
     return this;
   }
 
   /**
    * Insert the given [node] into the tree of watched folders, either as a child
    * of this node or as a descendent of one of this node's children. Return the
    * immediate parent of the newly added node.
    */
-  WatchNode insert(WatchNode node) {
-    WatchNode parentNode = findParent(node.folder.path);
+  WatchNode<T> insert(WatchNode<T> node) {
+    WatchNode<T> parentNode = findParent(node.folder.path);
     parentNode._addChild(node, true);
     return parentNode;
   }
 
   @override
   String toString() => 'WatchNode ('
       'folder = ${folder == null ? '<root>' : folder.path}, '
       'tokens = $tokens, '
       'subscription = ${subscription == null ? 'null' : 'non-null'})';
 
   /**
    * Add the given [newChild] as an immediate child of this node.
    *
    * If [checkChildren] is `true`, check to see whether any of the previously
    * existing children of this node should now be children of the new child, and
    * if so, move them.
    */
-  void _addChild(WatchNode newChild, bool checkChildren) {
+  void _addChild(WatchNode<T> newChild, bool checkChildren) {
     if (checkChildren) {
       Folder folder = newChild.folder;
       for (int i = _children.length - 1; i >= 0; i--) {
-        WatchNode existingChild = _children[i];
+        WatchNode<T> existingChild = _children[i];
         if (folder.contains(existingChild.folder.path)) {
           newChild._addChild(existingChild, false);
           _children.removeAt(i);
         }
       }
     }
     newChild.parent = this;
     _children.add(newChild);
   }
 
   /**
    * Remove the given [node] from the list of children of this node. Any
    * children of the [node] will become children of this node.
    */
-  void _removeChild(WatchNode child) {
+  void _removeChild(WatchNode<T> child) {
     _children.remove(child);
-    Iterable<WatchNode> grandchildren = child.children;
-    for (WatchNode grandchild in grandchildren) {
+    Iterable<WatchNode<T>> grandchildren = child.children;
+    for (WatchNode<T> grandchild in grandchildren) {
       grandchild.parent = this;
       _children.add(grandchild);
     }
     child._children.clear();
   }
 }