Improve the speed and memory efficiency of csslib parsing.

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_span/source_span.dart';
 
@@ skipping 178 matching lines @@
       : this.file = file,
         _baseUrl = baseUrl,
         tokenizer = new Tokenizer(file, text, true, start) {
     _peekToken = tokenizer.next();
   }
 
   /** Main entry point for parsing an entire CSS file. */
   StyleSheet parse() {
     List<TreeNode> productions = [];
 
-    int start = _peekToken.start;
+    var start = _peekToken.span;
     while (!_maybeEat(TokenKind.END_OF_FILE) && !_peekKind(TokenKind.RBRACE)) {
       // TODO(terry): Need to handle charset.
       var directive = processDirective();
       if (directive != null) {
         productions.add(directive);
         _maybeEat(TokenKind.SEMICOLON);
       } else {
         RuleSet ruleset = processRuleSet();
         if (ruleset != null) {
           productions.add(ruleset);
         } else {
           break;
         }
       }
     }
 
     checkEndOfFile();
 
     return new StyleSheet(productions, _makeSpan(start));
   }
 
   /** Main entry point for parsing a simple selector sequence. */
   StyleSheet parseSelector() {
     List<TreeNode> productions = [];
 
-    int start = _peekToken.start;
+    var start = _peekToken.span;
     while (!_maybeEat(TokenKind.END_OF_FILE) && !_peekKind(TokenKind.RBRACE)) {
       var selector = processSelector();
       if (selector != null) {
         productions.add(selector);
       }
     }
 
     checkEndOfFile();
 
     return new StyleSheet.selector(productions, _makeSpan(start));
@@ skipping 91 matching lines @@
     messages.error(message, location);
   }
 
   void _warning(String message, SourceSpan location) {
     if (location == null) {
       location = _peekToken.span;
     }
     messages.warning(message, location);
   }
 
-  SourceSpan _makeSpan(int start) {
+  SourceSpan _makeSpan(FileSpan start) {
     // TODO(terry): there are places where we are creating spans before we eat
-    // the tokens, so using _previousToken.end is not always valid.
-    var end = _previousToken != null && _previousToken.end >= start
-        ? _previousToken.end : _peekToken.end;
-    return file.span(start, end);
+    // the tokens, so using _previousToken is not always valid.
+    // TODO(nweiz): use < rather than compareTo when SourceSpan supports it.
+    if (_previousToken == null || _previousToken.span.compareTo(start) < 0) {
+      return start;
+    }
+    return start.expand(_previousToken.span);
   }
 
   ///////////////////////////////////////////////////////////////////
   // Top level productions
   ///////////////////////////////////////////////////////////////////
 
   /**
    * The media_query_list production below replaces the media_list production
    * from CSS2 the new grammar is:
    *
@@ skipping 29 matching lines @@
       firstTime = true;
     } while ((!firstTime && mediaQuery != null) || firstTime);
 
     return mediaQueries;
   }
 
   MediaQuery processMediaQuery([bool startQuery = true]) {
     // Grammar: [ONLY | NOT]? S* media_type S*
     //          [ AND S* MediaExpr ]* | MediaExpr [ AND S* MediaExpr ]*
 
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     // Is it a unary media operator?
     var op = _peekToken.text;
     var opLen = op.length;
     var unaryOp = TokenKind.matchMediaOperator(op, 0, opLen);
     if (unaryOp != -1) {
       if (isChecked) {
         if (startQuery &&
             unaryOp != TokenKind.MEDIA_OP_NOT ||
             unaryOp != TokenKind.MEDIA_OP_ONLY) {
           _warning("Only the unary operators NOT and ONLY allowed",
               _makeSpan(start));
         }
         if (!startQuery && unaryOp != TokenKind.MEDIA_OP_AND) {
           _warning("Only the binary AND operator allowed", _makeSpan(start));
         }
       }
       _next();
-      start = _peekToken.start;
+      start = _peekToken.span;
     }
 
     var type;
     if (startQuery && unaryOp != TokenKind.MEDIA_OP_AND) {
       // Get the media type.
       if (_peekIdentifier()) type = identifier();
     }
 
     var exprs = [];
 
@@ skipping 12 matching lines @@
         _next();
       }
     }
 
     if (unaryOp != -1 || type != null || exprs.length > 0) {
       return new MediaQuery(unaryOp, type, exprs, _makeSpan(start));
     }
   }
 
   MediaExpression processMediaExpression([bool andOperator = false]) {
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     // Grammar: '(' S* media_feature S* [ ':' S* expr ]? ')' S*
     if (_maybeEat(TokenKind.LPAREN)) {
       if (_peekIdentifier()) {
         var feature = identifier();           // Media feature.
         while (_maybeEat(TokenKind.COLON)) {
-          int startExpr = _peekToken.start;
+          var startExpr = _peekToken.span;
           var exprs = processExpr();
           if (_maybeEat(TokenKind.RPAREN)) {
             return new MediaExpression(andOperator, feature, exprs,
                 _makeSpan(startExpr));
           } else if (isChecked) {
             _warning("Missing parenthesis around media expression",
                 _makeSpan(start));
             return null;
           }
         }
@@ skipping 15 matching lines @@
    *  keyframes:          '@-webkit-keyframes ...' (see grammar below).
    *  font_face:          '@font-face' '{' declarations '}'
    *  namespace:          '@namespace name url("xmlns")
    *  host:               '@host '{' ruleset '}'
    *  mixin:              '@mixin name [(args,...)] '{' declarations/ruleset '}'
    *  include:            '@include name [(@arg,@arg1)]
    *                      '@include name [(@arg...)]
    *  content             '@content'
    */
   processDirective() {
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     var tokId = processVariableOrDirective();
     if (tokId is VarDefinitionDirective) return tokId;
     switch (tokId) {
       case TokenKind.DIRECTIVE_IMPORT:
         _next();
 
         // @import "uri_string" or @import url("uri_string") are identical; only
         // a url can follow an @import.
         String importStr;
@@ skipping 198 matching lines @@
 
         var name;
         if (_peekIdentifier()) {
           name = identifier();
         }
 
         _eat(TokenKind.LBRACE);
 
         List<TreeNode> productions = [];
 
-        start = _peekToken.start;
+        start = _peekToken.span;
         while (!_maybeEat(TokenKind.END_OF_FILE)) {
           RuleSet ruleset = processRuleSet();
           if (ruleset == null) {
             break;
           }
           productions.add(ruleset);
         }
 
         _eat(TokenKind.RBRACE);
 
@@ skipping 31 matching lines @@
             }
           } else {
             namespaceUri = processQuotedString(false);
           }
         }
 
         return new NamespaceDirective(prefix != null ? prefix.name : '',
             namespaceUri, _makeSpan(start));
 
       case TokenKind.DIRECTIVE_MIXIN:
