Fix all strong mode errors and warnings.

lib/src/analyzer.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.
 
 part of csslib.parser;
 
 // TODO(terry): Add optimizing phase to remove duplicated selectors in the same
 //              selector group (e.g., .btn, .btn { color: red; }).  Also, look
 //              at simplifying selectors expressions too (much harder).
 // TODO(terry): Detect invalid directive usage.  All @imports must occur before
@@ skipping 225 matching lines @@
    * Build up the list of all inherited sequences from the parent selector
    * [node] is the current nested selector and it's parent is the last entry in
    * the [_nestedSelectorGroup].
    */
   SelectorGroup _mergeToFlatten(RuleSet node) {
     // Create a new SelectorGroup for this nesting level.
     var nestedSelectors = _nestedSelectorGroup.selectors;
     var selectors = node.selectorGroup.selectors;
 
     // Create a merged set of previous parent selectors and current selectors.
-    var newSelectors = [];
+    var newSelectors = <Selector>[];
     for (Selector selector in selectors) {
       for (Selector nestedSelector in nestedSelectors) {
         var seq = _mergeNestedSelector(nestedSelector.simpleSelectorSequences,
             selector.simpleSelectorSequences);
         newSelectors.add(new Selector(seq, node.span));
       }
     }
 
     return new SelectorGroup(newSelectors, node.span);
   }
 
   /**
    * Merge the nested selector sequences [current] to the [parent] sequences or
    * substitue any & with the parent selector.
    */
   List<SimpleSelectorSequence> _mergeNestedSelector(
       List<SimpleSelectorSequence> parent,
       List<SimpleSelectorSequence> current) {
 
     // If any & operator then the parent selector will be substituted otherwise
     // the parent selector is pre-pended to the current selector.
     var hasThis = current.any((s) => s.simpleSelector.isThis);
 
-    var newSequence = [];
+    var newSequence = <SimpleSelectorSequence>[];
 
     if (!hasThis) {
       // If no & in the sector group then prefix with the parent selector.
       newSequence.addAll(parent);
       newSequence.addAll(_convertToDescendentSequence(current));
     } else {
       for (var sequence in current) {
         if (sequence.simpleSelector.isThis) {
           // Substitue the & with the parent selector and only use a combinator
           // descendant if & is prefix by a sequence with an empty name e.g.,
@@ skipping 14 matching lines @@
   /**
    * Return selector sequences with first sequence combinator being a
    * descendant.  Used for nested selectors when the parent selector needs to
    * be prefixed to a nested selector or to substitute the this (&) with the
    * parent selector.
    */
   List<SimpleSelectorSequence> _convertToDescendentSequence(
       List<SimpleSelectorSequence> sequences) {
     if (sequences.isEmpty) return sequences;
 
-    var newSequences = [];
+    var newSequences = <SimpleSelectorSequence>[];
     var first = sequences.first;
     newSequences.add(new SimpleSelectorSequence(
         first.simpleSelector, first.span, TokenKind.COMBINATOR_DESCENDANT));
     newSequences.addAll(sequences.skip(1));
 
     return newSequences;
   }
 
   void visitDeclarationGroup(DeclarationGroup node) {
     var span = node.span;
@@ skipping 269 matching lines @@
       visitMixinRulesetDirective(mixinDef);
     } else {
       visitMixinDeclarationDirective(mixinDef);
     }
   }
 
   /**
    * Given a mixin's defined arguments return a cloned mixin defintion that has
    * replaced all defined arguments with user's supplied VarUsages.
    */
-  MixinDefinition transform(List callArgs) {
+  MixinDefinition transform(List<List<Expression>> callArgs) {
     // TODO(terry): Handle default arguments and varArgs.
     // Transform mixin with callArgs.
     for (var index = 0; index < _definedArgs.length; index++) {
       var definedArg = _definedArgs[index];
       VarDefinition varDef;
       if (definedArg is VarDefinition) {
         varDef = definedArg;
       } else if (definedArg is VarDefinitionDirective) {
         VarDefinitionDirective varDirective = definedArg;
         varDef = varDirective.def;
@@ skipping 15 matching lines @@
           k.expressions.replaceRange(usagesIndex, usagesIndex + 1, callArg);
         }
       });
     }
 
     // Clone the mixin
     return mixinDef.clone();
   }
 
   /** Rip apart var def with multiple parameters. */
-  List<List<TreeNode>> _varDefsAsCallArgs(var callArg) {
-    var defArgs = [];
+  List<List<Expression>> _varDefsAsCallArgs(var callArg) {
+    var defArgs = <List<Expression>>[];
     if (callArg is List && callArg[0] is VarUsage) {
       var varDef = varDefs[callArg[0].name];
-      var expressions = varDef.expression.expressions;
+      var expressions = (varDef.expression as Expressions).expressions;
       assert(expressions.length > 1);
       for (var expr in expressions) {
         if (expr is! OperatorComma) {
           defArgs.add([expr]);
         }
       }
     }
     return defArgs;
   }
 
@@ skipping 103 matching lines @@
             currDeclGroup.declarations.replaceRange(
                 index, index + 1, [new NoOp()]);
           }
           _messages.warning(
               "Using top-level mixin ${node.include.name} as a declaration",
               node.span);
         } else {
           // We're a list of @include(s) inside of a mixin ruleset - convert
           // to a list of IncludeMixinAtDeclaration(s).
           var origRulesets = mixinDef.rulesets;
-          var rulesets = [];
+          var rulesets = <Declaration>[];
           if (origRulesets.every((ruleset) => ruleset is IncludeDirective)) {
             origRulesets.forEach((ruleset) {
-              rulesets
-                  .add(new IncludeMixinAtDeclaration(ruleset, ruleset.span));
+              rulesets.add(new IncludeMixinAtDeclaration(
+                  ruleset as IncludeDirective, ruleset.span));
             });
             _IncludeReplacer.replace(_styleSheet, node, rulesets);
           }
         }
       }
 
       if (mixinDef.definedArgs.length > 0 && node.include.args.length > 0) {
         var callMixin = _createCallDeclMixin(mixinDef);
         mixinDef = callMixin.transform(node.include.args);
       }
@@ skipping 60 matching lines @@
   }
 
   void visitVarDefinitionDirective(VarDefinitionDirective node) {
     visitVarDefinition(node.def);
   }
 }
 
 /** @include as a top-level with ruleset(s). */
 class _IncludeReplacer extends Visitor {
   final _include;
-  final List<Declaration> _newDeclarations;
+  final List<TreeNode> _newDeclarations;
   bool _foundAndReplaced = false;
 
   /**
    * Look for the [ruleSet] inside of a @media directive; if found then replace
    * with the [newRules].
    */
   static void replace(
-      StyleSheet ss, var include, List<Declaration> newDeclarations) {
+      StyleSheet ss, var include, List<TreeNode> newDeclarations) {
     var visitor = new _IncludeReplacer(include, newDeclarations);
     visitor.visitStyleSheet(ss);
   }
 
   _IncludeReplacer(this._include, this._newDeclarations);
 
   void visitDeclarationGroup(DeclarationGroup node) {
     var index = _findInclude(node.declarations, _include);
     if (index != -1) {
       node.declarations.insertAll(index + 1, _newDeclarations);
@@ skipping 142 matching lines @@
             isLastNone = false;
           }
         } else {
           isLastNone = simpleSeq.isCombinatorNone;
         }
       }
     }
     super.visitSelectorGroup(node);
   }
 }