pkg/csslib: fixed analysis error, more cleanup

pkg/csslib/lib/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 csslib.parser;
 
 import 'dart:math' as math;
 
 import 'package:source_maps/span.dart' show SourceFile, Span, FileSpan;
 
@@ skipping 12 matching lines @@
 
 /** Used for parser lookup ahead (used for nested selectors Less support). */
 class ParserState extends TokenizerState {
   final Token peekToken;
   final Token previousToken;
 
   ParserState(this.peekToken, this.previousToken, Tokenizer tokenizer)
       : super(tokenizer);
 }
 
-void _createMessages({List errors, List options}) {
+void _createMessages({List<Message> errors, List<String> options}) {
   if (errors == null) errors = [];
 
   if (options == null) {
     options = ['--no-colors', 'memory'];
   }
   var opt = PreprocessorOptions.parse(options);
   messages = new Messages(options: opt, printHandler: errors.add);
 }
 
 /** CSS checked mode enabled. */
 bool get isChecked => messages.options.checked;
 
 // TODO(terry): Remove nested name parameter.
 /** Parse and analyze the CSS file. */
-StyleSheet compile(var input, {List errors, List options, bool nested: true,
-    bool polyfill: false, List<StyleSheet> includes: null}) {
+StyleSheet compile(var input, {List<Message> errors, List<String> options,
+    bool nested: true,
+    bool polyfill: false,
+    List<StyleSheet> includes: null}) {
+
   if (includes == null) {
     includes = [];
   }
 
   var source = _inputAsString(input);
 
   _createMessages(errors: errors, options: options);
 
   var file = new SourceFile.text(null, source);
 
   var tree = new _Parser(file, source).parse();
 
   analyze([tree], errors: errors, options: options);
 
   if (polyfill) {
     var processCss = new PolyFill(messages, true);
     processCss.process(tree, includes: includes);
   }
 
   return tree;
 }
 
 /** Analyze the CSS file. */
-void analyze(List<StyleSheet> styleSheets,  {List errors, List options}) {
+void analyze(List<StyleSheet> styleSheets,
+    {List<Message> errors, List<String> options}) {
+
   _createMessages(errors: errors, options: options);
   new Analyzer(styleSheets, messages).run();
 }
 
 /**
  * Parse the [input] CSS stylesheet into a tree. The [input] can be a [String],
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
-StyleSheet parse(var input, {List errors, List options}) {
+StyleSheet parse(var input, {List<Message> errors, List<String> options}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors, options: options);
 
   var file = new SourceFile.text(null, source);
 
   return new _Parser(file, source).parse();
 }
 
 /**
  * Parse the [input] CSS selector into a tree. The [input] can be a [String],
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
-StyleSheet selector(var input, {List errors}) {
+StyleSheet selector(var input, {List<Message> errors}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors);
 
   var file = new SourceFile.text(null, source);
 
   return new _Parser(file, source).parseSelector();
 }
 
 String _inputAsString(var input) {
@@ skipping 34 matching lines @@
   final _Parser _parser;
 
   Parser(SourceFile file, String text, {int start: 0, String baseUrl}) :
     _parser = new _Parser(file, text, start: start, baseUrl: baseUrl);
 
   StyleSheet parse() => _parser.parse();
 }
 
 /** A simple recursive descent parser for CSS. */
 class _Parser {
-  Tokenizer tokenizer;
+  final Tokenizer tokenizer;
 
   /** Base url of CSS file. */
   final String _baseUrl;
 
   /**
    * File containing the source being parsed, used to report errors with
    * source-span locations.
    */
   final SourceFile file;
 
@@ skipping 1013 matching lines @@
     } while (_maybeEat(TokenKind.COMMA));
 
     if (selectors.length > 0) {
       return new SelectorGroup(selectors, _makeSpan(start));
     }
   }
 
   /**
    * Return list of selectors
    */
-  processSelector() {
-    List<SimpleSelectorSequence> simpleSequences = [];
-    int start = _peekToken.start;
+  Selector processSelector() {
+    var simpleSequences = <SimpleSelectorSequence>[];
+    var start = _peekToken.start;
     while (true) {
       // First item is never descendant make sure it's COMBINATOR_NONE.
       var selectorItem = simpleSelectorSequence(simpleSequences.length == 0);
       if (selectorItem != null) {
         simpleSequences.add(selectorItem);
       } else {
         break;
       }
     }
 
@@ skipping 137 matching lines @@
     }
 
     return false;
   }
 
   /**
    * type_selector | universal | HASH | class | attrib | pseudo
    */
   simpleSelectorTail() {
     // Check for HASH | class | attrib | pseudo | negation
-    int start = _peekToken.start;
+    var start = _peekToken.start;
     switch (_peek()) {
       case TokenKind.HASH:
         _eat(TokenKind.HASH);
 
-        bool hasWhiteSpace = false;
+        var hasWhiteSpace = false;
         if (_anyWhiteSpaceBeforePeekToken(TokenKind.HASH)) {
           _warning("Not a valid ID selector expected #id", _makeSpan(start));
           hasWhiteSpace = true;
         }
         if (_peekIdentifier()) {
           var id = identifier();
           if (hasWhiteSpace) {
             // Generate bad selector id (normalized).
             id.name = " ${id.name}";
           }
@@ skipping 25 matching lines @@
             _peekToken.span);
         _next();
         break;
     }
   }
 
   processPseudoSelector(int start) {
     // :pseudo-class ::pseudo-element
     // TODO(terry): '::' should be token.
     _eat(TokenKind.COLON);
-    bool pseudoElement = _maybeEat(TokenKind.COLON);
+    var pseudoElement = _maybeEat(TokenKind.COLON);
 
     // TODO(terry): If no identifier specified consider optimizing out the
     //              : or :: and making this a normal selector.  For now,
     //              create an empty pseudoName.
     var pseudoName;
     if (_peekIdentifier()) {
       pseudoName = identifier();
     } else {
       return null;
     }
@@ skipping 40 matching lines @@
    *  In CSS3, the expressions are identifiers, strings, or of the form "an+b".
    *
    *    : [ [ PLUS | '-' | DIMENSION | NUMBER | STRING | IDENT ] S* ]+
    *
    *    num               [0-9]+|[0-9]*\.[0-9]+
    *    PLUS              '+'
    *    DIMENSION         {num}{ident}
    *    NUMBER            {num}
    */
   processSelectorExpression() {
-    int start = _peekToken.start;
+    var start = _peekToken.start;
 
     var expression = new SelectorExpression(_makeSpan(start));
 
     Token termToken;
     var value;
 
     // Special parsing for expressions in pseudo functions.  Minus is used as
     // operator not identifier.
     tokenizer.selectorExpression = true;
 
-    bool keepParsing = true;
+    var keepParsing = true;
     while (keepParsing) {
       switch (_peek()) {
         case TokenKind.PLUS:
           start = _peekToken.start;
           termToken = _next();
           expression.add(new OperatorPlus(_makeSpan(start)));
           break;
         case TokenKind.MINUS:
           start = _peekToken.start;
           termToken = _next();
@@ skipping 51 matching lines @@
   //
   //  DASHMATCH:        '|='
   //
   //  PREFIXMATCH:      '^='
   //
   //  SUFFIXMATCH:      '$='
   //
   //  SUBSTRMATCH:      '*='
   //
   //
-  processAttribute() {
-    int start = _peekToken.start;
+  AttributeSelector processAttribute() {
+    var start = _peekToken.start;
 
     if (_maybeEat(TokenKind.LBRACK)) {
       var attrName = identifier();
 
       int op;
       switch (_peek()) {
       case TokenKind.EQUALS:
       case TokenKind.INCLUDES:        // ~=
       case TokenKind.DASH_MATCH:      // |=
       case TokenKind.PREFIX_MATCH:    // ^=
@@ skipping 32 matching lines @@
   //
   //  property:  IDENT [or IE hacks]
   //  prio:      !important
   //  expr:      (see processExpr)
   //
   // Here are the ugly IE hacks we need to support:
   //   property: expr prio? \9; - IE8 and below property, /9 before semi-colon
   //   *IDENT                   - IE7 or below
   //   _IDENT                   - IE6 property (automatically a valid ident)
   //
-  processDeclaration(List dartStyles) {
+  Declaration processDeclaration(List dartStyles) {
     Declaration decl;
 
     int start = _peekToken.start;
 
     // IE7 hack of * before property name if so the property is IE7 or below.
     var ie7 = _peekKind(TokenKind.ASTERISK);
     if (ie7) {
       _next();
     }
 
@@ skipping 23 matching lines @@
 
       Expressions exprs = processExpr();
 
       decl = new VarDefinition(definedName, exprs, _makeSpan(start));
     } else if (_peekToken.kind == TokenKind.DIRECTIVE_INCLUDE) {
       // @include mixinName in the declaration area.
       var span = _makeSpan(start);
       var include = processInclude(span, eatSemiColon: false);
       decl = new IncludeMixinAtDeclaration(include, span);
     } else if (_peekToken.kind == TokenKind.DIRECTIVE_EXTEND) {
-      List<SimpleSelectorSequence> simpleSequences = [];
+      var simpleSequences = <TreeNode>[];
 
       _next();
       var span = _makeSpan(start);
       var selector = simpleSelector();
       if (selector == null) {
         _warning("@extends expecting simple selector name", span);
       } else {
         simpleSequences.add(selector);
       }
       if (_peekKind(TokenKind.COLON)) {
@@ skipping 72 matching lines @@
     'padding-top':          _paddingPartTop,
     'padding-right':        _paddingPartRight,
     'padding-bottom':       _paddingPartBottom
   };
 
   static const Map<String, int> _nameToFontWeight = const {
     'bold' : FontWeight.bold,
     'normal' : FontWeight.normal
   };
 
-  static _findStyle(String styleName) {
-    if (_stylesToDart.containsKey(styleName)) {
-      return _stylesToDart[styleName];
-    }
-  }
+  static int _findStyle(String styleName) => _stylesToDart[styleName];
 
-  _styleForDart(Identifier property, Expressions exprs, List dartStyles) {
-    int styleType = _findStyle(property.name.toLowerCase());
+  DartStyleExpression _styleForDart(Identifier property, Expressions exprs,
+      List dartStyles) {
+    var styleType = _findStyle(property.name.toLowerCase());
     if (styleType != null) {
       return buildDartStyleNode(styleType, exprs, dartStyles);
     }
   }
 
   FontExpression _mergeFontStyles(FontExpression fontExpr, List dartStyles) {
     // Merge all font styles for this class selector.
     for (var dartStyle in dartStyles) {
       if (dartStyle.isFont) {
         fontExpr = new FontExpression.merge(dartStyle, fontExpr);
       }
     }
 
     return fontExpr;
   }
 
-  buildDartStyleNode(int styleType, Expressions exprs, List dartStyles) {
+  DartStyleExpression buildDartStyleNode(int styleType, Expressions exprs,
+      List dartStyles) {
+
     switch (styleType) {
       /*
        * Properties in order:
        *
        *   font-style font-variant font-weight font-size/line-height font-family
        *
        * The font-size and font-family values are required. If other values are
        * missing; a default, if it exist, will be used.
        */
        case _fontPartFont:
@@ skipping 122 matching lines @@
         }
         break;
       default:
         // Don't handle it.
         return null;
     }
   }
 
   // TODO(terry): Look at handling width of thin, thick, etc. any none numbers
   //              to convert to a number.
-  processOneNumber(Expressions exprs, int part) {
+  DartStyleExpression processOneNumber(Expressions exprs, int part) {
     var value = marginValue(exprs.expressions[0]);
     if (value != null) {
       switch (part) {
         case _marginPartLeft:
           return new MarginExpression(exprs.span, left: value);
         case _marginPartTop:
           return new MarginExpression(exprs.span, top: value);
         case _marginPartRight:
           return new MarginExpression(exprs.span, right: value);
         case _marginPartBottom:
@@ skipping 29 matching lines @@
   /**
    * Margins are of the format:
    *
    *   top,right,bottom,left      (4 parameters)
    *   top,right/left, bottom     (3 parameters)
    *   top/bottom,right/left      (2 parameters)
    *   top/right/bottom/left      (1 parameter)
    *
    * The values of the margins can be a unit or unitless or auto.
    */
-  processFourNums(Expressions exprs) {
+  BoxEdge processFourNums(Expressions exprs) {
     num top;
     num right;
     num bottom;
     num left;
 
     int totalExprs = exprs.expressions.length;
     switch (totalExprs) {
       case 1:
         top = marginValue(exprs.expressions[0]);
         right = top;
@@ skipping 32 matching lines @@
     }
   }
 
   //  Expression grammar:
   //
   //  expression:   term [ operator? term]*
   //
   //  operator:     '/' | ','
   //  term:         (see processTerm)
   //
-  processExpr([bool ieFilter = false]) {
-    int start = _peekToken.start;
-    Expressions expressions = new Expressions(_makeSpan(start));
+  Expressions processExpr([bool ieFilter = false]) {
+    var start = _peekToken.start;
+    var expressions = new Expressions(_makeSpan(start));
 
-    bool keepGoing = true;
+    var keepGoing = true;
     var expr;
     while (keepGoing && (expr = processTerm(ieFilter)) != null) {
       var op;
 
-      int opStart = _peekToken.start;
+      var opStart = _peekToken.start;
 
       switch (_peek()) {
       case TokenKind.SLASH:
         op = new OperatorSlash(_makeSpan(opStart));
         break;
       case TokenKind.COMMA:
         op = new OperatorComma(_makeSpan(opStart));
         break;
       case TokenKind.BACKSLASH:
         // Backslash outside of string; detected IE8 or older signaled by \9 at
@@ skipping 31 matching lines @@
           keepGoing = false;
         } else {
           _next();
         }
       }
     }
 
     return expressions;
   }
 
-  static int MAX_UNICODE = int.parse('0x10FFFF');
+  static final int MAX_UNICODE = int.parse('0x10FFFF');
 
   //  Term grammar:
   //
   //  term:
   //    unary_operator?
   //    [ term_value ]
   //    | STRING S* | IDENT S* | URI S* | UNICODERANGE S* | hexcolor
   //
   //  term_value:
   //    NUMBER S* | PERCENTAGE S* | LENGTH S* | EMS S* | EXS S* | ANGLE S* |
   //    TIME S* | FREQ S* | function
   //
   //  NUMBER:       {num}
   //  PERCENTAGE:   {num}%
   //  LENGTH:       {num}['px' | 'cm' | 'mm' | 'in' | 'pt' | 'pc']
   //  EMS:          {num}'em'
   //  EXS:          {num}'ex'
   //  ANGLE:        {num}['deg' | 'rad' | 'grad']
   //  TIME:         {num}['ms' | 's']
   //  FREQ:         {num}['hz' | 'khz']
   //  function:     IDENT '(' expr ')'
   //
   processTerm([bool ieFilter = false]) {
-    int start = _peekToken.start;
+    var start = _peekToken.start;
     Token t;                          // token for term's value
     var value;                        // value of term (numeric values)
 
     var unary = "";
     switch (_peek()) {
     case TokenKind.HASH:
       this._eat(TokenKind.HASH);
       if (!_anyWhiteSpaceBeforePeekToken(TokenKind.HASH)) {
         String hexText;
         if (_peekKind(TokenKind.INTEGER)) {
@@ skipping 87 matching lines @@
           var propName = nameValue.name;
           var errMsg = TokenKind.isPredefinedName(propName) ?
               "Improper use of property value ${propName}" :
               "Unknown property value ${propName}";
           _warning(errMsg, _makeSpan(start));
         }
         return new LiteralTerm(nameValue, nameValue.name, _makeSpan(start));
       }
 
       // Yes, process the color as an RGB value.
-      String rgbColor = TokenKind.decimalToHex(
-          TokenKind.colorValue(colorEntry), 6);
+      var rgbColor =
+          TokenKind.decimalToHex(TokenKind.colorValue(colorEntry), 6);
       return _parseHex(rgbColor, _makeSpan(start));
     case TokenKind.UNICODE_RANGE:
       var first;
       var second;
       var firstNumber;
       var secondNumber;
       _eat(TokenKind.UNICODE_RANGE, unicodeRange: true);
       if (_maybeEat(TokenKind.HEX_INTEGER, unicodeRange: true)) {
         first = _previousToken.text;
         firstNumber = int.parse('0x$first');
@@ skipping 33 matching lines @@
         expr.expressions[0] = varUsage;
         return expr.expressions;
       }
       break;
     }
 
     return processDimension(t, value, _makeSpan(start));
   }
 
   /** Process all dimension units. */
-  processDimension(Token t, var value, Span span) {
-    var term;
+  LiteralTerm processDimension(Token t, var value, Span span) {
+    LiteralTerm term;
     var unitType = this._peek();
 
     switch (unitType) {
     case TokenKind.UNIT_EM:
       term = new EmTerm(value, t.text, span);
       _next();    // Skip the unit
       break;
     case TokenKind.UNIT_EX:
       term = new ExTerm(value, t.text, span);
       _next();    // Skip the unit
@@ skipping 58 matching lines @@
         term = (value is Identifier)
             ? new LiteralTerm(value, value.name, span)
             : new NumberTerm(value, t.text, span);
       }
       break;
     }
 
     return term;
   }
 
-  processQuotedString([bool urlString = false]) {
-    int start = _peekToken.start;
+  String processQuotedString([bool urlString = false]) {
+    var start = _peekToken.start;
 
     // URI term sucks up everything inside of quotes(' or ") or between parens
-    int stopToken = urlString ? TokenKind.RPAREN : -1;
+    var stopToken = urlString ? TokenKind.RPAREN : -1;
     switch (_peek()) {
     case TokenKind.SINGLE_QUOTE:
       stopToken = TokenKind.SINGLE_QUOTE;
       start = _peekToken.start + 1;   // Skip the quote might have whitespace.
       _next();    // Skip the SINGLE_QUOTE.
       break;
     case TokenKind.DOUBLE_QUOTE:
       stopToken = TokenKind.DOUBLE_QUOTE;
       start = _peekToken.start + 1;   // Skip the quote might have whitespace.
       _next();    // Skip the DOUBLE_QUOTE.
       break;
     default:
       if (urlString) {
         if (_peek() == TokenKind.LPAREN) {
           _next();    // Skip the LPAREN.
           start = _peekToken.start;
         }
         stopToken = TokenKind.RPAREN;
       } else {
         _error('unexpected string', _makeSpan(start));
       }
       break;
     }
 
     // Gobble up everything until we hit our stop token.
-    int runningStart = _peekToken.start;
+    var runningStart = _peekToken.start;
     while (_peek() != stopToken && _peek() != TokenKind.END_OF_FILE) {
       var tok = _next();
     }
 
     // All characters between quotes is the string.
-    int end = _peekToken.end;
+    var end = _peekToken.end;
     var stringValue = (_peekToken.span as FileSpan).file.getText(start,
         end - 1);
 
     if (stopToken != TokenKind.RPAREN) {
       _next();    // Skip the SINGLE_QUOTE or DOUBLE_QUOTE;
     }
 
     return stringValue;
   }
 
   // TODO(terry): Should probably understand IE's non-standard filter syntax to
   //              fully support calc, var(), etc.
   /**
    * IE's filter property breaks CSS value parsing.  IE's format can be:
    *
    *    filter: progid:DXImageTransform.MS.gradient(Type=0, Color='#9d8b83');
    *
    * We'll just parse everything after the 'progid:' look for the left paren
    * then parse to the right paren ignoring everything in between.
    */
   processIEFilter(int startAfterProgidColon) {
-    int parens = 0;
+    var parens = 0;
 
     while (_peek() != TokenKind.END_OF_FILE) {
       switch (_peek()) {
         case TokenKind.LPAREN:
           _eat(TokenKind.LPAREN);
           parens++;
           break;
         case TokenKind.RPAREN:
           _eat(TokenKind.RPAREN);
           if (--parens == 0) {
             var tok = tokenizer.makeIEFilter(startAfterProgidColon,
                 _peekToken.start);
             return new LiteralTerm(tok.text, tok.text, tok.span);
           }
           break;
         default:
           _eat(_peek());
       }
     }
   }
 
   //  Function grammar:
   //
   //  function:     IDENT '(' expr ')'
   //
   processFunction(Identifier func) {
-    int start = _peekToken.start;
+    var start = _peekToken.start;
 
-    String name = func.name;
+    var name = func.name;
 
     switch (name) {
     case 'url':
       // URI term sucks up everything inside of quotes(' or ") or between parens
-      String urlParam = processQuotedString(true);
+      var urlParam = processQuotedString(true);
 
       // TODO(terry): Better error messge and checking for mismatched quotes.
       if (_peek() == TokenKind.END_OF_FILE) {
         _error("problem parsing URI", _peekToken.span);
       }
 
       if (_peek() == TokenKind.RPAREN) {
         _next();
       }
 
@@ skipping 29 matching lines @@
       if (!_maybeEat(TokenKind.RPAREN)) {
         _error("problem parsing function expected ), ", _peekToken.span);
       }
 
       return new FunctionTerm(name, name, expr, _makeSpan(start));
     }
 
     return null;
   }
 
-  identifier() {
+  Identifier identifier() {
     var tok = _next();
 
     if (!TokenKind.isIdentifier(tok.kind) &&
         !TokenKind.isKindIdentifier(tok.kind)) {
       if (isChecked) {
         _warning('expected identifier, but found $tok', tok.span);
       }
       return new Identifier("", _makeSpan(tok.start));
     }
 
     return new Identifier(tok.text, _makeSpan(tok.start));
   }
 
   // TODO(terry): Move this to base <= 36 and into shared code.
   static int _hexDigit(int c) {
-    if(c >= 48/*0*/ && c <= 57/*9*/) {
+    if (c >= 48/*0*/ && c <= 57/*9*/) {
       return c - 48;
     } else if (c >= 97/*a*/ && c <= 102/*f*/) {
       return c - 87;
     } else if (c >= 65/*A*/ && c <= 70/*F*/) {
       return c - 55;
     } else {
       return -1;
     }
   }
 
   HexColorTerm _parseHex(String hexText, Span span) {
-    int hexValue = 0;
+    var hexValue = 0;
 
-     for (int i = 0; i < hexText.length; i++) {
+     for (var i = 0; i < hexText.length; i++) {
       var digit = _hexDigit(hexText.codeUnitAt(i));
       if (digit < 0) {
         _warning('Bad hex number', span);
         return new HexColorTerm(new BAD_HEX_VALUE(), hexText, span);
       }
       hexValue = (hexValue << 4) + digit;
     }
 
     // Make 3 character hex value #RRGGBB => #RGB iff:
     // high/low nibble of RR is the same, high/low nibble of GG is the same and
@@ skipping 14 matching lines @@
   }
 }
 
 class ExpressionsProcessor {
   final Expressions _exprs;
   int _index = 0;
 
   ExpressionsProcessor(this._exprs);
 
   // TODO(terry): Only handles ##px unit.
-  processFontSize() {
+  FontExpression processFontSize() {
     /* font-size[/line-height]
      *
      * Possible size values:
      *   xx-small
      *   small
      *   medium [default]
      *   large
      *   x-large
      *   xx-large
      *   smaller
      *   larger
      *   ##length in px, pt, etc.
      *   ##%, percent of parent elem's font-size
      *   inherit
      */
     LengthTerm size;
     LineHeight lineHt;
-    bool nextIsLineHeight = false;
+    var nextIsLineHeight = false;
     for (; _index < _exprs.expressions.length; _index++) {
       var expr = _exprs.expressions[_index];
       if (size == null && expr is LengthTerm) {
         // font-size part.
         size = expr;
       } else if (size != null) {
         if (expr is OperatorSlash) {
           // LineHeight could follow?
           nextIsLineHeight = true;
         } else if (nextIsLineHeight && expr is LengthTerm) {
           assert(expr.unit == TokenKind.UNIT_LENGTH_PX);
           lineHt = new LineHeight(expr.value, inPixels: true);
           nextIsLineHeight = false;
           _index++;
           break;
         } else {
           break;
         }
       } else {
         break;
       }
     }
 
     return new FontExpression(_exprs.span, size: size, lineHeight: lineHt);
   }
 
-  processFontFamily() {
-    final List<String> family = <String>[];
+  FontExpression processFontFamily() {
+    var family = <String>[];
 
     /* Possible family values:
      * font-family: arial, Times new roman ,Lucida Sans Unicode,Courier;
      * font-family: "Times New Roman", arial, Lucida Sans Unicode, Courier;
      */
-    bool moreFamilies = false;
+    var moreFamilies = false;
 
     for (; _index < _exprs.expressions.length; _index++) {
       Expression expr = _exprs.expressions[_index];
       if (expr is LiteralTerm) {
         if (family.length == 0 || moreFamilies) {
           // It's font-family now.
           family.add(expr.toString());
           moreFamilies = false;
         } else if (isChecked) {
           messages.warning('Only font-family can be a list', _exprs.span);
         }
       } else if (expr is OperatorComma && family.length > 0) {
         moreFamilies = true;
       } else {
         break;
       }
     }
 
     return new FontExpression(_exprs.span, family: family);
   }
 
-  processFont() {
-    var family;
+  FontExpression processFont() {
+    List<String> family;
 
     // Process all parts of the font expression.
     FontExpression fontSize;
     FontExpression fontFamily;
     for (; _index < _exprs.expressions.length; _index++) {
       var expr = _exprs.expressions[_index];
       // Order is font-size font-family
       if (fontSize == null) {
         fontSize = processFontSize();
       }
@@ skipping 14 matching lines @@
 }
 
 /**
  * Escapes [text] for use in a CSS string.
  * [single] specifies single quote `'` vs double quote `"`.
  */
 String _escapeString(String text, {bool single: false}) {
   StringBuffer result = null;
 
   for (int i = 0; i < text.length; i++) {
-    int code = text.codeUnitAt(i);
-    var replace = null;
+    var code = text.codeUnitAt(i);
+    String replace = null;
     switch (code) {
       case 34/*'"'*/:  if (!single) replace = r'\"'; break;
       case 39/*"'"*/:  if (single) replace = r"\'"; break;
     }
 
     if (replace != null && result == null) {
       result = new StringBuffer(text.substring(0, i));
     }
 
     if (result != null) result.write(replace != null ? replace : text[i]);
   }
 
   return result == null ? text : result.toString();
 }