-        return processMixin(start);
+        return processMixin();
 
       case TokenKind.DIRECTIVE_INCLUDE:
         return processInclude( _makeSpan(start));
 
       case TokenKind.DIRECTIVE_CONTENT:
         // TODO(terry): TBD
         _warning("@content not implemented.", _makeSpan(start));
         return null;
     }
     return null;
   }
 
   /**
    * Parse the mixin beginning token offset [start]. Returns a [MixinDefinition]
    * node.
    *
    * Mixin grammar:
    *
    *  @mixin IDENT [(args,...)] '{'
    *    [ruleset | property | directive]*
    *  '}'
    */
-  MixinDefinition processMixin(int start) {
+  MixinDefinition processMixin() {
     _next();
 
     var name = identifier();
 
     List<VarDefinitionDirective> params = [];
     // Any parameters?
     if (_maybeEat(TokenKind.LPAREN)) {
       var mustHaveParam = false;
       var keepGoing = true;
       while (keepGoing) {
         var varDef = processVariableOrDirective(mixinParameter: true);
         if (varDef is VarDefinitionDirective || varDef is VarDefinition) {
           params.add(varDef);
         } else if (mustHaveParam) {
-          _warning("Expecting parameter", _makeSpan(_peekToken.start));
+          _warning("Expecting parameter", _makeSpan(_peekToken.span));
           keepGoing = false;
         }
         if (_maybeEat(TokenKind.COMMA)) {
           mustHaveParam = true;
           continue;
         }
         keepGoing = !_maybeEat(TokenKind.RPAREN);
       }
     }
 
     _eat(TokenKind.LBRACE);
 
     List<TreeNode> productions = [];
     List<TreeNode> declarations = [];
     var mixinDirective;
 
-    start = _peekToken.start;
+    var start = _peekToken.span;
     while (!_maybeEat(TokenKind.END_OF_FILE)) {
       var directive = processDirective();
       if (directive != null) {
         productions.add(directive);
         continue;
       }
 
       var declGroup = processDeclarations(checkBrace: false);
       var decls = [];
       if (declGroup.declarations.any((decl) {
         return decl is Declaration &&
             decl is! IncludeMixinAtDeclaration;
       })) {
         var newDecls = [];
         productions.forEach((include) {
           // If declGroup has items that are declarations then we assume
           // this mixin is a declaration mixin not a top-level mixin.
           if (include is IncludeDirective) {
             newDecls.add(new IncludeMixinAtDeclaration(include,
                 include.span));
           } else {
             _warning("Error mixing of top-level vs declarations mixins",
-                _makeSpan(include));
+                _makeSpan(include.span));
           }
         });
         declGroup.declarations.insertAll(0, newDecls);
         productions = [];
       } else {
         // Declarations are just @includes make it a list of productions
         // not a declaration group (anything else is a ruleset).  Make it a
         // list of productions, not a declaration group.
         for (var decl in declGroup.declarations) {
           productions.add(decl is IncludeMixinAtDeclaration ?
@@ skipping 28 matching lines @@
     _eat(TokenKind.RBRACE);
 
     return mixinDirective;
   }
 
   /**
    * Returns a VarDefinitionDirective or VarDefinition if a varaible otherwise
    * return the token id of a directive or -1 if neither.
    */
   processVariableOrDirective({bool mixinParameter: false}) {
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     var tokId = _peek();
     // Handle case for @ directive (where there's a whitespace between the @
     // sign and the directive name.  Technically, it's not valid grammar but
     // a number of CSS tests test for whitespace between @ and name.
     if (tokId == TokenKind.AT) {
       Token tok = _next();
       tokId = _peek();
       if (_peekIdentifier()) {
         // Is it a directive?
@@ skipping 143 matching lines @@
       return null;
     } else {
       // Remember any messages from look ahead.
       oldMessages.mergeMessages(messages);
       messages = oldMessages;
       return selGroup;
     }
   }
 
   DeclarationGroup processDeclarations({bool checkBrace: true}) {
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     if (checkBrace) _eat(TokenKind.LBRACE);
 
     List decls = [];
     List dartStyles = [];             // List of latest styles exposed to Dart.
 
     do {
       var selectorGroup = _nestedSelector();
       while (selectorGroup != null) {
         // Nested selector so process as a ruleset.
@@ skipping 37 matching lines @@
         }
       }
     }
 
     return new DeclarationGroup(decls, _makeSpan(start));
   }
 
   List<DeclarationGroup> processMarginsDeclarations() {
     List groups = [];
 
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     _eat(TokenKind.LBRACE);
 
     List<Declaration> decls = [];
     List dartStyles = [];             // List of latest styles exposed to Dart.
 
     do {
       switch (_peek()) {
         case TokenKind.MARGIN_DIRECTIVE_TOPLEFTCORNER:
         case TokenKind.MARGIN_DIRECTIVE_TOPLEFT:
@@ skipping 64 matching lines @@
 
     if (decls.length > 0) {
       groups.add(new DeclarationGroup(decls, _makeSpan(start)));
     }
 
     return groups;
   }
 
   SelectorGroup processSelectorGroup() {
     List<Selector> selectors = [];
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     do {
       Selector selector = processSelector();
       if (selector != null) {
         selectors.add(selector);
       }
     } while (_maybeEat(TokenKind.COMMA));
 
     if (selectors.length > 0) {
       return new SelectorGroup(selectors, _makeSpan(start));
     }
   }
 
   /**
    * Return list of selectors
    */
   Selector processSelector() {
     var simpleSequences = <SimpleSelectorSequence>[];
-    var start = _peekToken.start;
+    var start = _peekToken.span;
     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;
       }
     }
 
     if (simpleSequences.length > 0) {
       return new Selector(simpleSequences, _makeSpan(start));
     }
   }
 
   simpleSelectorSequence(bool forceCombinatorNone) {
-    var start = _peekToken.start;
+    var start = _peekToken.span;
     var combinatorType = TokenKind.COMBINATOR_NONE;
     var thisOperator = false;
 
     switch (_peek()) {
       case TokenKind.PLUS:
         _eat(TokenKind.PLUS);
         combinatorType = TokenKind.COMBINATOR_PLUS;
         break;
       case TokenKind.GREATER:
         _eat(TokenKind.GREATER);
@@ skipping 55 matching lines @@
    *    class
    *       : '.' IDENT
    */
   simpleSelector() {
     // TODO(terry): Natalie makes a good point parsing of namespace and element
     //              are essentially the same (asterisk or identifier) other
     //              than the error message for element.  Should consolidate the
     //              code.
     // TODO(terry): Need to handle attribute namespace too.
     var first;
-    int start = _peekToken.start;
+    var start = _peekToken.span;
     switch (_peek()) {
       case TokenKind.ASTERISK:
         // Mark as universal namespace.
         var tok = _next();
-        first = new Wildcard(_makeSpan(tok.start));
+        first = new Wildcard(_makeSpan(tok.span));
         break;
       case TokenKind.IDENTIFIER:
         first = identifier();
         break;
       default:
         // Expecting simple selector.
         // TODO(terry): Could be a synthesized token like value, etc.
         if (TokenKind.isKindIdentifier(_peek())) {
           first = identifier();
         } else if (_peekKind(TokenKind.SEMICOLON)) {
           // Can't be a selector if we found a semi-colon.
           return null;
         }
         break;
     }
 
     if (_maybeEat(TokenKind.NAMESPACE)) {
       var element;
       switch (_peek()) {
         case TokenKind.ASTERISK:
           // Mark as universal element
           var tok = _next();
-          element = new Wildcard(_makeSpan(tok.start));
+          element = new Wildcard(_makeSpan(tok.span));
           break;
         case TokenKind.IDENTIFIER:
           element = identifier();
           break;
         default:
           _error('expected element name or universal(*), but found $_peekToken',
               _peekToken.span);
           break;
       }
 
@@ skipping 16 matching lines @@
     }
 
     return false;
   }
 
   /**
    * type_selector | universal | HASH | class | attrib | pseudo
    */
   simpleSelectorTail() {
     // Check for HASH | class | attrib | pseudo | negation
-    var start = _peekToken.start;
+    var start = _peekToken.span;
     switch (_peek()) {
       case TokenKind.HASH:
         _eat(TokenKind.HASH);
 
         var hasWhiteSpace = false;
         if (_anyWhiteSpaceBeforePeekToken(TokenKind.HASH)) {
           _warning("Not a valid ID selector expected #id", _makeSpan(start));
           hasWhiteSpace = true;
         }
         if (_peekIdentifier()) {
@@ skipping 26 matching lines @@
       case TokenKind.LBRACK:
         return processAttribute();
       case TokenKind.DOUBLE:
         _error('name must start with a alpha character, but found a number',
             _peekToken.span);
         _next();
         break;
     }
   }
 
-  processPseudoSelector(int start) {
+  processPseudoSelector(FileSpan start) {
     // :pseudo-class ::pseudo-element
     // TODO(terry): '::' should be token.
     _eat(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()) {
@@ skipping 58 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() {
-    var start = _peekToken.start;
+    var start = _peekToken.span;
 
     var expressions = [];
 
     Token termToken;
     var value;
 
     var keepParsing = true;
     while (keepParsing) {
       switch (_peek()) {
         case TokenKind.PLUS:
-          start = _peekToken.start;
+          start = _peekToken.span;
           termToken = _next();
           expressions.add(new OperatorPlus(_makeSpan(start)));
           break;
         case TokenKind.MINUS:
-          start = _peekToken.start;
+          start = _peekToken.span;
           termToken = _next();
           expressions.add(new OperatorMinus(_makeSpan(start)));
           break;
         case TokenKind.INTEGER:
           termToken = _next();
           value = int.parse(termToken.text);
           break;
         case TokenKind.DOUBLE:
           termToken = _next();
           value = double.parse(termToken.text);
@@ skipping 44 matching lines @@
   //  DASHMATCH:        '|='
   //
   //  PREFIXMATCH:      '^='
   //
   //  SUFFIXMATCH:      '$='
   //
   //  SUBSTRMATCH:      '*='
   //
   //
   AttributeSelector processAttribute() {
-    var start = _peekToken.start;
+    var start = _peekToken.span;
 
     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 35 matching lines @@
   //  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)
   //
   Declaration processDeclaration(List dartStyles) {
     Declaration decl;
 
-    int start = _peekToken.start;
+    var start = _peekToken.span;
 
     // IE7 hack of * before property name if so the property is IE7 or below.
     var ie7 = _peekKind(TokenKind.ASTERISK);
     if (ie7) {
       _next();
     }
 
     // IDENT ':' expr '!important'?
     if (TokenKind.isIdentifier(_peekToken.kind)) {
       var propertyIdent = identifier();
@@ skipping 31 matching lines @@
 
       _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)) {
-        var pseudoSelector = processPseudoSelector(_peekToken.start);
+        var pseudoSelector = processPseudoSelector(_peekToken.span);
         if (pseudoSelector is PseudoElementSelector ||
             pseudoSelector is PseudoClassSelector) {
           simpleSequences.add(pseudoSelector);
         } else {
           _warning("not a valid selector", span);
         }
       }
       decl = new ExtendDeclaration(simpleSequences, span);
     }
 
@@ skipping 331 matching lines @@
   }
 
   //  Expression grammar:
   //
   //  expression:   term [ operator? term]*
   //
   //  operator:     '/' | ','
   //  term:         (see processTerm)
   //
   Expressions processExpr([bool ieFilter = false]) {
-    var start = _peekToken.start;
+    var start = _peekToken.span;
     var expressions = new Expressions(_makeSpan(start));
 
     var keepGoing = true;
     var expr;
     while (keepGoing && (expr = processTerm(ieFilter)) != null) {
       var op;
 
-      var opStart = _peekToken.start;
+      var opStart = _peekToken.span;
 
       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
         // end of an expression.
-        var ie8Start = _peekToken.start;
+        var ie8Start = _peekToken.span;
 
         _next();
         if (_peekKind(TokenKind.INTEGER)) {
           var numToken = _next();
           var value = int.parse(numToken.text);
           if (value == 9) {
             op = new IE8Term(_makeSpan(ie8Start));
           } else if (isChecked) {
             _warning("\$value is not valid in an expression", _makeSpan(start));
           }
@@ skipping 43 matching lines @@
   //  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]) {
-    var start = _peekToken.start;
+    var start = _peekToken.span;
     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 226 matching lines @@
             ? new LiteralTerm(value, value.name, span)
             : new NumberTerm(value, t.text, span);
       }
       break;
     }
 
     return term;
   }
 
   String processQuotedString([bool urlString = false]) {
-    var start = _peekToken.start;
+    var start = _peekToken.span;
 
     // URI term sucks up everything inside of quotes(' or ") or between parens
     var stopToken = urlString ? TokenKind.RPAREN : -1;
 
     // Note: disable skipping whitespace tokens inside a string.
     // TODO(jmesserly): the layering here feels wrong.
     var skipWhitespace = tokenizer._skipWhitespace;
     tokenizer._skipWhitespace = false;
 
     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.
+      _next(); // Skip the SINGLE_QUOTE.
+      start = _peekToken.span;

[sra1, 2014/12/02 23:43:45]

Will the _peekToken always have a span starting immediately following the
skipped 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.
+      _next(); // Skip the DOUBLE_QUOTE.
+      start = _peekToken.span;
       break;
     default:
       if (urlString) {
         if (_peek() == TokenKind.LPAREN) {
           _next();    // Skip the LPAREN.
-          start = _peekToken.start;
+          start = _peekToken.span;
         }
         stopToken = TokenKind.RPAREN;
       } else {
         _error('unexpected string', _makeSpan(start));
       }
       break;
     }
 
     // Gobble up everything until we hit our stop token.
-    var runningStart = _peekToken.start;
-
     var stringValue = new StringBuffer();
     while (_peek() != stopToken && _peek() != TokenKind.END_OF_FILE) {
       stringValue.write(_next().text);
     }
 
     tokenizer._skipWhitespace = skipWhitespace;
 
     // All characters between quotes is the string.
     if (stopToken != TokenKind.RPAREN) {
       _next();    // Skip the SINGLE_QUOTE or DOUBLE_QUOTE;
     }
 
     return stringValue.toString();
   }
 
   // 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) {
+  processIEFilter(FileSpan startAfterProgidColon) {
     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,
+            var tok = tokenizer.makeIEFilter(startAfterProgidColon.start.offset,
                 _peekToken.start);
             return new LiteralTerm(tok.text, tok.text, tok.span);
           }
           break;
         default:
           _eat(_peek());
       }
     }
   }
 
   //  Function grammar:
   //
   //  function:     IDENT '(' expr ')'
   //
   processFunction(Identifier func) {
-    var start = _peekToken.start;
+    var start = _peekToken.span;
 
     var name = func.name;
 
     switch (name) {
     case 'url':
       // URI term sucks up everything inside of quotes(' or ") or between parens
       var urlParam = processQuotedString(true);
 
       // TODO(terry): Better error messge and checking for mismatched quotes.
       if (_peek() == TokenKind.END_OF_FILE) {
@@ skipping 44 matching lines @@
   }
 
   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("", _makeSpan(tok.span));
     }
 
-    return new Identifier(tok.text, _makeSpan(tok.start));
+    return new Identifier(tok.text, _makeSpan(tok.span));
   }
 
   // TODO(terry): Move this to base <= 36 and into shared code.
   static int _hexDigit(int c) {
     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;
@@ skipping 159 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();
 }