Update charted to 0.4.8 and roll

packages/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';
 
-import "visitor.dart";
+import 'visitor.dart';
 import 'src/messages.dart';
 import 'src/options.dart';
 
+export 'src/messages.dart' show Message;
 export 'src/options.dart';
 
 part 'src/analyzer.dart';
 part 'src/polyfill.dart';
 part 'src/property.dart';
 part 'src/token.dart';
 part 'src/tokenizer_base.dart';
 part 'src/tokenizer.dart';
 part 'src/tokenkind.dart';
 
+enum ClauseType {
+  none,
+  conjunction,
+  disjunction,
+}
+
 /** 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);
 }
 
 // TODO(jmesserly): this should not be global
 void _createMessages({List<Message> errors, PreprocessorOptions options}) {
   if (errors == null) errors = [];
 
   if (options == null) {
     options = new PreprocessorOptions(useColors: false, inputFile: 'memory');
   }
 
   messages = new Messages(options: options, 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(input, {List<Message> errors, PreprocessorOptions options,
-    bool nested: true, bool polyfill: false, List<StyleSheet> includes: null}) {
+StyleSheet compile(input,
+    {List<Message> errors,
+    PreprocessorOptions 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(source);
 
@@ skipping 46 matching lines @@
       .parseSelector();
 }
 
 SelectorGroup parseSelectorGroup(input, {List<Message> errors}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors);
 
   var file = new SourceFile(source);
   return (new _Parser(file, source)
-    // TODO(jmesserly): this fix should be applied to the parser. It's tricky
-    // because by the time the flag is set one token has already been fetched.
-    ..tokenizer.inSelector = true).processSelectorGroup();
+        // TODO(jmesserly): this fix should be applied to the parser. It's tricky
+        // because by the time the flag is set one token has already been fetched.
+        ..tokenizer.inSelector = true)
+      .processSelectorGroup();
 }
 
 String _inputAsString(input) {
   String source;
 
   if (input is String) {
     source = input;
   } else if (input is List) {
     // TODO(terry): The parse function needs an "encoding" argument and will
     //              default to whatever encoding CSS defaults to.
@@ skipping 20 matching lines @@
   return source;
 }
 
 // TODO(terry): Consider removing this class when all usages can be eliminated
 //               or replaced with compile API.
 /** Public parsing interface for csslib. */
 class Parser {
   final _Parser _parser;
 
   // TODO(jmesserly): having file and text is redundant.
+  // TODO(rnystrom): baseUrl isn't used. Remove from API.
   Parser(SourceFile file, String text, {int start: 0, String baseUrl})
-      : _parser = new _Parser(file, text, start: start, baseUrl: baseUrl);
+      : _parser = new _Parser(file, text, start: start);
 
   StyleSheet parse() => _parser.parse();
 }
 
