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 779 matching lines @@
     if (_maybeEat(TokenKind.LPAREN)) {
       var terms = [];
       var expr;
       var keepGoing = true;
       while (keepGoing && (expr = processTerm()) != null) {
         // VarUsage is returns as a list
         terms.add(expr is List ? expr[0] : expr);
         keepGoing = !_peekKind(TokenKind.RPAREN);
         if (keepGoing) {
           if (_maybeEat(TokenKind.COMMA)) {
             params.add(terms);

[terry, 2013/11/07 18:17:05]

Good I thought it should stay as add.

             terms = [];
           }
         }
       }
       params.add(terms);
       _maybeEat(TokenKind.RPAREN);
     }
 
     if (eatSemiColon) {
       _eat(TokenKind.SEMICOLON);
@@ skipping 213 matching lines @@
     } while (_maybeEat(TokenKind.COMMA));
 
     if (selectors.length > 0) {
       return new SelectorGroup(selectors, _makeSpan(start));
     }
   }
 
   /**
    * Return list of selectors
    */
-  processSelector() {
+  Selector processSelector() {
     List<SimpleSelectorSequence> simpleSequences = [];
     int 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 334 matching lines @@
   //
   //  DASHMATCH:        '|='
   //
   //  PREFIXMATCH:      '^='
   //
   //  SUFFIXMATCH:      '$='
   //
   //  SUBSTRMATCH:      '*='
   //
   //
-  processAttribute() {
+  AttributeSelector processAttribute() {
     int start = _peekToken.start;
 
     if (_maybeEat(TokenKind.LBRACK)) {
       var attrName = identifier();
 
       int op;
       switch (_peek()) {
       case TokenKind.EQUALS:
       case TokenKind.INCLUDES:        // ~=
       case TokenKind.DASH_MATCH:      // |=
@@ skipping 33 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 116 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 _findStyle(String styleName) => _stylesToDart[styleName];
 
-  _styleForDart(Identifier property, Expressions exprs, List dartStyles) {
+  DartStyleExpression _styleForDart(Identifier property, Expressions exprs, List dartStyles) {
     int 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]) {
+  Expression processExpr([bool ieFilter = false]) {
     int start = _peekToken.start;
     Expressions expressions = new Expressions(_makeSpan(start));
 
     bool keepGoing = true;
     var expr;
     while (keepGoing && (expr = processTerm(ieFilter)) != null) {
       var op;
 
       int opStart = _peekToken.start;
 
@@ skipping 40 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* |
@@ skipping 166 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]) {
+  String processQuotedString([bool urlString = false]) {
     int start = _peekToken.start;
 
     // URI term sucks up everything inside of quotes(' or ") or between parens
     int 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;
@@ skipping 121 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));
     }
 
@@ skipping 44 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
@@ skipping 24 matching lines @@
           break;
         }
       } else {
         break;
       }
     }
 
     return new FontExpression(_exprs.span, size: size, lineHeight: lineHt);
   }
 
-  processFontFamily() {
+  FontExpression processFontFamily() {
     final List<String> 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;
 
     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() {
+  FontExpression processFont() {
     var 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 31 matching lines @@
 
     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();
 }