sassc 0.0.9 → 0.0.10

data/ext/libsass/ast.hpp

@@ -1,11 +1,14 @@
-#define SASS_AST
+#ifndef SASS_AST_H
+#define SASS_AST_H
 
+#include <set>
+#include <deque>
+#include <vector>
 #include <string>
 #include <sstream>
-#include <vector>
-#include <set>
+#include <iostream>
+#include <typeinfo>
 #include <algorithm>
-#include <deque>
 #include <unordered_map>
 
 #ifdef __clang__
@@ -27,61 +30,43 @@
 
 #endif
 
-#ifndef SASS_CONSTANTS
+#include "util.hpp"
+#include "units.hpp"
+#include "context.hpp"
+#include "position.hpp"
 #include "constants.hpp"
-#endif
-
-#ifndef SASS_OPERATION
 #include "operation.hpp"
-#endif
-
-#ifndef SASS_TOKEN
-#include "token.hpp"
-#endif
-
-#ifndef SASS_ENVIRONMENT
+#include "position.hpp"
+#include "inspect.hpp"
+#include "source_map.hpp"
 #include "environment.hpp"
-#endif
+#include "error_handling.hpp"
+#include "ast_def_macros.hpp"
+#include "ast_fwd_decl.hpp"
+#include "to_string.hpp"
+#include "source_map.hpp"
 
 #include "sass.h"
 #include "sass_values.h"
 #include "sass_functions.h"
 