+// CSS2.1 pseudo-elements which were defined with a single ':'.
+final _legacyPseudoElements = new Set<String>.from(const [
+  'after',
+  'before',
+  'first-letter',
+  'first-line',
+]);
+
 /** A simple recursive descent parser for CSS. */
 class _Parser {
   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;
 
   Token _previousToken;
   Token _peekToken;
 
-  _Parser(SourceFile file, String text, {int start: 0, String baseUrl})
+  _Parser(SourceFile file, String text, {int start: 0})
       : 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 = [];
 
     var start = _peekToken.span;
     while (!_maybeEat(TokenKind.END_OF_FILE) && !_peekKind(TokenKind.RBRACE)) {
@@ skipping 153 matching lines @@
    *    : [ONLY | NOT]? S* media_type S* [ AND S* expression ]*
    *    | expression [ AND S* expression ]*
    *   media_type
    *    : IDENT
    *   expression
    *    : '(' S* media_feature S* [ ':' S* expr ]? ')' S*
    *   media_feature
    *    : IDENT
    */
   List<MediaQuery> processMediaQueryList() {
-    var mediaQueries = [];
+    var mediaQueries = <MediaQuery>[];
 
-    bool firstTime = true;
-    var mediaQuery;
     do {
-      mediaQuery = processMediaQuery(firstTime == true);
+      var mediaQuery = processMediaQuery();
       if (mediaQuery != null) {
         mediaQueries.add(mediaQuery);
-        firstTime = false;
-        continue;
+      } else {
+        break;
       }
-
-      // Any more more media types separated by comma.
-      if (!_maybeEat(TokenKind.COMMA)) break;
-
-      // Yep more media types start again.
-      firstTime = true;
-    } while ((!firstTime && mediaQuery != null) || firstTime);
+    } while (_maybeEat(TokenKind.COMMA));
 
     return mediaQueries;
   }
 
-  MediaQuery processMediaQuery([bool startQuery = true]) {
+  MediaQuery processMediaQuery() {
     // Grammar: [ONLY | NOT]? S* media_type S*
     //          [ AND S* MediaExpr ]* | MediaExpr [ AND S* MediaExpr ]*
 
     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 ||
+        if (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.span;
     }
 
     var type;
-    if (startQuery && unaryOp != TokenKind.MEDIA_OP_AND) {
-      // Get the media type.
-      if (_peekIdentifier()) type = identifier();
-    }
+    // Get the media type.
+    if (_peekIdentifier()) type = identifier();
 
-    var exprs = [];
+    var exprs = <MediaExpression>[];
 
-    if (unaryOp == -1 || unaryOp == TokenKind.MEDIA_OP_AND) {
-      var andOp = false;
-      while (true) {
-        var expr = processMediaExpression(andOp);
-        if (expr == null) break;
-
-        exprs.add(expr);
+    while (true) {
+      // Parse AND if query has a media_type or previous expression.
+      var andOp = exprs.isNotEmpty || type != null;
+      if (andOp) {
         op = _peekToken.text;
         opLen = op.length;
-        andOp = TokenKind.matchMediaOperator(op, 0, opLen) ==
-            TokenKind.MEDIA_OP_AND;
-        if (!andOp) break;
+        if (TokenKind.matchMediaOperator(op, 0, opLen) !=
+            TokenKind.MEDIA_OP_AND) {
+          break;
+        }
         _next();
       }
+
+      var expr = processMediaExpression(andOp);
+      if (expr == null) break;
+
+      exprs.add(expr);
     }
 
     if (unaryOp != -1 || type != null || exprs.length > 0) {
       return new MediaQuery(unaryOp, type, exprs, _makeSpan(start));
     }
     return null;
   }
 
   MediaExpression processMediaExpression([bool andOperator = false]) {
     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)) {
-          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;
-          }
+        var exprs = _maybeEat(TokenKind.COLON)
+            ? processExpr()
+            : new Expressions(_makeSpan(_peekToken.span));
+        if (_maybeEat(TokenKind.RPAREN)) {
+          return new MediaExpression(
+              andOperator, feature, exprs, _makeSpan(start));
+        } else if (isChecked) {
+          _warning(
+              "Missing parenthesis around media expression", _makeSpan(start));
+          return null;
         }
       } else if (isChecked) {
         _warning("Missing media feature in media expression", _makeSpan(start));
       }
     }
     return null;
   }
 
   /**
    * Directive grammar:
    *
    *  import:             '@import' [string | URI] media_list?
    *  media:              '@media' media_query_list '{' ruleset '}'
    *  page:               '@page' [':' IDENT]? '{' declarations '}'
    *  stylet:             '@stylet' IDENT '{' ruleset '}'
    *  media_query_list:   IDENT [',' IDENT]
    *  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'
+   *  content:            '@content'
+   *  -moz-document:      '@-moz-document' [ <url> | url-prefix(<string>) |
+   *                          domain(<string>) | regexp(<string) ]# '{'
+   *                        declarations
+   *                      '}'
+   *  supports:           '@supports' supports_condition group_rule_body
    */
   processDirective() {
     var start = _peekToken.span;
 
     var tokId = processVariableOrDirective();
     if (tokId is VarDefinitionDirective) return tokId;
     switch (tokId) {
       case TokenKind.DIRECTIVE_IMPORT:
         _next();
 
@@ skipping 256 matching lines @@
         }
 
         return new NamespaceDirective(
             prefix != null ? prefix.name : '', namespaceUri, _makeSpan(start));
 
       case TokenKind.DIRECTIVE_MIXIN:
         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;
+      case TokenKind.DIRECTIVE_MOZ_DOCUMENT:
+        return processDocumentDirective();
+      case TokenKind.DIRECTIVE_SUPPORTS:
+        return processSupportsDirective();
+      case TokenKind.DIRECTIVE_VIEWPORT:
+      case TokenKind.DIRECTIVE_MS_VIEWPORT:
+        return processViewportDirective();
     }
     return null;
   }
 
   /**
    * Parse the mixin beginning token offset [start]. Returns a [MixinDefinition]
    * node.
    *
    * Mixin grammar:
    *
    *  @mixin IDENT [(args,...)] '{'
    *    [ruleset | property | directive]*
    *  '}'
    */
   MixinDefinition processMixin() {
     _next();
 
     var name = identifier();
 
-    List<VarDefinitionDirective> params = [];
+    var params = <TreeNode>[];
     // 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.span));
@@ skipping 17 matching lines @@
       var directive = processDirective();
       if (directive != null) {
         productions.add(directive);
         continue;
       }
 
       var declGroup = processDeclarations(checkBrace: false);
       if (declGroup.declarations.any((decl) {
         return decl is Declaration && decl is! IncludeMixinAtDeclaration;
       })) {
-        var newDecls = [];
+        var newDecls = <Declaration>[];
         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.span));
           }
         });
@@ skipping 109 matching lines @@
     *
      *  @include IDENT [(args,...)];
      */
     _next();
 
     var name;
     if (_peekIdentifier()) {
       name = identifier();
     }
 
-    var params = [];
+    var params = <List<Expression>>[];
 
     // Any parameters?  Parameters can be multiple terms per argument e.g.,
     // 3px solid yellow, green is two parameters:
     //    1. 3px solid yellow
     //    2. green
     // the first has 3 terms and the second has 1 term.
     if (_maybeEat(TokenKind.LPAREN)) {
-      var terms = [];
+      var terms = <Expression>[];
       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);
             terms = [];
           }
         }
       }
       params.add(terms);
       _maybeEat(TokenKind.RPAREN);
     }
 
     if (eatSemiColon) {
       _eat(TokenKind.SEMICOLON);
     }
 
     return new IncludeDirective(name.name, params, span);
   }
 
+  DocumentDirective processDocumentDirective() {
+    var start = _peekToken.span;
+    _next(); // '@-moz-document'
+    var functions = <LiteralTerm>[];
+    do {
+      var function;
+
+      // Consume function token: IDENT '('
+      var ident = identifier();
+      _eat(TokenKind.LPAREN);
+
+      // Consume function arguments.
+      if (ident.name == 'url-prefix' || ident.name == 'domain') {
+        // @-moz-document allows the 'url-prefix' and 'domain' functions to
+        // omit quotations around their argument, contrary to the standard
+        // in which they must be strings. To support this we consume a
+        // string with optional quotation marks, then reapply quotation
+        // marks so they're present in the emitted CSS.
+        var argumentStart = _peekToken.span;
+        var value = processQuotedString(true);
+        // Don't quote the argument if it's empty. '@-moz-document url-prefix()'
+        // is a common pattern used for browser detection.
+        var argument = value.isNotEmpty ? '"$value"' : '';
+        var argumentSpan = _makeSpan(argumentStart);
+
+        _eat(TokenKind.RPAREN);
+
+        var arguments = new Expressions(_makeSpan(argumentSpan))
+          ..add(new LiteralTerm(argument, argument, argumentSpan));
+        function = new FunctionTerm(
+            ident.name, ident.name, arguments, _makeSpan(ident.span));
+      } else {
+        function = processFunction(ident);
+      }
+
+      functions.add(function);
+    } while (_maybeEat(TokenKind.COMMA));
+
+    _eat(TokenKind.LBRACE);
+    var groupRuleBody = processGroupRuleBody();
+    _eat(TokenKind.RBRACE);
+    return new DocumentDirective(functions, groupRuleBody, _makeSpan(start));
+  }
+
+  SupportsDirective processSupportsDirective() {
+    var start = _peekToken.span;
+    _next(); // '@supports'
+    var condition = processSupportsCondition();
+    _eat(TokenKind.LBRACE);
+    var groupRuleBody = processGroupRuleBody();
+    _eat(TokenKind.RBRACE);
+    return new SupportsDirective(condition, groupRuleBody, _makeSpan(start));
+  }
+
+  SupportsCondition processSupportsCondition() {
+    if (_peekKind(TokenKind.IDENTIFIER)) {
+      return processSupportsNegation();
+    }
+
+    var start = _peekToken.span;
+    var conditions = <SupportsConditionInParens>[];
+    var clauseType = ClauseType.none;
+
+    while (true) {
+      conditions.add(processSupportsConditionInParens());
+
+      var type;
+      var text = _peekToken.text.toLowerCase();
+
+      if (text == 'and') {
+        type = ClauseType.conjunction;
+      } else if (text == 'or') {
+        type = ClauseType.disjunction;
+      } else {
+        break; // Done parsing clause.
+      }
+
+      if (clauseType == ClauseType.none) {
+        clauseType = type; // First operand and operator of clause.
+      } else if (clauseType != type) {
+        _error("Operators can't be mixed without a layer of parentheses",
+            _peekToken.span);
+        break;
+      }
+
+      _next(); // Consume operator.
+    }
+
+    if (clauseType == ClauseType.conjunction) {
+      return new SupportsConjunction(conditions, _makeSpan(start));
+    } else if (clauseType == ClauseType.disjunction) {
+      return new SupportsDisjunction(conditions, _makeSpan(start));
+    } else {
+      return conditions.first;
+    }
+  }
+
+  SupportsNegation processSupportsNegation() {
+    var start = _peekToken.span;
+    var text = _peekToken.text.toLowerCase();
+    if (text != 'not') return null;
+    _next(); // 'not'
+    var condition = processSupportsConditionInParens();
+    return new SupportsNegation(condition, _makeSpan(start));
+  }
+
+  SupportsConditionInParens processSupportsConditionInParens() {
+    var start = _peekToken.span;
+    _eat(TokenKind.LPAREN);
+    // Try to parse a condition.
+    var condition = processSupportsCondition();
+    if (condition != null) {
+      _eat(TokenKind.RPAREN);
+      return new SupportsConditionInParens.nested(condition, _makeSpan(start));
+    }
+    // Otherwise, parse a declaration.
+    var declaration = processDeclaration([]);
+    _eat(TokenKind.RPAREN);
+    return new SupportsConditionInParens(declaration, _makeSpan(start));
+  }
+
+  ViewportDirective processViewportDirective() {
+    var start = _peekToken.span;
+    var name = _next().text;
+    var declarations = processDeclarations();
+    return new ViewportDirective(name, declarations, _makeSpan(start));
+  }
+
   RuleSet processRuleSet([SelectorGroup selectorGroup]) {
     if (selectorGroup == null) {
       selectorGroup = processSelectorGroup();
     }
     if (selectorGroup != null) {
       return new RuleSet(
           selectorGroup, processDeclarations(), selectorGroup.span);
     }
     return null;
   }
 