-#include "units.hpp"
-
-#ifndef SASS_ERROR_HANDLING
-#include "error_handling.hpp"
-#endif
-
-#include "ast_def_macros.hpp"
-#include "inspect.hpp"
-
-#include <sstream>
-#include <iostream>
-#include <typeinfo>
-
-#ifndef SASS_POSITION
-#include "position.hpp"
-#endif
-
-
 namespace Sass {
   using namespace std;
 
   //////////////////////////////////////////////////////////
   // Abstract base class for all abstract syntax tree nodes.
   //////////////////////////////////////////////////////////
-  class Block;
-  class Statement;
-  class Expression;
-  class Selector;
   class AST_Node {
-    ADD_PROPERTY(string, path);
-    ADD_PROPERTY(Position, position);
+    ADD_PROPERTY(ParserState, pstate);
   public:
-    AST_Node(string path, Position position) : path_(path), position_(position) { }
+    AST_Node(ParserState pstate)
+    : pstate_(pstate)
+    { }
     virtual ~AST_Node() = 0;
     // virtual Block* block() { return 0; }
+  public:
+    Offset off() { return pstate(); };
+    Position pos() { return pstate(); };
     ATTACH_OPERATIONS();
   };
   inline AST_Node::~AST_Node() { }
@@ -112,10 +97,13 @@ namespace Sass {
     ADD_PROPERTY(bool, is_interpolant);
     ADD_PROPERTY(Concrete_Type, concrete_type);
   public:
-    Expression(string path, Position position,
+    Expression(ParserState pstate,
                bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)
-    : AST_Node(path, position),
-      is_delayed_(d), is_expanded_(d), is_interpolant_(i), concrete_type_(ct)
+    : AST_Node(pstate),
+      is_delayed_(d),
+      is_expanded_(d),
+      is_interpolant_(i),
+      concrete_type_(ct)
     { }
     virtual operator bool() { return true; }
     virtual ~Expression() { };
@@ -173,6 +161,7 @@ namespace Sass {
     virtual ~Vectorized() = 0;
     size_t length() const   { return elements_.size(); }
     bool empty() const      { return elements_.empty(); }
+    T last()                { return elements_.back(); }
     T& operator[](size_t i) { return elements_[i]; }
     const T& operator[](size_t i) const { return elements_[i]; }
     Vectorized& operator<<(T element)
@@ -187,6 +176,11 @@ namespace Sass {
       for (size_t i = 0, L = v->length(); i < L; ++i) *this << (*v)[i];
       return *this;
     }
+    Vectorized& unshift(T element)
+    {
+      elements_.insert(elements_.begin(), element);
+      return *this;
+    }
     vector<T>& elements() { return elements_; }
     const vector<T>& elements() const { return elements_; }
     vector<T>& elements(vector<T>& e) { elements_ = e; return elements_; }
@@ -195,7 +189,7 @@ namespace Sass {
   inline Vectorized<T>::~Vectorized() { }
 
   /////////////////////////////////////////////////////////////////////////////
-  // Mixin class for AST nodes that should behave like ahash table. Uses an
+  // Mixin class for AST nodes that should behave like a hash table. Uses an
   // extra <vector> internally to maintain insertion order for interation.
   /////////////////////////////////////////////////////////////////////////////
   class Hashed {
@@ -258,10 +252,30 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   class Statement : public AST_Node {
   public:
-    Statement(string path, Position position) : AST_Node(path, position) { }
+    enum Statement_Type {
+      NONE,
+      RULESET,
+      MEDIA,
+      DIRECTIVE,
+      FEATURE,
+      ATROOT,
+      BUBBLE,
+      KEYFRAMERULE
+    };
+  private:
+    ADD_PROPERTY(Block*, block);
+    ADD_PROPERTY(Statement_Type, statement_type);
+    ADD_PROPERTY(size_t, tabs);
+    ADD_PROPERTY(bool, group_end);
+  public:
+    Statement(ParserState pstate, Statement_Type st = NONE, size_t t = 0)
+    : AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)
+     { }
     virtual ~Statement() = 0;
     // needed for rearranging nested rulesets during CSS emission
     virtual bool   is_hoistable() { return false; }
+    virtual bool   is_invisible() { return false; }
+    virtual bool   bubbles() { return false; }
     virtual Block* block()  { return 0; }
   };
   inline Statement::~Statement() { }
@@ -281,8 +295,8 @@ namespace Sass {
       else                   has_non_hoistable_ = true;
     };
   public:
-    Block(string path, Position position, size_t s = 0, bool r = false)
-    : Statement(path, position),
+    Block(ParserState pstate, size_t s = 0, bool r = false)
+    : Statement(pstate),
       Vectorized<Statement*>(s),
       is_root_(r), has_hoistable_(false), has_non_hoistable_(false)
     { }
@@ -296,8 +310,8 @@ namespace Sass {
   class Has_Block : public Statement {
     ADD_PROPERTY(Block*, block);
   public:
-    Has_Block(string path, Position position, Block* b)
-    : Statement(path, position), block_(b)
+    Has_Block(ParserState pstate, Block* b)
+    : Statement(pstate), block_(b)
     { }
     virtual ~Has_Block() = 0;
   };
@@ -307,13 +321,13 @@ namespace Sass {
   // Rulesets (i.e., sets of styles headed by a selector and containing a block
   // of style declarations.
   /////////////////////////////////////////////////////////////////////////////
-  class Selector;
   class Ruleset : public Has_Block {
     ADD_PROPERTY(Selector*, selector);
   public:
-    Ruleset(string path, Position position, Selector* s, Block* b)
-    : Has_Block(path, position, b), selector_(s)
-    { }
+    Ruleset(ParserState pstate, Selector* s, Block* b)
+    : Has_Block(pstate, b), selector_(s)
+    { statement_type(RULESET); }
+    bool is_invisible();
     // nested rulesets need to be hoisted out of their enclosing blocks
     bool is_hoistable() { return true; }
     ATTACH_OPERATIONS();
@@ -322,28 +336,50 @@ namespace Sass {
   /////////////////////////////////////////////////////////
   // Nested declaration sets (i.e., namespaced properties).
   /////////////////////////////////////////////////////////
-  class String;
   class Propset : public Has_Block {
     ADD_PROPERTY(String*, property_fragment);
   public:
-    Propset(string path, Position position, String* pf, Block* b = 0)
-    : Has_Block(path, position, b), property_fragment_(pf)
+    Propset(ParserState pstate, String* pf, Block* b = 0)
+    : Has_Block(pstate, b), property_fragment_(pf)
     { }
     ATTACH_OPERATIONS();
   };
 
+  /////////////////
+  // Bubble.
+  /////////////////
+  class Bubble : public Statement {
+    ADD_PROPERTY(Statement*, node);
+    ADD_PROPERTY(bool, group_end);
+  public:
+    Bubble(ParserState pstate, Statement* n, Statement* g = 0, size_t t = 0)
+    : Statement(pstate, Statement::BUBBLE, t), node_(n), group_end_(g == 0)
+    { }
+    bool bubbles() { return true; }
+    ATTACH_OPERATIONS();
+  };
+
   /////////////////
   // Media queries.
   /////////////////
-  class List;
   class Media_Block : public Has_Block {
     ADD_PROPERTY(List*, media_queries);
     ADD_PROPERTY(Selector*, selector);
   public:
-    Media_Block(string path, Position position, List* mqs, Block* b)
-    : Has_Block(path, position, b), media_queries_(mqs), selector_(0)
-    { }
+    Media_Block(ParserState pstate, List* mqs, Block* b)
+    : Has_Block(pstate, b), media_queries_(mqs), selector_(0)
+    { statement_type(MEDIA); }
+    Media_Block(ParserState pstate, List* mqs, Block* b, Selector* s)
+    : Has_Block(pstate, b), media_queries_(mqs), selector_(s)
+    { statement_type(MEDIA); }
+    bool bubbles() { return true; }
     bool is_hoistable() { return true; }
+    bool is_invisible() {
+      bool is_invisible = true;
+      for (size_t i = 0, L = block()->length(); i < L && is_invisible; i++)
+        is_invisible &= (*block())[i]->is_invisible();
+      return is_invisible;
+    }
     ATTACH_OPERATIONS();
   };
 
@@ -354,10 +390,11 @@ namespace Sass {
     ADD_PROPERTY(Feature_Query*, feature_queries);
     ADD_PROPERTY(Selector*, selector);
   public:
-    Feature_Block(string path, Position position, Feature_Query* fqs, Block* b)
-    : Has_Block(path, position, b), feature_queries_(fqs), selector_(0)
-    { }
+    Feature_Block(ParserState pstate, Feature_Query* fqs, Block* b)
+    : Has_Block(pstate, b), feature_queries_(fqs), selector_(0)
+    { statement_type(FEATURE); }
     bool is_hoistable() { return true; }
+    bool bubbles() { return true; }
     ATTACH_OPERATIONS();
   };
 
@@ -370,9 +407,34 @@ namespace Sass {
     ADD_PROPERTY(Selector*, selector);
     ADD_PROPERTY(Expression*, value);
   public:
-    At_Rule(string path, Position position, string kwd, Selector* sel = 0, Block* b = 0)
-    : Has_Block(path, position, b), keyword_(kwd), selector_(sel), value_(0) // set value manually if needed
-    { }
+    At_Rule(ParserState pstate, string kwd, Selector* sel = 0, Block* b = 0)
+    : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(0) // set value manually if needed
+    { statement_type(DIRECTIVE); }
+    bool bubbles() { return is_keyframes() || is_media(); }
+    bool is_media() {
+      return keyword_.compare("@-webkit-media") == 0 ||
+             keyword_.compare("@-moz-media") == 0 ||
+             keyword_.compare("@-o-media") == 0 ||
+             keyword_.compare("@media") == 0;
+    }
+    bool is_keyframes() {
+      return keyword_.compare("@-webkit-keyframes") == 0 ||
+             keyword_.compare("@-moz-keyframes") == 0 ||
+             keyword_.compare("@-o-keyframes") == 0 ||
+             keyword_.compare("@keyframes") == 0;
+    }
+    ATTACH_OPERATIONS();
+  };
+
+  ///////////////////////////////////////////////////////////////////////
+  // Keyframe-rules -- the child blocks of "@keyframes" nodes.
+  ///////////////////////////////////////////////////////////////////////
+  class Keyframe_Rule : public Has_Block {
+    ADD_PROPERTY(String*, rules);
+  public:
+    Keyframe_Rule(ParserState pstate, Block* b)
+    : Has_Block(pstate, b), rules_(0)
+    { statement_type(KEYFRAMERULE); }
     ATTACH_OPERATIONS();
   };
 
@@ -384,9 +446,9 @@ namespace Sass {
     ADD_PROPERTY(Expression*, value);
     ADD_PROPERTY(bool, is_important);
   public:
-    Declaration(string path, Position position,
+    Declaration(ParserState pstate,
                 String* prop, Expression* val, bool i = false)
-    : Statement(path, position), property_(prop), value_(val), is_important_(i)
+    : Statement(pstate), property_(prop), value_(val), is_important_(i)
     { }
     ATTACH_OPERATIONS();
   };
@@ -394,19 +456,17 @@ namespace Sass {
   /////////////////////////////////////
   // Assignments -- variable and value.
   /////////////////////////////////////
-  class Variable;
-  class Expression;
   class Assignment : public Statement {
     ADD_PROPERTY(string, variable);
     ADD_PROPERTY(Expression*, value);
     ADD_PROPERTY(bool, is_guarded);
     ADD_PROPERTY(bool, is_global);
   public:
-    Assignment(string path, Position position,
+    Assignment(ParserState pstate,
                string var, Expression* val,
                bool guarded = false,
                bool global = false)
-    : Statement(path, position), variable_(var), value_(val), is_guarded_(guarded), is_global_(global)
+    : Statement(pstate), variable_(var), value_(val), is_guarded_(guarded), is_global_(global)
     { }
     ATTACH_OPERATIONS();
   };
@@ -417,10 +477,10 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////////
   class Import : public Statement {
     vector<string>         files_;
-    vector<Expression*> urls_;
+    vector<Expression*>    urls_;
   public:
-    Import(string path, Position position)
-    : Statement(path, position),
+    Import(ParserState pstate)
+    : Statement(pstate),
       files_(vector<string>()), urls_(vector<Expression*>())
     { }
     vector<string>&         files() { return files_; }
@@ -431,8 +491,8 @@ namespace Sass {
   class Import_Stub : public Statement {
     ADD_PROPERTY(string, file_name);
   public:
-    Import_Stub(string path, Position position, string f)
-    : Statement(path, position), file_name_(f)
+    Import_Stub(ParserState pstate, string f)
+    : Statement(pstate), file_name_(f)
     { }
     ATTACH_OPERATIONS();
   };
@@ -443,8 +503,8 @@ namespace Sass {
   class Warning : public Statement {
     ADD_PROPERTY(Expression*, message);
   public:
-    Warning(string path, Position position, Expression* msg)
-    : Statement(path, position), message_(msg)
+    Warning(ParserState pstate, Expression* msg)
+    : Statement(pstate), message_(msg)
     { }
     ATTACH_OPERATIONS();
   };
@@ -455,8 +515,8 @@ namespace Sass {
   class Error : public Statement {
     ADD_PROPERTY(Expression*, message);
   public:
-    Error(string path, Position position, Expression* msg)
-    : Statement(path, position), message_(msg)
+    Error(ParserState pstate, Expression* msg)
+    : Statement(pstate), message_(msg)
     { }
     ATTACH_OPERATIONS();
   };
@@ -467,8 +527,8 @@ namespace Sass {
   class Debug : public Statement {
     ADD_PROPERTY(Expression*, value);
   public:
-    Debug(string path, Position position, Expression* val)
-    : Statement(path, position), value_(val)
+    Debug(ParserState pstate, Expression* val)
+    : Statement(pstate), value_(val)
     { }
     ATTACH_OPERATIONS();
   };
@@ -478,9 +538,10 @@ namespace Sass {
   ///////////////////////////////////////////
   class Comment : public Statement {
     ADD_PROPERTY(String*, text);
+    ADD_PROPERTY(bool, is_important);
   public:
-    Comment(string path, Position position, String* txt)
-    : Statement(path, position), text_(txt)
+    Comment(ParserState pstate, String* txt, bool is_important)
+    : Statement(pstate), text_(txt), is_important_(is_important)
     { }
     ATTACH_OPERATIONS();
   };
@@ -493,8 +554,8 @@ namespace Sass {
     ADD_PROPERTY(Block*, consequent);
     ADD_PROPERTY(Block*, alternative);
   public:
-    If(string path, Position position, Expression* pred, Block* con, Block* alt = 0)
-    : Statement(path, position), predicate_(pred), consequent_(con), alternative_(alt)
+    If(ParserState pstate, Expression* pred, Block* con, Block* alt = 0)
+    : Statement(pstate), predicate_(pred), consequent_(con), alternative_(alt)
     { }
     ATTACH_OPERATIONS();
   };
@@ -508,9 +569,9 @@ namespace Sass {
     ADD_PROPERTY(Expression*, upper_bound);
     ADD_PROPERTY(bool, is_inclusive);
   public:
-    For(string path, Position position,
+    For(ParserState pstate,
         string var, Expression* lo, Expression* hi, Block* b, bool inc)
-    : Has_Block(path, position, b),
+    : Has_Block(pstate, b),
       variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)
     { }
     ATTACH_OPERATIONS();
@@ -523,8 +584,8 @@ namespace Sass {
     ADD_PROPERTY(vector<string>, variables);
     ADD_PROPERTY(Expression*, list);
   public:
-    Each(string path, Position position, vector<string> vars, Expression* lst, Block* b)
-    : Has_Block(path, position, b), variables_(vars), list_(lst)
+    Each(ParserState pstate, vector<string> vars, Expression* lst, Block* b)
+    : Has_Block(pstate, b), variables_(vars), list_(lst)
     { }
     ATTACH_OPERATIONS();
   };
@@ -535,8 +596,8 @@ namespace Sass {
   class While : public Has_Block {
     ADD_PROPERTY(Expression*, predicate);
   public:
-    While(string path, Position position, Expression* pred, Block* b)
-    : Has_Block(path, position, b), predicate_(pred)
+    While(ParserState pstate, Expression* pred, Block* b)
+    : Has_Block(pstate, b), predicate_(pred)
     { }
     ATTACH_OPERATIONS();
   };
@@ -547,8 +608,8 @@ namespace Sass {
   class Return : public Statement {
     ADD_PROPERTY(Expression*, value);
   public:
-    Return(string path, Position position, Expression* val)
-    : Statement(path, position), value_(val)
+    Return(ParserState pstate, Expression* val)
+    : Statement(pstate), value_(val)
     { }
     ATTACH_OPERATIONS();
   };
@@ -559,8 +620,8 @@ namespace Sass {
   class Extension : public Statement {
     ADD_PROPERTY(Selector*, selector);
   public:
-    Extension(string path, Position position, Selector* s)
-    : Statement(path, position), selector_(s)
+    Extension(ParserState pstate, Selector* s)
+    : Statement(pstate), selector_(s)
     { }
     ATTACH_OPERATIONS();
   };
@@ -569,12 +630,10 @@ namespace Sass {
   // Definitions for both mixins and functions. The two cases are distinguished
   // by a type tag.
   /////////////////////////////////////////////////////////////////////////////
-  struct Context;
   struct Backtrace;
-  class Parameters;
   typedef Environment<AST_Node*> Env;
   typedef const char* Signature;
-  typedef Expression* (*Native_Function)(Env&, Env&, Context&, Signature, const string&, Position, Backtrace*);
+  typedef Expression* (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*);
   typedef const char* Signature;
   class Definition : public Has_Block {
   public:
@@ -589,13 +648,12 @@ namespace Sass {
     ADD_PROPERTY(bool, is_overload_stub);
     ADD_PROPERTY(Signature, signature);
   public:
-    Definition(string path,
-               Position position,
+    Definition(ParserState pstate,
                string n,
                Parameters* params,
                Block* b,
                Type t)
-    : Has_Block(path, position, b),
+    : Has_Block(pstate, b),
       name_(n),
       parameters_(params),
       environment_(0),
@@ -606,14 +664,13 @@ namespace Sass {
       is_overload_stub_(false),
       signature_(0)
     { }
-    Definition(string path,
-               Position position,
+    Definition(ParserState pstate,
                Signature sig,
                string n,
                Parameters* params,
                Native_Function func_ptr,
                bool overload_stub = false)
-    : Has_Block(path, position, 0),
+    : Has_Block(pstate, 0),
       name_(n),
       parameters_(params),
       environment_(0),
@@ -624,8 +681,7 @@ namespace Sass {
       is_overload_stub_(overload_stub),
       signature_(sig)
     { }
-    Definition(string path,
-               Position position,
+    Definition(ParserState pstate,
                Signature sig,
                string n,
                Parameters* params,
@@ -633,7 +689,7 @@ namespace Sass {
                void* cookie,
                bool whatever,
                bool whatever2)
-    : Has_Block(path, position, 0),
+    : Has_Block(pstate, 0),
       name_(n),
       parameters_(params),
       environment_(0),
@@ -650,13 +706,12 @@ namespace Sass {
   //////////////////////////////////////
   // Mixin calls (i.e., `@include ...`).
   //////////////////////////////////////
-  class Arguments;
   class Mixin_Call : public Has_Block {
     ADD_PROPERTY(string, name);
     ADD_PROPERTY(Arguments*, arguments);
   public:
-    Mixin_Call(string path, Position position, string n, Arguments* args, Block* b = 0)
-    : Has_Block(path, position, b), name_(n), arguments_(args)
+    Mixin_Call(ParserState pstate, string n, Arguments* args, Block* b = 0)
+    : Has_Block(pstate, b), name_(n), arguments_(args)
     { }
     ATTACH_OPERATIONS();
   };
@@ -666,7 +721,7 @@ namespace Sass {
   ///////////////////////////////////////////////////
   class Content : public Statement {
   public:
-    Content(string path, Position position) : Statement(path, position) { }
+    Content(ParserState pstate) : Statement(pstate) { }
     ATTACH_OPERATIONS();
   };
 
@@ -682,9 +737,9 @@ namespace Sass {
     ADD_PROPERTY(Separator, separator);
     ADD_PROPERTY(bool, is_arglist);
   public:
-    List(string path, Position position,
+    List(ParserState pstate,
          size_t size = 0, Separator sep = SPACE, bool argl = false)
-    : Expression(path, position),
+    : Expression(pstate),
       Vectorized<Expression*>(size),
       separator_(sep), is_arglist_(argl)
     { concrete_type(LIST); }
@@ -729,13 +784,12 @@ namespace Sass {
   ///////////////////////////////////////////////////////////////////////
   // Key value paris.
   ///////////////////////////////////////////////////////////////////////
-
   class Map : public Expression, public Hashed {
     void adjust_after_pushing(std::pair<Expression*, Expression*> p) { is_expanded(false); }
   public:
-    Map(string path, Position position,
+    Map(ParserState pstate,
          size_t size = 0)
-    : Expression(path, position),
+    : Expression(pstate),
       Hashed(size)
     { concrete_type(MAP); }
     string type() { return "map"; }
@@ -772,8 +826,6 @@ namespace Sass {
     ATTACH_OPERATIONS();
   };
 
-
-
   //////////////////////////////////////////////////////////////////////////
   // Binary expressions. Represents logical, relational, and arithmetic
   // operations. Templatized to avoid large switch statements and repetitive
@@ -792,9 +844,9 @@ namespace Sass {
     ADD_PROPERTY(Expression*, left);
     ADD_PROPERTY(Expression*, right);
   public:
-    Binary_Expression(string path, Position position,
+    Binary_Expression(ParserState pstate,
                       Type t, Expression* lhs, Expression* rhs)
-    : Expression(path, position), type_(t), left_(lhs), right_(rhs)
+    : Expression(pstate), type_(t), left_(lhs), right_(rhs)
     { }
     ATTACH_OPERATIONS();
   };
@@ -809,8 +861,8 @@ namespace Sass {
     ADD_PROPERTY(Type, type);
     ADD_PROPERTY(Expression*, operand);
   public:
-    Unary_Expression(string path, Position position, Type t, Expression* o)
-    : Expression(path, position), type_(t), operand_(o)
+    Unary_Expression(ParserState pstate, Type t, Expression* o)
+    : Expression(pstate), type_(t), operand_(o)
     { }
     ATTACH_OPERATIONS();
   };
@@ -825,11 +877,11 @@ namespace Sass {
     ADD_PROPERTY(bool, is_keyword_argument);
     size_t hash_;
   public:
-    Argument(string p, Position pos, Expression* val, string n = "", bool rest = false, bool keyword = false)
-    : Expression(p, pos), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
+    Argument(ParserState pstate, Expression* val, string n = "", bool rest = false, bool keyword = false)
+    : Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
     {
       if (!name_.empty() && is_rest_argument_) {
-        error("variable-length argument may not be passed by name", path(), position());
+        error("variable-length argument may not be passed by name", pstate);
       }
     }
 
@@ -874,37 +926,37 @@ namespace Sass {
     {
       if (!a->name().empty()) {
         if (has_rest_argument_ || has_keyword_argument_) {
-          error("named arguments must precede variable-length argument", a->path(), a->position());
+          error("named arguments must precede variable-length argument", a->pstate());
         }
         has_named_arguments_ = true;
       }
       else if (a->is_rest_argument()) {
         if (has_rest_argument_) {
-          error("functions and mixins may only be called with one variable-length argument", a->path(), a->position());
+          error("functions and mixins may only be called with one variable-length argument", a->pstate());
         }
         if (has_keyword_argument_) {
-          error("only keyword arguments may follow variable arguments", a->path(), a->position());
+          error("only keyword arguments may follow variable arguments", a->pstate());
         }
         has_rest_argument_ = true;
       }
       else if (a->is_keyword_argument()) {
         if (has_keyword_argument_) {
-          error("functions and mixins may only be called with one keyword argument", a->path(), a->position());
+          error("functions and mixins may only be called with one keyword argument", a->pstate());
         }
         has_keyword_argument_ = true;
       }
       else {
         if (has_rest_argument_) {
-          error("ordinal arguments must precede variable-length arguments", a->path(), a->position());
+          error("ordinal arguments must precede variable-length arguments", a->pstate());
         }
         if (has_named_arguments_) {
-          error("ordinal arguments must precede named arguments", a->path(), a->position());
+          error("ordinal arguments must precede named arguments", a->pstate());
         }
       }
     }
   public:
-    Arguments(string path, Position position)
-    : Expression(path, position),
+    Arguments(ParserState pstate)
+    : Expression(pstate),
       Vectorized<Argument*>(),
       has_named_arguments_(false),
       has_rest_argument_(false),
@@ -922,11 +974,11 @@ namespace Sass {
     ADD_PROPERTY(void*, cookie);
     size_t hash_;
   public:
-    Function_Call(string path, Position position, string n, Arguments* args, void* cookie)
-    : Expression(path, position), name_(n), arguments_(args), cookie_(cookie), hash_(0)
+    Function_Call(ParserState pstate, string n, Arguments* args, void* cookie)
+    : Expression(pstate), name_(n), arguments_(args), cookie_(cookie), hash_(0)
     { concrete_type(STRING); }
-    Function_Call(string path, Position position, string n, Arguments* args)
-    : Expression(path, position), name_(n), arguments_(args), cookie_(0), hash_(0)
+    Function_Call(ParserState pstate, string n, Arguments* args)
+    : Expression(pstate), name_(n), arguments_(args), cookie_(0), hash_(0)
     { concrete_type(STRING); }
 
     virtual bool operator==(Expression& rhs) const
@@ -968,8 +1020,8 @@ namespace Sass {
     ADD_PROPERTY(String*, name);
     ADD_PROPERTY(Arguments*, arguments);
   public:
-    Function_Call_Schema(string path, Position position, String* n, Arguments* args)
-    : Expression(path, position), name_(n), arguments_(args)
+    Function_Call_Schema(ParserState pstate, String* n, Arguments* args)
+    : Expression(pstate), name_(n), arguments_(args)
     { concrete_type(STRING); }
     ATTACH_OPERATIONS();
   };
@@ -980,8 +1032,8 @@ namespace Sass {
   class Variable : public Expression {
     ADD_PROPERTY(string, name);
   public:
-    Variable(string path, Position position, string n)
-    : Expression(path, position), name_(n)
+    Variable(ParserState pstate, string n)
+    : Expression(pstate), name_(n)
     { }
 
     virtual bool operator==(Expression& rhs) const
@@ -1018,8 +1070,8 @@ namespace Sass {
     ADD_PROPERTY(string, value);
     size_t hash_;
   public:
-    Textual(string path, Position position, Type t, string val)
-    : Expression(path, position, true), type_(t), value_(val),
+    Textual(ParserState pstate, Type t, string val)
+    : Expression(pstate, true), type_(t), value_(val),
       hash_(0)
     { }
 
@@ -1056,8 +1108,8 @@ namespace Sass {
     vector<string> denominator_units_;
     size_t hash_;
   public:
-    Number(string path, Position position, double val, string u = "", bool zero = true)
-    : Expression(path, position),
+    Number(ParserState pstate, double val, string u = "", bool zero = true)
+    : Expression(pstate),
       value_(val),
       zero_(zero),
       numerator_units_(vector<string>()),
@@ -1201,8 +1253,8 @@ namespace Sass {
     ADD_PROPERTY(string, disp);
     size_t hash_;
   public:
-    Color(string path, Position position, double r, double g, double b, double a = 1, bool sixtuplet = true, const string disp = "")
-    : Expression(path, position), r_(r), g_(g), b_(b), a_(a), sixtuplet_(sixtuplet), disp_(disp),
+    Color(ParserState pstate, double r, double g, double b, double a = 1, bool sixtuplet = true, const string disp = "")
+    : Expression(pstate), r_(r), g_(g), b_(b), a_(a), sixtuplet_(sixtuplet), disp_(disp),
       hash_(0)
     { concrete_type(COLOR); }
     string type() { return "color"; }
@@ -1238,8 +1290,8 @@ namespace Sass {
     ADD_PROPERTY(bool, value);
     size_t hash_;
   public:
-    Boolean(string path, Position position, bool val)
-    : Expression(path, position), value_(val),
+    Boolean(ParserState pstate, bool val)
+    : Expression(pstate), value_(val),
       hash_(0)
     { concrete_type(BOOLEAN); }
     virtual operator bool() { return value_; }
@@ -1275,10 +1327,10 @@ namespace Sass {
   // "flat" strings.
   ////////////////////////////////////////////////////////////////////////
   class String : public Expression {
-    ADD_PROPERTY(bool, needs_unquoting);
+    ADD_PROPERTY(bool, sass_fix_1291);
   public:
-    String(string path, Position position, bool unq = false, bool delayed = false)
-    : Expression(path, position, delayed), needs_unquoting_(unq)
+    String(ParserState pstate, bool delayed = false, bool sass_fix_1291 = false)
+    : Expression(pstate, delayed), sass_fix_1291_(sass_fix_1291)
     { concrete_type(STRING); }
     static string type_name() { return "string"; }
     virtual ~String() = 0;
@@ -1291,12 +1343,11 @@ namespace Sass {
   // evaluation phase.
   ///////////////////////////////////////////////////////////////////////
   class String_Schema : public String, public Vectorized<Expression*> {
-    ADD_PROPERTY(char, quote_mark);
     ADD_PROPERTY(bool, has_interpolants);
     size_t hash_;
   public:
-    String_Schema(string path, Position position, size_t size = 0, bool unq = false, char qm = '\0', bool i = false)
-    : String(path, position, unq), Vectorized<Expression*>(size), quote_mark_(qm), has_interpolants_(i), hash_(0)
+    String_Schema(ParserState pstate, size_t size = 0, bool has_interpolants = false)
+    : String(pstate), Vectorized<Expression*>(size), has_interpolants_(has_interpolants), hash_(0)
     { }
     string type() { return "string"; }
     static string type_name() { return "string"; }
@@ -1335,22 +1386,23 @@ namespace Sass {
   // Flat strings -- the lowest level of raw textual data.
   ////////////////////////////////////////////////////////
   class String_Constant : public String {
+    ADD_PROPERTY(char, quote_mark);
     ADD_PROPERTY(string, value);
-    string unquoted_;
+  protected:
     size_t hash_;
   public:
-    String_Constant(string path, Position position, string val, bool unq = false)
-    : String(path, position, unq, true), value_(val), hash_(0)
-    { unquoted_ = unquote(value_); }
-    String_Constant(string path, Position position, const char* beg, bool unq = false)
-    : String(path, position, unq, true), value_(string(beg)), hash_(0)
-    { unquoted_ = unquote(value_); }
-    String_Constant(string path, Position position, const char* beg, const char* end, bool unq = false)
-    : String(path, position, unq, true), value_(string(beg, end-beg)), hash_(0)
-    { unquoted_ = unquote(value_); }
-    String_Constant(string path, Position position, const Token& tok, bool unq = false)
-    : String(path, position, unq, true), value_(string(tok.begin, tok.end)), hash_(0)
-    { unquoted_ = unquote(value_); }
+    String_Constant(ParserState pstate, string val)
+    : String(pstate), quote_mark_(0), value_(val), hash_(0)
+    { }
+    String_Constant(ParserState pstate, const char* beg)
+    : String(pstate), quote_mark_(0), value_(string(beg)), hash_(0)
+    { }
+    String_Constant(ParserState pstate, const char* beg, const char* end)
+    : String(pstate), quote_mark_(0), value_(string(beg, end-beg)), hash_(0)
+    { }
+    String_Constant(ParserState pstate, const Token& tok)
+    : String(pstate), quote_mark_(0), value_(string(tok.begin, tok.end)), hash_(0)
+    { }
     string type() { return "string"; }
     static string type_name() { return "string"; }
 
@@ -1359,7 +1411,7 @@ namespace Sass {
       try
       {
         String_Constant& e = dynamic_cast<String_Constant&>(rhs);
-        return e && unquoted_ == e.unquoted_;
+        return e && value_ == e.value_;
       }
       catch (std::bad_cast&)
       {
@@ -1370,15 +1422,27 @@ namespace Sass {
 
     virtual size_t hash()
     {
-      if (hash_ == 0) hash_ = std::hash<string>()(unquoted_);
+      if (hash_ == 0) hash_ = std::hash<string>()(value_);
       return hash_;
     }
 
-    static char single_quote() { return '\''; }
+    // static char auto_quote() { return '*'; }
     static char double_quote() { return '"'; }
+    static char single_quote() { return '\''; }
 
-    bool is_quoted() { return value_.length() && (value_[0] == '"' || value_[0] == '\''); }
-    char quote_mark() { return is_quoted() ? value_[0] : '\0'; }
+    ATTACH_OPERATIONS();
+  };
+
+  ////////////////////////////////////////////////////////
+  // Possibly quoted string (unquote on instantiation)
+  ////////////////////////////////////////////////////////
+  class String_Quoted : public String_Constant {
+  public:
+    String_Quoted(ParserState pstate, string val)
+    : String_Constant(pstate, val)
+    {
+      value_ = unquote(value_, &quote_mark_);
+    }
     ATTACH_OPERATIONS();
   };
 
@@ -1391,9 +1455,9 @@ namespace Sass {
     ADD_PROPERTY(bool, is_negated);
     ADD_PROPERTY(bool, is_restricted);
   public:
-    Media_Query(string path, Position position,
+    Media_Query(ParserState pstate,
                 String* t = 0, size_t s = 0, bool n = false, bool r = false)
-    : Expression(path, position), Vectorized<Media_Query_Expression*>(s),
+    : Expression(pstate), Vectorized<Media_Query_Expression*>(s),
       media_type_(t), is_negated_(n), is_restricted_(r)
     { }
     ATTACH_OPERATIONS();
@@ -1407,9 +1471,9 @@ namespace Sass {
     ADD_PROPERTY(Expression*, value);
     ADD_PROPERTY(bool, is_interpolated);
   public:
-    Media_Query_Expression(string path, Position position,
+    Media_Query_Expression(ParserState pstate,
                            Expression* f, Expression* v, bool i = false)
-    : Expression(path, position), feature_(f), value_(v), is_interpolated_(i)
+    : Expression(pstate), feature_(f), value_(v), is_interpolated_(i)
     { }
     ATTACH_OPERATIONS();
   };
@@ -1419,8 +1483,8 @@ namespace Sass {
   ///////////////////
   class Feature_Query : public Expression, public Vectorized<Feature_Query_Condition*> {
   public:
-    Feature_Query(string path, Position position, size_t s = 0)
-    : Expression(path, position), Vectorized<Feature_Query_Condition*>(s)
+    Feature_Query(ParserState pstate, size_t s = 0)
+    : Expression(pstate), Vectorized<Feature_Query_Condition*>(s)
     { }
     ATTACH_OPERATIONS();
   };
@@ -1437,20 +1501,100 @@ namespace Sass {
     ADD_PROPERTY(Operand, operand);
     ADD_PROPERTY(bool, is_root);
   public:
-    Feature_Query_Condition(string path, Position position, size_t s = 0, String* f = 0,
+    Feature_Query_Condition(ParserState pstate, size_t s = 0, String* f = 0,
                             Expression* v = 0, Operand o = NONE, bool r = false)
-    : Expression(path, position), Vectorized<Feature_Query_Condition*>(s),
+    : Expression(pstate), Vectorized<Feature_Query_Condition*>(s),
       feature_(f), value_(v), operand_(o), is_root_(r)
     { }
     ATTACH_OPERATIONS();
   };
 
+  /////////////////////////////////////////////////
+  // At root expressions (for use inside @at-root).
+  /////////////////////////////////////////////////
+  class At_Root_Expression : public Expression {
+  private:
+    ADD_PROPERTY(String*, feature);
+    ADD_PROPERTY(Expression*, value);
+    ADD_PROPERTY(bool, is_interpolated);
+  public:
+    At_Root_Expression(ParserState pstate, String* f = 0, Expression* v = 0, bool i = false)
+    : Expression(pstate), feature_(f), value_(v), is_interpolated_(i)
+    { }
+    bool exclude(string str)
+    {
+      To_String to_string;
+      bool with = feature() && unquote(feature()->perform(&to_string)).compare("with") == 0;
+      List* l = static_cast<List*>(value());
+      string v;
+
+      if (with)
+      {
+        if (!l || l->length() == 0) return str.compare("rule") != 0;
+        for (size_t i = 0, L = l->length(); i < L; ++i)
+        {
+          v = unquote((*l)[i]->perform(&to_string));
+          if (v.compare("all") == 0 || v == str) return false;
+        }
+        return true;
+      }
+      else
+      {
+        if (!l || !l->length()) return str.compare("rule") == 0;
+        for (size_t i = 0, L = l->length(); i < L; ++i)
+        {
+          v = unquote((*l)[i]->perform(&to_string));
+          if (v.compare("all") == 0 || v == str) return true;
+        }
+        return false;
+      }
+    }
+    ATTACH_OPERATIONS();
+  };
+
+  ///////////
+  // At-root.
+  ///////////
+  class At_Root_Block : public Has_Block {
+    ADD_PROPERTY(At_Root_Expression*, expression);
+  public:
+    At_Root_Block(ParserState pstate, Block* b = 0, At_Root_Expression* e = 0)
+    : Has_Block(pstate, b), expression_(e)
+    { statement_type(ATROOT); }
+    bool is_hoistable() { return true; }
+    bool bubbles() { return true; }
+    bool exclude_node(Statement* s) {
+      if (s->statement_type() == Statement::DIRECTIVE)
+      {
+        return expression()->exclude(static_cast<At_Rule*>(s)->keyword().erase(0, 1));
+      }
+      if (s->statement_type() == Statement::MEDIA)
+      {
+        return expression()->exclude("media");
+      }
+      if (s->statement_type() == Statement::RULESET)
+      {
+        return expression()->exclude("rule");
+      }
+      if (s->statement_type() == Statement::FEATURE)
+      {
+        return expression()->exclude("supports");
+      }
+      if (static_cast<At_Rule*>(s)->is_keyframes())
+      {
+        return expression()->exclude("keyframes");
+      }
+      return false;
+    }
+    ATTACH_OPERATIONS();
+  };
+
   //////////////////
   // The null value.
   //////////////////
   class Null : public Expression {
   public:
-    Null(string path, Position position) : Expression(path, position) { concrete_type(NULL_VAL); }
+    Null(ParserState pstate) : Expression(pstate) { concrete_type(NULL_VAL); }
     string type() { return "null"; }
     static string type_name() { return "null"; }
     bool is_invisible() { return true; }
@@ -1477,8 +1621,8 @@ namespace Sass {
     ADD_PROPERTY(Expression*, expression);
     ADD_PROPERTY(Env*, environment);
   public:
-    Thunk(string path, Position position, Expression* exp, Env* env = 0)
-    : Expression(path, position), expression_(exp), environment_(env)
+    Thunk(ParserState pstate, Expression* exp, Env* env = 0)
+    : Expression(pstate), expression_(exp), environment_(env)
     { }
   };
 
@@ -1490,12 +1634,12 @@ namespace Sass {
     ADD_PROPERTY(Expression*, default_value);
     ADD_PROPERTY(bool, is_rest_parameter);
   public:
-    Parameter(string p, Position pos,
+    Parameter(ParserState pstate,
               string n, Expression* def = 0, bool rest = false)
-    : AST_Node(p, pos), name_(n), default_value_(def), is_rest_parameter_(rest)
+    : AST_Node(pstate), name_(n), default_value_(def), is_rest_parameter_(rest)
     {
       if (default_value_ && is_rest_parameter_) {
-        error("variable-length parameter may not have a default value", path(), position());
+        error("variable-length parameter may not have a default value", pstate);
       }
     }
     ATTACH_OPERATIONS();
@@ -1514,31 +1658,31 @@ namespace Sass {
     {
       if (p->default_value()) {
         if (has_rest_parameter_) {
-          error("optional parameters may not be combined with variable-length parameters", p->path(), p->position());
+          error("optional parameters may not be combined with variable-length parameters", p->pstate());
         }
         has_optional_parameters_ = true;
       }
       else if (p->is_rest_parameter()) {
         if (has_rest_parameter_) {
-          error("functions and mixins cannot have more than one variable-length parameter", p->path(), p->position());
+          error("functions and mixins cannot have more than one variable-length parameter", p->pstate());
         }
         if (has_optional_parameters_) {
-          error("optional parameters may not be combined with variable-length parameters", p->path(), p->position());
+          error("optional parameters may not be combined with variable-length parameters", p->pstate());
         }
         has_rest_parameter_ = true;
       }
       else {
         if (has_rest_parameter_) {
-          error("required parameters must precede variable-length parameters", p->path(), p->position());
+          error("required parameters must precede variable-length parameters", p->pstate());
         }
         if (has_optional_parameters_) {
-          error("required parameters must precede optional parameters", p->path(), p->position());
+          error("required parameters must precede optional parameters", p->pstate());
         }
       }
     }
   public:
-    Parameters(string path, Position position)
-    : AST_Node(path, position),
+    Parameters(ParserState pstate)
+    : AST_Node(pstate),
       Vectorized<Parameter*>(),
       has_optional_parameters_(false),
       has_rest_parameter_(false)
@@ -1557,12 +1701,27 @@ namespace Sass {
   class Selector : public AST_Node {
     ADD_PROPERTY(bool, has_reference);
     ADD_PROPERTY(bool, has_placeholder);
-  public:
-    Selector(string path, Position position, bool r = false, bool h = false)
-    : AST_Node(path, position), has_reference_(r), has_placeholder_(h)
+    // line break before list separator
+    ADD_PROPERTY(bool, has_line_feed);
+    // line break after list separator
+    ADD_PROPERTY(bool, has_line_break);
+    // maybe we have optional flag
+    ADD_PROPERTY(bool, is_optional);
+    // parent block pointers
+    ADD_PROPERTY(Block*, last_block);
+    ADD_PROPERTY(Media_Block*, media_block);
+  public:
+    Selector(ParserState pstate, bool r = false, bool h = false)
+    : AST_Node(pstate),
+      has_reference_(r),
+      has_placeholder_(h),
+      has_line_feed_(false),
+      has_line_break_(false),
+      is_optional_(false),
+      media_block_(0)
     { }
     virtual ~Selector() = 0;
-    virtual Selector_Placeholder* find_placeholder();
+    // virtual Selector_Placeholder* find_placeholder();
     virtual int specificity() { return Constants::SPECIFICITY_BASE; }
   };
   inline Selector::~Selector() { }
@@ -1574,8 +1733,8 @@ namespace Sass {
   class Selector_Schema : public Selector {
     ADD_PROPERTY(String*, contents);
   public:
-    Selector_Schema(string path, Position position, String* c)
-    : Selector(path, position), contents_(c)
+    Selector_Schema(ParserState pstate, String* c)
+    : Selector(pstate), contents_(c)
     { }
     ATTACH_OPERATIONS();
   };
@@ -1585,8 +1744,8 @@ namespace Sass {
   ////////////////////////////////////////////
   class Simple_Selector : public Selector {
   public:
-    Simple_Selector(string path, Position position)
-    : Selector(path, position)
+    Simple_Selector(ParserState pstate)
+    : Selector(pstate)
     { }
     virtual ~Simple_Selector() = 0;
     virtual Compound_Selector* unify_with(Compound_Selector*, Context&);
@@ -1605,8 +1764,8 @@ namespace Sass {
   class Selector_Reference : public Simple_Selector {
     ADD_PROPERTY(Selector*, selector);
   public:
-    Selector_Reference(string path, Position position, Selector* r = 0)
-    : Simple_Selector(path, position), selector_(r)
+    Selector_Reference(ParserState pstate, Selector* r = 0)
+    : Simple_Selector(pstate), selector_(r)
     { has_reference(true); }
     virtual int specificity()
     {
@@ -1622,10 +1781,10 @@ namespace Sass {
   class Selector_Placeholder : public Simple_Selector {
     ADD_PROPERTY(string, name);
   public:
-    Selector_Placeholder(string path, Position position, string n)
-    : Simple_Selector(path, position), name_(n)
+    Selector_Placeholder(ParserState pstate, string n)
+    : Simple_Selector(pstate), name_(n)
     { has_placeholder(true); }
-    virtual Selector_Placeholder* find_placeholder();
+    // virtual Selector_Placeholder* find_placeholder();
     ATTACH_OPERATIONS();
   };
 
@@ -1635,8 +1794,8 @@ namespace Sass {
   class Type_Selector : public Simple_Selector {
     ADD_PROPERTY(string, name);
   public:
-    Type_Selector(string path, Position position, string n)
-    : Simple_Selector(path, position), name_(n)
+    Type_Selector(ParserState pstate, string n)
+    : Simple_Selector(pstate), name_(n)
     { }
     virtual int specificity()
     {
@@ -1653,8 +1812,8 @@ namespace Sass {
   class Selector_Qualifier : public Simple_Selector {
     ADD_PROPERTY(string, name);
   public:
-    Selector_Qualifier(string path, Position position, string n)
-    : Simple_Selector(path, position), name_(n)
+    Selector_Qualifier(ParserState pstate, string n)
+    : Simple_Selector(pstate), name_(n)
     { }
     virtual int specificity()
     {
@@ -1673,8 +1832,8 @@ namespace Sass {
     ADD_PROPERTY(string, matcher);
     ADD_PROPERTY(String*, value); // might be interpolated
   public:
-    Attribute_Selector(string path, Position position, string n, string m, String* v)
-    : Simple_Selector(path, position), name_(n), matcher_(m), value_(v)
+    Attribute_Selector(ParserState pstate, string n, string m, String* v)
+    : Simple_Selector(pstate), name_(n), matcher_(m), value_(v)
     { }
     ATTACH_OPERATIONS();
   };
@@ -1686,8 +1845,8 @@ namespace Sass {
     ADD_PROPERTY(string, name);
     ADD_PROPERTY(String*, expression);
   public:
-    Pseudo_Selector(string path, Position position, string n, String* expr = 0)
-    : Simple_Selector(path, position), name_(n), expression_(expr)
+    Pseudo_Selector(ParserState pstate, string n, String* expr = 0)
+    : Simple_Selector(pstate), name_(n), expression_(expr)
     { }
     virtual int specificity()
     {
@@ -1724,8 +1883,8 @@ namespace Sass {
     ADD_PROPERTY(string, name);
     ADD_PROPERTY(Selector*, selector);
   public:
-    Wrapped_Selector(string path, Position position, string n, Selector* sel)
-    : Simple_Selector(path, position), name_(n), selector_(sel)
+    Wrapped_Selector(ParserState pstate, string n, Selector* sel)
+    : Simple_Selector(pstate), name_(n), selector_(sel)
     { }
     ATTACH_OPERATIONS();
   };
@@ -1749,13 +1908,13 @@ namespace Sass {
       if (s->has_placeholder()) has_placeholder(true);
     }
   public:
-    Compound_Selector(string path, Position position, size_t s = 0)
-    : Selector(path, position),
+    Compound_Selector(ParserState pstate, size_t s = 0)
+    : Selector(pstate),
       Vectorized<Simple_Selector*>(s)
     { }
 
     Compound_Selector* unify_with(Compound_Selector* rhs, Context& ctx);
-    virtual Selector_Placeholder* find_placeholder();
+    // virtual Selector_Placeholder* find_placeholder();
     Simple_Selector* base()
     {
       // Implement non-const in terms of const. Safe to const_cast since this method is non-const
@@ -1802,7 +1961,6 @@ namespace Sass {
   // CSS selector combinators (">", "+", "~", and whitespace). Essentially a
   // linked list.
   ////////////////////////////////////////////////////////////////////////////
-  struct Context;
   class Complex_Selector : public Selector {
   public:
     enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO };
@@ -1811,11 +1969,11 @@ namespace Sass {
     ADD_PROPERTY(Compound_Selector*, head);
     ADD_PROPERTY(Complex_Selector*, tail);
   public:
-    Complex_Selector(string path, Position position,
-                         Combinator c,
-                         Compound_Selector* h,
-                         Complex_Selector* t)
-    : Selector(path, position), combinator_(c), head_(h), tail_(t)
+    Complex_Selector(ParserState pstate,
+                     Combinator c,
+                     Compound_Selector* h,
+                     Complex_Selector* t)
+    : Selector(pstate), combinator_(c), head_(h), tail_(t)
     {
       if ((h && h->has_reference())   || (t && t->has_reference()))   has_reference(true);
       if ((h && h->has_placeholder()) || (t && t->has_placeholder())) has_placeholder(true);
@@ -1826,7 +1984,7 @@ namespace Sass {
     size_t length();
     bool is_superselector_of(Compound_Selector*);
     bool is_superselector_of(Complex_Selector*);
-    virtual Selector_Placeholder* find_placeholder();
+    // virtual Selector_Placeholder* find_placeholder();
     Combinator clear_innermost();
     void set_innermost(Complex_Selector*, Combinator);
     virtual int specificity() const
@@ -1889,7 +2047,7 @@ namespace Sass {
     }
     Complex_Selector* clone(Context&) const;      // does not clone Compound_Selector*s
     Complex_Selector* cloneFully(Context&) const; // clones Compound_Selector*s
-    vector<Compound_Selector*> to_vector();
+    // vector<Compound_Selector*> to_vector();
     ATTACH_OPERATIONS();
   };
 
@@ -1898,18 +2056,18 @@ namespace Sass {
   ///////////////////////////////////
   // Comma-separated selector groups.
   ///////////////////////////////////
-  class Selector_List
-      : public Selector, public Vectorized<Complex_Selector*> {
+  class Selector_List : public Selector, public Vectorized<Complex_Selector*> {
 #ifdef DEBUG
     ADD_PROPERTY(string, mCachedSelector);
 #endif
+    ADD_PROPERTY(vector<string>, wspace);
   protected:
     void adjust_after_pushing(Complex_Selector* c);
   public:
-    Selector_List(string path, Position position, size_t s = 0)
-    : Selector(path, position), Vectorized<Complex_Selector*>(s)
+    Selector_List(ParserState pstate, size_t s = 0)
+    : Selector(pstate), Vectorized<Complex_Selector*>(s), wspace_(0)
     { }
-    virtual Selector_Placeholder* find_placeholder();
+    // virtual Selector_Placeholder* find_placeholder();
     virtual int specificity()
     {
       int sum = 0;
@@ -1921,6 +2079,14 @@ namespace Sass {
     ATTACH_OPERATIONS();
   };
 
+  inline bool Ruleset::is_invisible() {
+    bool is_invisible = true;
+    Selector_List* sl = static_cast<Selector_List*>(selector());
+    for (size_t i = 0, L = sl->length(); i < L && is_invisible; ++i)
+      is_invisible &= (*sl)[i]->has_placeholder();
+    return is_invisible;
+  }
+
 
   template<typename SelectorType>
   bool selectors_equal(const SelectorType& one, const SelectorType& two, bool simpleSelectorOrderDependent) {
@@ -1947,3 +2113,5 @@ namespace Sass {
 #pragma clang diagnostic pop
 
 #endif
+
+#endif