+  List<TreeNode> processGroupRuleBody() {
+    var nodes = <TreeNode>[];
+    while (!(_peekKind(TokenKind.RBRACE) || _peekKind(TokenKind.END_OF_FILE))) {
+      var directive = processDirective();
+      if (directive != null) {
+        nodes.add(directive);
+        continue;
+      }
+      var ruleSet = processRuleSet();
+      if (ruleSet != null) {
+        nodes.add(ruleSet);
+        continue;
+      }
+      break;
+    }
+    return nodes;
+  }
+
   /**
    * Look ahead to see if what should be a declaration is really a selector.
    * If it's a selector than it's a nested selector.  This support's Less'
    * nested selector syntax (requires a look ahead). E.g.,
    *
    *    div {
    *      width : 20px;
    *      span {
    *        color: red;
    *      }
@@ skipping 34 matching lines @@
       messages = oldMessages;
       return selGroup;
     }
   }
 
   DeclarationGroup processDeclarations({bool checkBrace: true}) {
     var start = _peekToken.span;
 
     if (checkBrace) _eat(TokenKind.LBRACE);
 
-    List decls = [];
-    List dartStyles = []; // List of latest styles exposed to Dart.
+    var decls = <TreeNode>[];
+    var dartStyles = []; // List of latest styles exposed to Dart.
 
     do {
       var selectorGroup = _nestedSelector();
       while (selectorGroup != null) {
         // Nested selector so process as a ruleset.
         var ruleset = processRuleSet(selectorGroup);
         decls.add(ruleset);
         selectorGroup = _nestedSelector();
       }
 
@@ skipping 30 matching lines @@
           // Dart style not live, ignore these styles in this Declarations.
           decl.dartStyle = null;
         }
       }
     }
 
     return new DeclarationGroup(decls, _makeSpan(start));
   }
 
   List<DeclarationGroup> processMarginsDeclarations() {
-    List groups = [];
+    var groups = <DeclarationGroup>[];
 
     var start = _peekToken.span;
 
     _eat(TokenKind.LBRACE);
 
     List<Declaration> decls = [];
     List dartStyles = []; // List of latest styles exposed to Dart.
 
     do {
       switch (_peek()) {
@@ skipping 89 matching lines @@
   }
 
   /**
    * Return list of selectors
    */
   Selector processSelector() {
     var simpleSequences = <SimpleSelectorSequence>[];
     var start = _peekToken.span;
     while (true) {
       // First item is never descendant make sure it's COMBINATOR_NONE.
-      var selectorItem = simpleSelectorSequence(simpleSequences.length == 0);
+      var selectorItem = simpleSelectorSequence(simpleSequences.isEmpty);
       if (selectorItem != null) {
         simpleSequences.add(selectorItem);
       } else {
         break;
       }
     }
 
-    if (simpleSequences.length > 0) {
-      return new Selector(simpleSequences, _makeSpan(start));
-    }
+    if (simpleSequences.isEmpty) return null;
+
+    return new Selector(simpleSequences, _makeSpan(start));
+  }
+
+  /// Same as [processSelector] but reports an error for each combinator.
+  ///
+  /// This is a quick fix for parsing <compound-selectors> until the parser
+  /// supports Selector Level 4 grammar:
+  /// https://drafts.csswg.org/selectors-4/#typedef-compound-selector
+  Selector processCompoundSelector() {
+    return processSelector()
+      ..simpleSelectorSequences.forEach((sequence) {
+        if (!sequence.isCombinatorNone) {
+          _error('compound selector can not contain combinator', sequence.span);
+        }
+      });
   }
 
   simpleSelectorSequence(bool forceCombinatorNone) {
     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:
+        // Parse > or >>>
         _eat(TokenKind.GREATER);
-        combinatorType = TokenKind.COMBINATOR_GREATER;
+        if (_maybeEat(TokenKind.GREATER)) {
+          _eat(TokenKind.GREATER);
+          combinatorType = TokenKind.COMBINATOR_SHADOW_PIERCING_DESCENDANT;
+        } else {
+          combinatorType = TokenKind.COMBINATOR_GREATER;
+        }
         break;
       case TokenKind.TILDE:
         _eat(TokenKind.TILDE);
         combinatorType = TokenKind.COMBINATOR_TILDE;
         break;
+      case TokenKind.SLASH:
+        // Parse /deep/
+        _eat(TokenKind.SLASH);
+        var ate = _maybeEat(TokenKind.IDENTIFIER);
+        var tok = ate ? _previousToken : _peekToken;
+        if (!(ate && tok.text == 'deep')) {
+          _error('expected deep, but found ${tok.text}', tok.span);
+        }
+        _eat(TokenKind.SLASH);
+        combinatorType = TokenKind.COMBINATOR_DEEP;
+        break;
       case TokenKind.AMPERSAND:
         _eat(TokenKind.AMPERSAND);
         thisOperator = true;
         break;
     }
 
     // Check if WHITESPACE existed between tokens if so we're descendent.
     if (combinatorType == TokenKind.COMBINATOR_NONE && !forceCombinatorNone) {
       if (this._previousToken != null &&
           this._previousToken.end != this._peekToken.start) {
@@ skipping 168 matching lines @@
 
     // 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;
     }
+    var name = pseudoName.name.toLowerCase();
 
     // Functional pseudo?
-
     if (_peekToken.kind == TokenKind.LPAREN) {
-      if (!pseudoElement && pseudoName.name.toLowerCase() == 'not') {
+      if (!pseudoElement && name == 'not') {
         _eat(TokenKind.LPAREN);
 
         // Negation :   ':NOT(' S* negation_arg S* ')'
         var negArg = simpleSelector();
 
         _eat(TokenKind.RPAREN);
         return new NegationSelector(negArg, _makeSpan(start));
+      } else if (!pseudoElement && (name == 'host' || name == 'host-context')) {
+        _eat(TokenKind.LPAREN);
+        var selector = processCompoundSelector();
+        _eat(TokenKind.RPAREN);
+        var span = _makeSpan(start);
+        return new PseudoClassFunctionSelector(pseudoName, selector, span);
       } else {
         // Special parsing for expressions in pseudo functions.  Minus is used
         // as operator not identifier.
         // TODO(jmesserly): we need to flip this before we eat the "(" as the
         // next token will be fetched when we do that. I think we should try to
         // refactor so we don't need this boolean; it seems fragile.
         tokenizer.inSelectorExpression = true;
         _eat(TokenKind.LPAREN);
 
         // Handle function expression.
         var span = _makeSpan(start);
         var expr = processSelectorExpression();
 
         tokenizer.inSelectorExpression = false;
 
         // Used during selector look-a-head if not a SelectorExpression is
         // bad.
         if (expr is! SelectorExpression) {
           _errorExpected("CSS expression");
           return null;
         }
 
         _eat(TokenKind.RPAREN);
         return (pseudoElement)
             ? new PseudoElementFunctionSelector(pseudoName, expr, span)
             : new PseudoClassFunctionSelector(pseudoName, expr, span);
       }
     }
 
-    // TODO(terry): Need to handle specific pseudo class/element name and
-    // backward compatible names that are : as well as :: as well as
-    // parameters.  Current, spec uses :: for pseudo-element and : for
-    // pseudo-class.  However, CSS2.1 allows for : to specify old
-    // pseudo-elements (:first-line, :first-letter, :before and :after) any
-    // new pseudo-elements defined would require a ::.
-    return pseudoElement
-        ? new PseudoElementSelector(pseudoName, _makeSpan(start))
+    // Treat CSS2.1 pseudo-elements defined with pseudo class syntax as pseudo-
+    // elements for backwards compatibility.
+    return pseudoElement || _legacyPseudoElements.contains(name)
+        ? new PseudoElementSelector(pseudoName, _makeSpan(start),
+            isLegacy: !pseudoElement)
         : new PseudoClassSelector(pseudoName, _makeSpan(start));
   }
 
   /**
    *  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.span;
 
-    var expressions = [];
+    var expressions = <Expression>[];
 
     Token termToken;
     var value;
 
     var keepParsing = true;
     while (keepParsing) {
       switch (_peek()) {
         case TokenKind.PLUS:
           start = _peekToken.span;
           termToken = _next();
@@ skipping 615 matching lines @@
 
     var unary = "";
     switch (_peek()) {
       case TokenKind.HASH:
         this._eat(TokenKind.HASH);
         if (!_anyWhiteSpaceBeforePeekToken(TokenKind.HASH)) {
           String hexText;
           if (_peekKind(TokenKind.INTEGER)) {
             String hexText1 = _peekToken.text;
             _next();
-            if (_peekIdentifier()) {
+            // Append identifier only if there's no delimiting whitespace.
+            if (_peekIdentifier() && _previousToken.end == _peekToken.start) {
               hexText = '$hexText1${identifier().name}';
             } else {
               hexText = hexText1;
             }
           } else if (_peekIdentifier()) {
             hexText = identifier().name;
           }
           if (hexText != null) {
             return _parseHex(hexText, _makeSpan(start));
           }
@@ skipping 125 matching lines @@
       case TokenKind.AT:
         if (messages.options.lessSupport) {
           _next();
 
           var expr = processExpr();
           if (isChecked && expr.expressions.length > 1) {
             _error("only @name for Less syntax", _peekToken.span);
           }
 
           var param = expr.expressions[0];
-          var varUsage = new VarUsage(param.text, [], _makeSpan(start));
+          var varUsage =
+              new VarUsage((param as LiteralTerm).text, [], _makeSpan(start));
           expr.expressions[0] = varUsage;
           return expr.expressions;
         }
         break;
     }
 
-    return processDimension(t, value, _makeSpan(start));
+    return t != null ? processDimension(t, value, _makeSpan(start)) : null;
   }
 
   /** Process all dimension units. */
   LiteralTerm processDimension(Token t, var value, SourceSpan span) {
     LiteralTerm term;
     var unitType = this._peek();
 
     switch (unitType) {
       case TokenKind.UNIT_EM:
         term = new EmTerm(value, t.text, span);
@@ skipping 125 matching lines @@
   //              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(FileSpan startAfterProgidColon) {
+    // Support non-functional filters (i.e. filter: FlipH)
+    var kind = _peek();
+    if (kind == TokenKind.SEMICOLON || kind == TokenKind.RBRACE) {
+      var tok = tokenizer.makeIEFilter(
+          startAfterProgidColon.start.offset, _peekToken.start);
+      return new LiteralTerm(tok.text, tok.text, tok.span);
+    }
+
     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(
@@ skipping 23 matching lines @@
     tokenizer._inString = false;
 
     // Gobble up everything until we hit our stop token.
     var stringValue = new StringBuffer();
     var left = 1;
     var matchingParens = false;
     while (_peek() != TokenKind.END_OF_FILE && !matchingParens) {
       var token = _peek();
       if (token == TokenKind.LPAREN)
         left++;
-      else if (token == TokenKind.RPAREN)
-        left--;
+      else if (token == TokenKind.RPAREN) left--;
 
       matchingParens = left == 0;
       if (!matchingParens) stringValue.write(_next().text);
     }
 
     if (!matchingParens) {
       _error("problem parsing function expected ), ", _peekToken.span);
     }
 
     tokenizer._inString = inString;
 
     return stringValue.toString();
   }
 
   CalcTerm processCalc(Identifier func) {
     var start = _peekToken.span;
 
     var name = func.name;
-    if (name == 'calc') {
+    if (name == 'calc' || name == '-webkit-calc' || name == '-moz-calc') {
       // TODO(terry): Implement expression parsing properly.
       String expression = processCalcExpression();
       var calcExpr = new LiteralTerm(expression, expression, _makeSpan(start));
 
       if (!_maybeEat(TokenKind.RPAREN)) {
         _error("problem parsing function expected ), ", _peekToken.span);
       }
 
       return new CalcTerm(name, name, calcExpr, _makeSpan(start));
     }
 
     return null;
   }
 
   //  Function grammar:
   //
   //  function:     IDENT '(' expr ')'
   //
   processFunction(Identifier func) {
     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.
+        // TODO(terry): Better error message and checking for mismatched quotes.
         if (_peek() == TokenKind.END_OF_FILE) {
           _error("problem parsing URI", _peekToken.span);
         }
 
         if (_peek() == TokenKind.RPAREN) {
           _next();
         }
 
         return new UriTerm(urlParam, _makeSpan(start));
       case 'var':
         // TODO(terry): Consider handling var in IE specific filter/progid.  This
         //              will require parsing entire IE specific syntax e.g.,
         //              param = value or progid:com_id, etc. for example:
         //
         //    var-blur: Blur(Add = 0, Direction = 225, Strength = 10);
         //    var-gradient: progid:DXImageTransform.Microsoft.gradient"
         //      (GradientType=0,StartColorStr='#9d8b83', EndColorStr='#847670');
         var expr = processExpr();
         if (!_maybeEat(TokenKind.RPAREN)) {
           _error("problem parsing var expected ), ", _peekToken.span);
         }
         if (isChecked &&
             expr.expressions.where((e) => e is OperatorComma).length > 1) {
           _error("too many parameters to var()", _peekToken.span);
         }
 
-        var paramName = expr.expressions[0].text;
+        var paramName = (expr.expressions[0] as LiteralTerm).text;
 
         // [0] - var name, [1] - OperatorComma, [2] - default value.
-        var defaultValues =
-            expr.expressions.length >= 3 ? expr.expressions.sublist(2) : [];
+        var defaultValues = expr.expressions.length >= 3
+            ? expr.expressions.sublist(2)
+            : <Expression>[];
         return new VarUsage(paramName, defaultValues, _makeSpan(start));
       default:
         var expr = processExpr();
         if (!_maybeEat(TokenKind.RPAREN)) {
           _error("problem parsing function expected ), ", _peekToken.span);
         }
 
         return new FunctionTerm(name, name, expr, _makeSpan(start));
     }
-
-    return null;
   }
 
   Identifier identifier() {
     var tok = _next();
 
     if (!TokenKind.isIdentifier(tok.kind) &&
         !TokenKind.isKindIdentifier(tok.kind)) {
       if (isChecked) {
         _warning('expected identifier, but found $tok', tok.span);
       }
@@ skipping 174 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();
 }