sassc 1.10.1 → 1.11.0

data/ext/libsass/src/node.hpp

@@ -17,7 +17,7 @@ namespace Sass {
   /*
    There are a lot of stumbling blocks when trying to port the ruby extend code to C++. The biggest is the choice of
    data type. The ruby code will pretty seamlessly switch types between an Array<SimpleSequence or Op> (libsass'
-   equivalent is the Complex_Selector) to a Sequence, which contains more metadata about the sequence than just the
+   equivalent is the Sequence_Selector) to a Sequence, which contains more metadata about the sequence than just the
    selector info. They also have the ability to have arbitrary nestings of arrays like [1, [2]], which is hard to
    implement using Array equivalents in C++ (like the deque or vector). They also have the ability to include nil
    in the arrays, like [1, nil, 3], which has potential semantic differences than an empty array [1, [], 3]. To be
@@ -26,7 +26,7 @@ namespace Sass {
    more closely match the ruby code, which is a huge benefit when attempting to implement an complex algorithm like
    the Extend operator.
 
-   Note that the current libsass data model also pairs the combinator with the Complex_Selector that follows it, but
+   Note that the current libsass data model also pairs the combinator with the Sequence_Selector that follows it, but
    ruby sass has no such restriction, so we attempt to create a data structure that can handle them split apart.
    */
 
@@ -50,18 +50,18 @@ namespace Sass {
     bool isNil() const { return mType == NIL; }
     bool got_line_feed;
 
-    Complex_Selector::Combinator combinator() const { return mCombinator; }
+    Sequence_Selector::Combinator combinator() const { return mCombinator; }
 
-    Complex_Selector* selector() { return mpSelector; }
-    const Complex_Selector* selector() const { return mpSelector; }
+    Sequence_Selector* selector() { return mpSelector; }
+    const Sequence_Selector* selector() const { return mpSelector; }
 
     NodeDequePtr collection() { return mpCollection; }
     const NodeDequePtr collection() const { return mpCollection; }
 
-    static Node createCombinator(const Complex_Selector::Combinator& combinator);
+    static Node createCombinator(const Sequence_Selector::Combinator& combinator);
 
     // This method will clone the selector, stripping off the tail and combinator
-    static Node createSelector(Complex_Selector* pSelector, Context& ctx);
+    static Node createSelector(Sequence_Selector* pSelector, Context& ctx);
 
     static Node createCollection();
     static Node createCollection(const NodeDeque& values);
@@ -79,7 +79,7 @@ namespace Sass {
     COLLECTION FUNCTIONS
 
     Most types don't need any helper methods (nil and combinator due to their simplicity and
-    selector due to the fact that we leverage the non-node selector code on the Complex_Selector
+    selector due to the fact that we leverage the non-node selector code on the Sequence_Selector
     whereever possible). The following methods are intended to be called on Node objects whose
     type is COLLECTION only.
     */
@@ -97,21 +97,21 @@ namespace Sass {
     // Private constructor; Use the static methods (like createCombinator and createSelector)
     // to instantiate this object. This is more expressive, and it allows us to break apart each
     // case into separate functions.
-    Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection);
+    Node(const TYPE& type, Sequence_Selector::Combinator combinator, Sequence_Selector* pSelector, NodeDequePtr& pCollection);
 
     TYPE mType;
 
     // TODO: can we union these to save on memory?
-    Complex_Selector::Combinator mCombinator;
-    Complex_Selector* mpSelector; // this is an AST_Node, so it will be handled by the Memory_Manager
+    Sequence_Selector::Combinator mCombinator;
+    Sequence_Selector* mpSelector; // this is an AST_Node, so it will be handled by the Memory_Manager
     NodeDequePtr mpCollection;
   };
 
 #ifdef DEBUG
   std::ostream& operator<<(std::ostream& os, const Node& node);
 #endif
-  Node complexSelectorToNode(Complex_Selector* pToConvert, Context& ctx);
-  Complex_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx);
+  Node complexSelectorToNode(Sequence_Selector* pToConvert, Context& ctx);
+  Sequence_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx);
 
   bool nodesEqual(const Node& one, const Node& two, bool simpleSelectorOrderDependent);
 

data/ext/libsass/src/operation.hpp

@@ -13,12 +13,12 @@ namespace Sass {
     // statements
     virtual T operator()(Block* x)                  = 0;
     virtual T operator()(Ruleset* x)                = 0;
-    virtual T operator()(Propset* x)                = 0;
     virtual T operator()(Bubble* x)                 = 0;
+    virtual T operator()(Trace* x)                  = 0;
     virtual T operator()(Supports_Block* x)         = 0;
     virtual T operator()(Media_Block* x)            = 0;
     virtual T operator()(At_Root_Block* x)          = 0;
-    virtual T operator()(Directive* x)                = 0;
+    virtual T operator()(Directive* x)              = 0;
     virtual T operator()(Keyframe_Rule* x)          = 0;
     virtual T operator()(Declaration* x)            = 0;
     virtual T operator()(Assignment* x)             = 0;
@@ -61,7 +61,7 @@ namespace Sass {
     virtual T operator()(Supports_Interpolation* x) = 0;
     virtual T operator()(Media_Query* x)            = 0;
     virtual T operator()(Media_Query_Expression* x) = 0;
-    virtual T operator()(At_Root_Query* x)     = 0;
+    virtual T operator()(At_Root_Query* x)          = 0;
     virtual T operator()(Null* x)                   = 0;
     virtual T operator()(Parent_Selector* x)        = 0;
     // parameters and arguments
@@ -71,15 +71,16 @@ namespace Sass {
     virtual T operator()(Arguments* x)              = 0;
     // selectors
     virtual T operator()(Selector_Schema* x)        = 0;
-    virtual T operator()(Selector_Placeholder* x)   = 0;
-    virtual T operator()(Type_Selector* x)          = 0;
-    virtual T operator()(Selector_Qualifier* x)     = 0;
+    virtual T operator()(Placeholder_Selector* x)   = 0;
+    virtual T operator()(Element_Selector* x)       = 0;
+    virtual T operator()(Class_Selector* x)         = 0;
+    virtual T operator()(Id_Selector* x)            = 0;
     virtual T operator()(Attribute_Selector* x)     = 0;
     virtual T operator()(Pseudo_Selector* x)        = 0;
     virtual T operator()(Wrapped_Selector* x)       = 0;
-    virtual T operator()(Compound_Selector* x)      = 0;
-    virtual T operator()(Complex_Selector* x)       = 0;
-    virtual T operator()(Selector_List* x)          = 0;
+    virtual T operator()(SimpleSequence_Selector* x)= 0;
+    virtual T operator()(Sequence_Selector* x)      = 0;
+    virtual T operator()(CommaSequence_Selector* x) = 0;
 
     template <typename U>
     T fallback(U x) { return T(); }
@@ -94,12 +95,12 @@ namespace Sass {
     // statements
     T operator()(Block* x)                  { return static_cast<D*>(this)->fallback(x); }
     T operator()(Ruleset* x)                { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Propset* x)                { return static_cast<D*>(this)->fallback(x); }
     T operator()(Bubble* x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Trace* x)                  { return static_cast<D*>(this)->fallback(x); }
     T operator()(Supports_Block* x)         { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Block* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(At_Root_Block* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Directive* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Directive* x)              { return static_cast<D*>(this)->fallback(x); }
     T operator()(Keyframe_Rule* x)          { return static_cast<D*>(this)->fallback(x); }
     T operator()(Declaration* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(Assignment* x)             { return static_cast<D*>(this)->fallback(x); }
@@ -142,7 +143,7 @@ namespace Sass {
     T operator()(Supports_Interpolation* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Query* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(Media_Query_Expression* x) { return static_cast<D*>(this)->fallback(x); }
-    T operator()(At_Root_Query* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(At_Root_Query* x)          { return static_cast<D*>(this)->fallback(x); }
     T operator()(Null* x)                   { return static_cast<D*>(this)->fallback(x); }
     T operator()(Parent_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
     // parameters and arguments
@@ -152,18 +153,19 @@ namespace Sass {
     T operator()(Arguments* x)              { return static_cast<D*>(this)->fallback(x); }
     // selectors
     T operator()(Selector_Schema* x)        { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Selector_Placeholder* x)   { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Type_Selector* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Selector_Qualifier* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Placeholder_Selector* x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Element_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Class_Selector* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Id_Selector* x)            { return static_cast<D*>(this)->fallback(x); }
     T operator()(Attribute_Selector* x)     { return static_cast<D*>(this)->fallback(x); }
     T operator()(Pseudo_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
     T operator()(Wrapped_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Compound_Selector* x)      { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Complex_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Selector_List* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SimpleSequence_Selector* x){ return static_cast<D*>(this)->fallback(x); }
+    T operator()(Sequence_Selector* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(CommaSequence_Selector* x) { return static_cast<D*>(this)->fallback(x); }
 
     template <typename U>
-    T fallback(U x)                                 { return T(); }
+    T fallback(U x)                         { return T(); }
   };
 
 }

data/ext/libsass/src/output.cpp

@@ -111,77 +111,65 @@ namespace Sass {
   {
     Selector* s     = r->selector();
     Block*    b     = r->block();
-    bool      decls = false;
 
     // Filter out rulesets that aren't printable (process its children though)
     if (!Util::isPrintable(r, output_style())) {
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement* stm = (*b)[i];
         if (dynamic_cast<Has_Block*>(stm)) {
-          stm->perform(this);
+          if (typeid(*stm) != typeid(Declaration)) {
+            stm->perform(this);
+          }
         }
       }
       return;
     }
 
-    if (b->has_non_hoistable()) {
-      decls = true;
-      if (output_style() == NESTED) indentation += r->tabs();
-      if (opt.source_comments) {
-        std::stringstream ss;
-        append_indentation();
-        ss << "/* line " << r->pstate().line + 1 << ", " << r->pstate().path << " */";
-        append_string(ss.str());
-        append_optional_linefeed();
-      }
-      s->perform(this);
-      append_scope_opener(b);
-      for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        bool bPrintExpression = true;
-        // Check print conditions
-        if (typeid(*stm) == typeid(Declaration)) {
-          Declaration* dec = static_cast<Declaration*>(stm);
-          if (dec->value()->concrete_type() == Expression::STRING) {
-            String_Constant* valConst = static_cast<String_Constant*>(dec->value());
-            std::string val(valConst->value());
-            if (auto qstr = dynamic_cast<String_Quoted*>(valConst)) {
-              if (!qstr->quote_mark() && val.empty()) {
-                bPrintExpression = false;
-              }
-            }
-          }
-          else if (dec->value()->concrete_type() == Expression::LIST) {
-            List* list = static_cast<List*>(dec->value());
-            bool all_invisible = true;
-            for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
-              Expression* item = (*list)[list_i];
-              if (!item->is_invisible()) all_invisible = false;
+    if (output_style() == NESTED) indentation += r->tabs();
+    if (opt.source_comments) {
+      std::stringstream ss;
+      append_indentation();
+      std::string path(File::abs2rel(r->pstate().path));
+      ss << "/* line " << r->pstate().line + 1 << ", " << path << " */";
+      append_string(ss.str());
+      append_optional_linefeed();
+    }
+    s->perform(this);
+    append_scope_opener(b);
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement* stm = (*b)[i];
+      bool bPrintExpression = true;
+      // Check print conditions
+      if (typeid(*stm) == typeid(Declaration)) {
+        Declaration* dec = static_cast<Declaration*>(stm);
+        if (dec->value()->concrete_type() == Expression::STRING) {
+          String_Constant* valConst = static_cast<String_Constant*>(dec->value());
+          std::string val(valConst->value());
+          if (auto qstr = dynamic_cast<String_Quoted*>(valConst)) {
+            if (!qstr->quote_mark() && val.empty()) {
+              bPrintExpression = false;
             }
-            if (all_invisible) bPrintExpression = false;
           }
         }
-        // Print if OK
-        if (!stm->is_hoistable() && bPrintExpression) {
-          stm->perform(this);
+        else if (dec->value()->concrete_type() == Expression::LIST) {
+          List* list = static_cast<List*>(dec->value());
+          bool all_invisible = true;
+          for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
+            Expression* item = (*list)[list_i];
+            if (!item->is_invisible()) all_invisible = false;
+          }
+          if (all_invisible) bPrintExpression = false;
         }
       }
-      if (output_style() == NESTED) indentation -= r->tabs();
-      append_scope_closer(b);
-    }
-
-    if (b->has_hoistable()) {
-      if (decls) ++indentation;
-      for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        if (stm->is_hoistable()) {
-          stm->perform(this);
-        }
+      // Print if OK
+      if (bPrintExpression) {
+        stm->perform(this);
       }
-      if (decls) --indentation;
     }
-  }
+    if (output_style() == NESTED) indentation -= r->tabs();
+    append_scope_closer(b);
 
+  }
   void Output::operator()(Keyframe_Rule* r)
   {
     Block* b = r->block();
@@ -199,19 +187,9 @@ namespace Sass {
     append_scope_opener();
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement* stm = (*b)[i];
-      if (!stm->is_hoistable()) {
-        stm->perform(this);
-        if (i < L - 1) append_special_linefeed();
-      }
-    }
-
-    for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement* stm = (*b)[i];
-      if (stm->is_hoistable()) {
-        stm->perform(this);
-      }
+      stm->perform(this);
+      if (i < L - 1) append_special_linefeed();
     }
-
     append_scope_closer();
   }
 
@@ -240,33 +218,10 @@ namespace Sass {
     c->perform(this);
     append_scope_opener();
 
-    if (b->has_non_hoistable()) {
-      // JMA - hoisted, output the non-hoistable in a nested block, followed by the hoistable
-      append_scope_opener();
-
-      for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        if (!stm->is_hoistable()) {
-          stm->perform(this);
-        }
-      }
-
-      append_scope_closer();
-
-      for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        if (stm->is_hoistable()) {
-          stm->perform(this);
-        }
-      }
-    }
-    else {
-      // JMA - not hoisted, just output in order
-      for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement* stm = (*b)[i];
-        stm->perform(this);
-        if (i < L - 1) append_special_linefeed();
-      }
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement* stm = (*b)[i];
+      stm->perform(this);
+      if (i < L - 1) append_special_linefeed();
     }
 
     if (output_style() == NESTED) indentation -= f->tabs();
@@ -346,18 +301,8 @@ namespace Sass {
 
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement* stm = (*b)[i];
-      if (!stm->is_hoistable()) {
-        stm->perform(this);
-        if (i < L - 1 && format) append_special_linefeed();
-      }
-    }
-
-    for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement* stm = (*b)[i];
-      if (stm->is_hoistable()) {
-        stm->perform(this);
-        if (i < L - 1 && format) append_special_linefeed();
-      }
+      stm->perform(this);
+      if (i < L - 1 && format) append_special_linefeed();
     }
 
     append_scope_closer();

data/ext/libsass/src/output.hpp

@@ -35,7 +35,6 @@ namespace Sass {
 
     virtual void operator()(Map*);
     virtual void operator()(Ruleset*);
-    // virtual void operator()(Propset*);
     virtual void operator()(Supports_Block*);
     virtual void operator()(Media_Block*);
     virtual void operator()(Directive*);

data/ext/libsass/src/parser.cpp

@@ -12,6 +12,18 @@
 #include "sass/functions.h"
 #include "error_handling.hpp"
 
+// Notes about delayed: some ast nodes can have delayed evaluation so
+// they can preserve their original semantics if needed. This is most
+// prominently exhibited by the division operation, since it is not
+// only a valid operation, but also a valid css statement (i.e. for
+// fonts, as in `16px/24px`). When parsing lists and expression we
+// unwrap single items from lists and other operations. A nested list
+// must not be delayed, only the items of the first level sometimes
+// are delayed (as with argument lists). To achieve this we need to
+// pass status to the list parser, so this can be set correctly.
+// Another case with delayed values are colors. In compressed mode
+// only processed values get compressed (other are left as written).
+
 #include <typeinfo>
 #include <tuple>
 
@@ -21,6 +33,8 @@ namespace Sass {
 
   Parser Parser::from_c_str(const char* beg, Context& ctx, ParserState pstate, const char* source)
   {
+    pstate.offset.column = 0;
+    pstate.offset.line = 0;
     Parser p(ctx, pstate);
     p.source   = source ? source : beg;
     p.position = beg ? beg : p.source;
@@ -33,6 +47,8 @@ namespace Sass {
 
   Parser Parser::from_c_str(const char* beg, const char* end, Context& ctx, ParserState pstate, const char* source)
   {
+    pstate.offset.column = 0;
+    pstate.offset.line = 0;
     Parser p(ctx, pstate);
     p.source   = source ? source : beg;
     p.position = beg ? beg : p.source;
@@ -43,7 +59,15 @@ namespace Sass {
     return p;
   }
 
-  Selector_List* Parser::parse_selector(const char* beg, Context& ctx, ParserState pstate, const char* source)
+   void Parser::advanceToNextToken() {
+      lex < css_comments >(false);
+      // advance to position
+      pstate += pstate.offset;
+      pstate.offset.column = 0;
+      pstate.offset.line = 0;
+    }
+
+  CommaSequence_Selector* Parser::parse_selector(const char* beg, Context& ctx, ParserState pstate, const char* source)
   {
     Parser p = Parser::from_c_str(beg, ctx, pstate, source);
     // ToDo: ruby sass errors on parent references
@@ -254,7 +278,7 @@ namespace Sass {
     else if (lex< re_prefixed_directive >(true)) { (*block) << parse_prefixed_directive(); }
     else if (lex< at_keyword >(true)) { (*block) << parse_directive(); }
 
-    else if (block->is_root()) {
+    else if (is_root /* && block->is_root() */) {
       lex< css_whitespace >();
       if (position >= end) return true;
       css_error("Invalid CSS", " after ", ": expected 1 selector or at-rule, was ");
@@ -272,7 +296,7 @@ namespace Sass {
         if (decl->is_indented()) ++ indentation;
         // parse a propset that rides on the declaration's property
         stack.push_back(Scope::Properties);
-        (*block) << SASS_MEMORY_NEW(ctx.mem, Propset, pstate, decl->property(), parse_block());
+        decl->block(parse_block());
         stack.pop_back();
         if (decl->is_indented()) -- indentation;
       }
@@ -321,7 +345,7 @@ namespace Sass {
       first = false;
     } while (lex_css< exactly<','> >());
 
-    if (!peek_css<alternatives<exactly<';'>,end_of_file>>()) {
+    if (!peek_css< alternatives< exactly<';'>, exactly<'}'>, end_of_file > >()) {
       List* media_queries = parse_media_queries();
       imp->media_queries(media_queries);
     }
@@ -391,7 +415,6 @@ namespace Sass {
     if (lex< exactly<':'> >()) { // there's a default value
       while (lex< block_comment >());
       val = parse_space_list();
-      val->is_delayed(false);
     }
     else if (lex< exactly< ellipsis > >()) {
       is_rest = true;
@@ -430,14 +453,12 @@ namespace Sass {
       ParserState p = pstate;
       lex_css< exactly<':'> >();
       Expression* val = parse_space_list();
-      val->is_delayed(false);
       arg = SASS_MEMORY_NEW(ctx.mem, Argument, p, val, name);
     }
     else {
       bool is_arglist = false;
       bool is_keyword = false;
       Expression* val = parse_space_list();
-      val->is_delayed(false);
       List* l = dynamic_cast<List*>(val);
       if (lex_css< exactly< ellipsis > >()) {
         if (val->concrete_type() == Expression::MAP || (
@@ -455,6 +476,9 @@ namespace Sass {
     std::string name(Util::normalize_underscores(lexed));
     ParserState var_source_position = pstate;
     if (!lex< exactly<':'> >()) error("expected ':' after " + name + " in assignment statement", pstate);
+    if (peek_css< alternatives < exactly<';'>, end_of_file > >()) {
+      css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+    }
     Expression* val;
     Lookahead lookahead = lookahead_for_value(position);
     if (lookahead.has_interpolants && lookahead.found) {
@@ -462,7 +486,6 @@ namespace Sass {
     } else {
       val = parse_list();
     }
-    val->is_delayed(false);
     bool is_default = false;
     bool is_global = false;
     while (peek< alternatives < default_flag, global_flag > >()) {
@@ -587,12 +610,12 @@ namespace Sass {
 
   // parse a list of complex selectors
   // this is the main entry point for most
-  Selector_List* Parser::parse_selector_list(bool in_root)
+  CommaSequence_Selector* Parser::parse_selector_list(bool in_root)
   {
     bool reloop = true;
     bool had_linefeed = false;
-    Complex_Selector* sel = 0;
-    Selector_List* group = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate);
+    Sequence_Selector* sel = 0;
+    CommaSequence_Selector* group = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate);
     group->media_block(last_media_block);
 
     do {
@@ -639,13 +662,16 @@ namespace Sass {
   // complex selector, with one of four combinator operations.
   // the compound selector (head) is optional, since the combinator
   // can come first in the whole selector sequence (like `> DIV').
-  Complex_Selector* Parser::parse_complex_selector(bool in_root)
+  Sequence_Selector* Parser::parse_complex_selector(bool in_root)
   {
 
     String* reference = 0;
     lex < block_comment >();
+
+    Sequence_Selector* sel = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, pstate);
+
     // parse the left hand side
-    Compound_Selector* lhs = 0;
+    SimpleSequence_Selector* lhs = 0;
     // special case if it starts with combinator ([+~>])
     if (!peek_css< class_char < selector_combinator_ops > >()) {
       // parse the left hand side
@@ -656,28 +682,27 @@ namespace Sass {
     if (peek < end_of_file >()) return 0;
 
     // parse combinator between lhs and rhs
-    Complex_Selector::Combinator combinator;
-    if      (lex< exactly<'+'> >()) combinator = Complex_Selector::ADJACENT_TO;
-    else if (lex< exactly<'~'> >()) combinator = Complex_Selector::PRECEDES;
-    else if (lex< exactly<'>'> >()) combinator = Complex_Selector::PARENT_OF;
+    Sequence_Selector::Combinator combinator;
+    if      (lex< exactly<'+'> >()) combinator = Sequence_Selector::ADJACENT_TO;
+    else if (lex< exactly<'~'> >()) combinator = Sequence_Selector::PRECEDES;
+    else if (lex< exactly<'>'> >()) combinator = Sequence_Selector::PARENT_OF;
     else if (lex< sequence < exactly<'/'>, negate < exactly < '*' > > > >()) {
       // comments are allowed, but not spaces?
-      combinator = Complex_Selector::REFERENCE;
+      combinator = Sequence_Selector::REFERENCE;
       if (!lex < re_reference_combinator >()) return 0;
       reference = SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
       if (!lex < exactly < '/' > >()) return 0; // ToDo: error msg?
     }
-    else /* if (lex< zero >()) */   combinator = Complex_Selector::ANCESTOR_OF;
+    else /* if (lex< zero >()) */   combinator = Sequence_Selector::ANCESTOR_OF;
 
-    if (!lhs && combinator == Complex_Selector::ANCESTOR_OF) return 0;
+    if (!lhs && combinator == Sequence_Selector::ANCESTOR_OF) return 0;
 
     // lex < block_comment >();
-    // source position of a complex selector points to the combinator
-    // ToDo: make sure we update pstate for ancestor of (lex < zero >());
-    Complex_Selector* sel = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, pstate, combinator, lhs);
+    sel->head(lhs);
+    sel->combinator(combinator);
     sel->media_block(last_media_block);
 
-    if (combinator == Complex_Selector::REFERENCE) sel->reference(reference);
+    if (combinator == Sequence_Selector::REFERENCE) sel->reference(reference);
     // has linfeed after combinator?
     sel->has_line_break(peek_newline());
     // sel->has_line_feed(has_line_feed);
@@ -686,20 +711,15 @@ namespace Sass {
     if (!peek_css< class_char < complex_selector_delims > >()) {
       // parse next selector in sequence
       sel->tail(parse_complex_selector(true));
-      if (sel->tail()) {
-        // ToDo: move this logic below into tail setter
-        // if (sel->tail()->has_reference()) sel->has_reference(true);
-        if (sel->tail()->has_placeholder()) sel->has_placeholder(true);
-      }
     }
 
     // add a parent selector if we are not in a root
     // also skip adding parent ref if we only have refs
     if (!sel->has_parent_ref() && !in_at_root && !in_root) {
       // create the objects to wrap parent selector reference
-      Parent_Selector* parent = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, pstate);
+      SimpleSequence_Selector* head = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, pstate);
+      Parent_Selector* parent = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, pstate, false);
       parent->media_block(last_media_block);
-      Compound_Selector* head = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, pstate);
       head->media_block(last_media_block);
       // add simple selector
       (*head) << parent;
@@ -707,13 +727,15 @@ namespace Sass {
       if (!sel->head()) { sel->head(head); }
       // otherwise we need to create a new complex selector and set the old one as its tail
       else {
-        sel = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, pstate, Complex_Selector::ANCESTOR_OF, head, sel);
+        sel = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, pstate, Sequence_Selector::ANCESTOR_OF, head, sel);
         sel->media_block(last_media_block);
       }
       // peek for linefeed and remember result on head
       // if (peek_newline()) head->has_line_break(true);
     }
 
+    sel->update_pstate(pstate);
+
     // complex selector
     return sel;
   }
@@ -722,10 +744,10 @@ namespace Sass {
   // parse one compound selector, which is basically
   // a list of simple selectors (directly adjacent)
   // lex them exactly (without skipping white-space)
-  Compound_Selector* Parser::parse_compound_selector()
+  SimpleSequence_Selector* Parser::parse_compound_selector()
   {
     // init an empty compound selector wrapper
-    Compound_Selector* seq = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, pstate);
+    SimpleSequence_Selector* seq = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, pstate);
     seq->media_block(last_media_block);
 
     // skip initial white-space
@@ -763,7 +785,7 @@ namespace Sass {
       // parse type selector
       else if (lex< re_type_selector >(false))
       {
-        (*seq) << SASS_MEMORY_NEW(ctx.mem, Type_Selector, pstate, lexed);
+        (*seq) << SASS_MEMORY_NEW(ctx.mem, Element_Selector, pstate, lexed);
       }
       // peek for abort conditions
       else if (peek< spaces >()) break;
@@ -791,14 +813,17 @@ namespace Sass {
   Simple_Selector* Parser::parse_simple_selector()
   {
     lex < css_comments >(false);
-    if (lex< alternatives < id_name, class_name > >()) {
-      return SASS_MEMORY_NEW(ctx.mem, Selector_Qualifier, pstate, lexed);
+    if (lex< class_name >()) {
+      return SASS_MEMORY_NEW(ctx.mem, Class_Selector, pstate, lexed);
+    }
+    else if (lex< id_name >()) {
+      return SASS_MEMORY_NEW(ctx.mem, Id_Selector, pstate, lexed);
     }
     else if (lex< quoted_string >()) {
-      return SASS_MEMORY_NEW(ctx.mem, Type_Selector, pstate, unquote(lexed));
+      return SASS_MEMORY_NEW(ctx.mem, Element_Selector, pstate, unquote(lexed));
     }
     else if (lex< alternatives < variable, number, static_reference_combinator > >()) {
-      return SASS_MEMORY_NEW(ctx.mem, Type_Selector, pstate, lexed);
+      return SASS_MEMORY_NEW(ctx.mem, Element_Selector, pstate, lexed);
     }
     else if (peek< pseudo_not >()) {
       return parse_negated_selector();
@@ -813,7 +838,7 @@ namespace Sass {
       return parse_attribute_selector();
     }
     else if (lex< placeholder >()) {
-      Selector_Placeholder* sel = SASS_MEMORY_NEW(ctx.mem, Selector_Placeholder, pstate, lexed);
+      Placeholder_Selector* sel = SASS_MEMORY_NEW(ctx.mem, Placeholder_Selector, pstate, lexed);
       sel->media_block(last_media_block);
       return sel;
     }
@@ -938,7 +963,6 @@ namespace Sass {
     }
     else if (lex< sequence< optional< exactly<'*'> >, identifier, zero_plus< block_comment > > >()) {
       prop = SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
-      prop->is_delayed(true);
     }
     else {
       css_error("Invalid CSS", " after ", ": expected \"}\", was ");
@@ -959,11 +983,11 @@ namespace Sass {
         if (lookahead.has_interpolants) {
           value = parse_value_schema(lookahead.found);
         } else {
-          value = parse_list();
+          value = parse_list(DELAYED);
         }
       }
       else {
-        value = parse_list();
+        value = parse_list(DELAYED);
         if (List* list = dynamic_cast<List*>(value)) {
           if (list->length() == 0 && !peek< exactly <'{'> >()) {
             css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
@@ -1022,7 +1046,7 @@ namespace Sass {
       if (peek_css< exactly<')'> >(position))
       { break; }
 
-      Expression* key = parse_list();
+      Expression* key = parse_space_list();
       if (String_Quoted* str = dynamic_cast<String_Quoted*>(key)) {
         if (!str->quote_mark() && !str->is_delayed()) {
           if (const Color* col = name_to_color(str->value())) {
@@ -1035,7 +1059,7 @@ namespace Sass {
       }
 
       if (!(lex< exactly<':'> >()))
-      { error("invalid syntax", pstate); }
+      { css_error("Invalid CSS", " after ", ": expected \":\", was "); }
 
       Expression* value = parse_space_list();
 
@@ -1052,14 +1076,13 @@ namespace Sass {
   // parse list returns either a space separated list,
   // a comma separated list or any bare expression found.
   // so to speak: we unwrap items from lists if possible here!
-  Expression* Parser::parse_list()
+  Expression* Parser::parse_list(bool delayed)
   {
-    // parse list is relly just an alias
-    return parse_comma_list();
+    return parse_comma_list(delayed);
   }
 
   // will return singletons unwrapped
-  Expression* Parser::parse_comma_list()
+  Expression* Parser::parse_comma_list(bool delayed)
   {
     // check if we have an empty list
     // return the empty list as such
@@ -1075,12 +1098,20 @@ namespace Sass {
           default_flag,
           global_flag
         > >(position))
-    { return SASS_MEMORY_NEW(ctx.mem, List, pstate, 0); }
+    {
+      // return an empty list (nothing to delay)
+      return SASS_MEMORY_NEW(ctx.mem, List, pstate, 0);
+    }
 
     // now try to parse a space list
     Expression* list = parse_space_list();
     // if it's a singleton, return it (don't wrap it)
-    if (!peek_css< exactly<','> >(position)) return list;
+    if (!peek_css< exactly<','> >(position)) {
+      // set_delay doesn't apply to list children
+      // so this will only undelay single values
+      if (!delayed) list->set_delayed(false);
+      return list;
+    }
 
     // if we got so far, we actually do have a comma list
     List* comma_list = SASS_MEMORY_NEW(ctx.mem, List, pstate, 2, SASS_COMMA);
@@ -1158,6 +1189,8 @@ namespace Sass {
   // parse logical OR operation
   Expression* Parser::parse_disjunction()
   {
+    advanceToNextToken();
+    ParserState state(pstate);
     // parse the left hand side conjunction
     Expression* conj = parse_conjunction();
     // parse multiple right hand sides
@@ -1167,13 +1200,18 @@ namespace Sass {
     // if it's a singleton, return it directly
     if (operands.size() == 0) return conj;
     // fold all operands into one binary expression
-    return fold_operands(conj, operands, { Sass_OP::OR });
+    Expression* ex = fold_operands(conj, operands, { Sass_OP::OR });
+    state.offset = pstate - state + pstate.offset;
+    ex->pstate(state);
+    return ex;
   }
   // EO parse_disjunction
 
   // parse logical AND operation
   Expression* Parser::parse_conjunction()
   {
+    advanceToNextToken();
+    ParserState state(pstate);
     // parse the left hand side relation
     Expression* rel = parse_relation();
     // parse multiple right hand sides
@@ -1183,13 +1221,18 @@ namespace Sass {
     // if it's a singleton, return it directly
     if (operands.size() == 0) return rel;
     // fold all operands into one binary expression
-    return fold_operands(rel, operands, { Sass_OP::AND });
+    Expression* ex = fold_operands(rel, operands, { Sass_OP::AND });
+    state.offset = pstate - state + pstate.offset;
+    ex->pstate(state);
+    return ex;
   }
   // EO parse_conjunction
 
   // parse comparison operations
   Expression* Parser::parse_relation()
   {
+    advanceToNextToken();
+    ParserState state(pstate);
     // parse the left hand side expression
     Expression* lhs = parse_expression();
     std::vector<Expression*> operands;
@@ -1222,8 +1265,15 @@ namespace Sass {
       operands.push_back(parse_expression());
       left_ws = peek < css_comments >() != NULL;
     }
-    // parse the operator
-    return fold_operands(lhs, operands, operators);
+    // we are called recursively for list, so we first
+    // fold inner binary expression which has delayed
+    // correctly set to zero. After folding we also unwrap
+    // single nested items. So we cannot set delay on the
+    // returned result here, as we have lost nestings ...
+    Expression* ex = fold_operands(lhs, operands, operators);
+    state.offset = pstate - state + pstate.offset;
+    ex->pstate(state);
+    return ex;
   }
   // parse_relation
 
@@ -1234,6 +1284,8 @@ namespace Sass {
   // parse addition and subtraction operations
   Expression* Parser::parse_expression()
   {
+    advanceToNextToken();
+    ParserState state(pstate);
     // parses multiple add and subtract operations
     // NOTE: make sure that identifiers starting with
     // NOTE: dashes do NOT count as subtract operation
@@ -1259,7 +1311,6 @@ namespace Sass {
 
     ) {
 
-
       bool right_ws = peek < css_comments >() != NULL;
       operators.push_back({ lexed.to_string() == "+" ? Sass_OP::ADD : Sass_OP::SUB, left_ws, right_ws });
       operands.push_back(parse_operators());
@@ -1267,12 +1318,17 @@ namespace Sass {
     }
 
     if (operands.size() == 0) return lhs;
-    return fold_operands(lhs, operands, operators);
+    Expression* ex = fold_operands(lhs, operands, operators);
+    state.offset = pstate - state + pstate.offset;
+    ex->pstate(state);
+    return ex;
   }
 
   // parse addition and subtraction operations
   Expression* Parser::parse_operators()
   {
+    advanceToNextToken();
+    ParserState state(pstate);
     Expression* factor = parse_factor();
     // if it's a singleton, return it (don't wrap it)
     std::vector<Expression*> operands; // factors
@@ -1291,7 +1347,10 @@ namespace Sass {
       left_ws = peek < css_comments >();
     }
     // operands and operators to binary expression
-    return fold_operands(factor, operands, operators);
+    Expression* ex = fold_operands(factor, operands, operators);
+    state.offset = pstate - state + pstate.offset;
+    ex->pstate(state);
+    return ex;
   }
   // EO parse_operators
 
@@ -1307,14 +1366,6 @@ namespace Sass {
       // lex the expected closing parenthesis
       if (!lex_css< exactly<')'> >()) error("unclosed parenthesis", pstate);
       // expression can be evaluated
-      // make sure wrapped lists and division expressions are non-delayed within parentheses
-      if (value->concrete_type() == Expression::LIST) {
-        // List* l = static_cast<List*>(value);
-        // if (!l->empty()) (*l)[0]->is_delayed(false);
-      } else if (typeid(*value) == typeid(Binary_Expression)) {
-        Binary_Expression* b = static_cast<Binary_Expression*>(value);
-        if (b && b->type() == Sass_OP::DIV) b->set_delayed(false);
-      }
       return value;
     }
     // string may be interpolated
@@ -1350,17 +1401,25 @@ namespace Sass {
       return parse_function_call();
     }
     else if (lex< exactly<'+'> >()) {
-      return SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::PLUS, parse_factor());
+      Unary_Expression* ex = SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::PLUS, parse_factor());
+      if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
+      return ex;
     }
     else if (lex< exactly<'-'> >()) {
-      return SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::MINUS, parse_factor());
+      Unary_Expression* ex = SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::MINUS, parse_factor());
+      if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
+      return ex;
     }
     else if (lex< sequence< kwd_not > >()) {
-      return SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::NOT, parse_factor());
+      Unary_Expression* ex = SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::NOT, parse_factor());
+      if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
+      return ex;
     }
     else if (peek < sequence < one_plus < alternatives < css_whitespace, exactly<'-'>, exactly<'+'> > >, number > >()) {
       if (parse_number_prefix()) return parse_value(); // prefix is positive
-      return SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::MINUS, parse_value());
+      Unary_Expression* ex = SASS_MEMORY_NEW(ctx.mem, Unary_Expression, pstate, Unary_Expression::MINUS, parse_value());;
+      if (ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
+      return ex;
     }
     else {
       return parse_value();
@@ -1455,7 +1514,6 @@ namespace Sass {
     if (!p) {
       String_Quoted* str_quoted = SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, std::string(i, chunk.end));
       if (!constant && str_quoted->quote_mark()) str_quoted->quote_mark('*');
-      str_quoted->is_delayed(true);
       return str_quoted;
     }
 
@@ -1510,11 +1568,13 @@ namespace Sass {
   {
     lex< static_value >();
     Token str(lexed);
+    // static values always have trailing white-
+    // space and end delimiter (\s*[;]$) included
+    -- pstate.offset.column;
     --str.end;
     --position;
 
     String_Constant* str_node = SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, str.time_wspace());
-    str_node->is_delayed(true);
     return str_node;
   }
 
@@ -1720,7 +1780,7 @@ namespace Sass {
         const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p+2, id.end); // find the closing brace
         if (j) {
           // parse the interpolant and accumulate it
-          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, pstate, source).parse_list();
+          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, pstate, source).parse_list(DELAYED);
           interp_node->is_interpolant(true);
           (*schema) << interp_node;
           // schema->has_interpolants(true);
@@ -1844,16 +1904,6 @@ namespace Sass {
 
   Content* Parser::parse_content_directive()
   {
-    bool missing_mixin_parent = true;
-    for (auto parent : stack) {
-      if (parent == Scope::Mixin) {
-        missing_mixin_parent = false;
-        break;
-      }
-    }
-    if (missing_mixin_parent) {
-      error("@content may only be used within a mixin", pstate);
-    }
     return SASS_MEMORY_NEW(ctx.mem, Content, pstate);
   }
 
@@ -1861,9 +1911,9 @@ namespace Sass {
   {
     stack.push_back(Scope::Control);
     ParserState if_source_position = pstate;
+    bool root = block_stack.back()->is_root();
     Expression* predicate = parse_list();
-    predicate->is_delayed(false);
-    Block* block = parse_block();
+    Block* block = parse_block(root);
     Block* alternative = 0;
 
     // only throw away comment if we parse a case
@@ -1873,7 +1923,7 @@ namespace Sass {
       (*alternative) << parse_if_directive(true);
     }
     else if (lex_css< kwd_else_directive >()) {
-      alternative = parse_block();
+      alternative = parse_block(root);
     }
     stack.pop_back();
     return SASS_MEMORY_NEW(ctx.mem, If, if_source_position, predicate, block, alternative);
@@ -1883,18 +1933,17 @@ namespace Sass {
   {
     stack.push_back(Scope::Control);
     ParserState for_source_position = pstate;
+    bool root = block_stack.back()->is_root();
     lex_variable();
     std::string var(Util::normalize_underscores(lexed));
     if (!lex< kwd_from >()) error("expected 'from' keyword in @for directive", pstate);
     Expression* lower_bound = parse_expression();
-    lower_bound->is_delayed(false);
     bool inclusive = false;
     if (lex< kwd_through >()) inclusive = true;
     else if (lex< kwd_to >()) inclusive = false;
     else                  error("expected 'through' or 'to' keyword in @for directive", pstate);
     Expression* upper_bound = parse_expression();
-    upper_bound->is_delayed(false);
-    Block* body = parse_block();
+    Block* body = parse_block(root);
     stack.pop_back();
     return SASS_MEMORY_NEW(ctx.mem, For, for_source_position, var, lower_bound, upper_bound, body, inclusive);
   }
@@ -1929,6 +1978,7 @@ namespace Sass {
   {
     stack.push_back(Scope::Control);
     ParserState each_source_position = pstate;
+    bool root = block_stack.back()->is_root();
     std::vector<std::string> vars;
     lex_variable();
     vars.push_back(Util::normalize_underscores(lexed));
@@ -1938,14 +1988,7 @@ namespace Sass {
     }
     if (!lex< kwd_in >()) error("expected 'in' keyword in @each directive", pstate);
     Expression* list = parse_list();
-    list->is_delayed(false);
-    if (list->concrete_type() == Expression::LIST) {
-      List* l = static_cast<List*>(list);
-      for (size_t i = 0, L = l->length(); i < L; ++i) {
-        (*l)[i]->is_delayed(false);
-      }
-    }
-    Block* body = parse_block();
+    Block* body = parse_block(root);
     stack.pop_back();
     return SASS_MEMORY_NEW(ctx.mem, Each, each_source_position, vars, list, body);
   }
@@ -1954,14 +1997,14 @@ namespace Sass {
   While* Parser::parse_while_directive()
   {
     stack.push_back(Scope::Control);
+    bool root = block_stack.back()->is_root();
     // create the initial while call object
     While* call = SASS_MEMORY_NEW(ctx.mem, While, pstate, 0, 0);
     // parse mandatory predicate
     Expression* predicate = parse_list();
-    predicate->is_delayed(false);
     call->predicate(predicate);
     // parse mandatory block
-    call->block(parse_block());
+    call->block(parse_block(root));
     // return ast node
     stack.pop_back();
     // return ast node
@@ -1985,22 +2028,22 @@ namespace Sass {
 
   List* Parser::parse_media_queries()
   {
+    advanceToNextToken();
     List* media_queries = SASS_MEMORY_NEW(ctx.mem, List, pstate, 0, SASS_COMMA);
     if (!peek_css < exactly <'{'> >()) (*media_queries) << parse_media_query();
     while (lex_css < exactly <','> >()) (*media_queries) << parse_media_query();
+    media_queries->update_pstate(pstate);
     return media_queries;
   }
 
   // Expression* Parser::parse_media_query()
   Media_Query* Parser::parse_media_query()
   {
+    advanceToNextToken();
     Media_Query* media_query = SASS_MEMORY_NEW(ctx.mem, Media_Query, pstate);
+    if (lex < kwd_not >()) { media_query->is_negated(true); lex < css_comments >(false); }
+    else if (lex < kwd_only >()) { media_query->is_restricted(true); lex < css_comments >(false); }
 
-    lex < css_comments >(false);
-    if (lex < kwd_not >()) media_query->is_negated(true);
-    else if (lex < kwd_only >()) media_query->is_restricted(true);
-
-    lex < css_comments >(false);
     if (lex < identifier_schema >())  media_query->media_type(parse_identifier_schema());
     else if (lex < identifier >())    media_query->media_type(parse_interpolated_chunk(lexed));
     else                             (*media_query) << parse_media_expression();
@@ -2014,6 +2057,9 @@ namespace Sass {
       media_query->media_type(schema);
     }
     while (lex_css < kwd_and >()) (*media_query) << parse_media_expression();
+
+    media_query->update_pstate(pstate);
+
     return media_query;
   }
 
@@ -2033,7 +2079,7 @@ namespace Sass {
     feature = parse_expression();
     Expression* expression = 0;
     if (lex_css< exactly<':'> >()) {
-      expression = parse_list();
+      expression = parse_list(DELAYED);
     }
     if (!lex_css< exactly<')'> >()) {
       error("unclosed parenthesis in media query expression", pstate);
@@ -2252,13 +2298,9 @@ namespace Sass {
     Directive* directive = SASS_MEMORY_NEW(ctx.mem, Directive, pstate, lexed);
     Expression* val = parse_almost_any_value();
     // strip left and right if they are of type string
-    // debug_ast(val);
-    // std::cerr << "HAASDASD\n";
     directive->value(val);
     if (peek< exactly<'{'> >()) {
       directive->block(parse_block());
-    } else if (!val) {
-      css_error("most def");
     }
     return directive;
   }
@@ -2386,7 +2428,7 @@ namespace Sass {
         stack.back() != Scope::Rules) {
       error("Illegal nesting: Only properties may be nested beneath properties.", pstate);
     }
-    return SASS_MEMORY_NEW(ctx.mem, Warning, pstate, parse_list());
+    return SASS_MEMORY_NEW(ctx.mem, Warning, pstate, parse_list(DELAYED));
   }
 
   Error* Parser::parse_error()
@@ -2398,7 +2440,7 @@ namespace Sass {
         stack.back() != Scope::Rules) {
       error("Illegal nesting: Only properties may be nested beneath properties.", pstate);
     }
-    return SASS_MEMORY_NEW(ctx.mem, Error, pstate, parse_list());
+    return SASS_MEMORY_NEW(ctx.mem, Error, pstate, parse_list(DELAYED));
   }
 
   Debug* Parser::parse_debug()
@@ -2410,7 +2452,7 @@ namespace Sass {
         stack.back() != Scope::Rules) {
       error("Illegal nesting: Only properties may be nested beneath properties.", pstate);
     }
-    return SASS_MEMORY_NEW(ctx.mem, Debug, pstate, parse_list());
+    return SASS_MEMORY_NEW(ctx.mem, Debug, pstate, parse_list(DELAYED));
   }
 
   Return* Parser::parse_return_directive()
@@ -2623,22 +2665,13 @@ namespace Sass {
   Expression* Parser::fold_operands(Expression* base, std::vector<Expression*>& operands, Operand op)
   {
     for (size_t i = 0, S = operands.size(); i < S; ++i) {
-      base = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, pstate, op, base, operands[i]);
-      Binary_Expression* b = static_cast<Binary_Expression*>(base);
-      if (op.operand == Sass_OP::DIV && b->left()->is_delayed() && b->right()->is_delayed()) {
-        base->is_delayed(true);
-      }
-      else if (b && b->op().operand != Sass_OP::DIV) {
-        b->left()->is_delayed(false);
-        b->right()->is_delayed(false);
-      }
+      base = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, base->pstate(), op, base, operands[i]);
     }
     return base;
   }
 
   Expression* Parser::fold_operands(Expression* base, std::vector<Expression*>& operands, std::vector<Operand>& ops, size_t i)
   {
-
     if (String_Schema* schema = dynamic_cast<String_Schema*>(base)) {
       // return schema;
       if (schema->has_interpolants()) {
@@ -2653,10 +2686,8 @@ namespace Sass {
           || (ops[0].operand == Sass_OP::LTE)
           || (ops[0].operand == Sass_OP::GTE)
         )) {
-          Expression* rhs = fold_operands(operands[0], operands, ops, 1);
+          Expression* rhs = fold_operands(operands[i], operands, ops, i + 1);
           rhs = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, base->pstate(), ops[0], schema, rhs);
-          rhs->set_delayed(false);
-          rhs->is_delayed(true);
           return rhs;
         }
         // return schema;
@@ -2670,12 +2701,9 @@ namespace Sass {
             Expression* rhs = fold_operands(operands[i+1], operands, ops, i + 2);
             rhs = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, base->pstate(), ops[i], schema, rhs);
             base = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, base->pstate(), ops[i], base, rhs);
-            rhs->is_delayed(true);
-            base->is_delayed(true);
             return base;
           }
           base = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, base->pstate(), ops[i], base, operands[i]);
-          if (ops[i].operand != Sass_OP::DIV) base->is_delayed(true);
           return base;
         } else {
           base = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, base->pstate(), ops[i], base, operands[i]);
@@ -2687,11 +2715,11 @@ namespace Sass {
       if (b && ops[i].operand == Sass_OP::DIV && b->left()->is_delayed() && b->right()->is_delayed()) {
         base->is_delayed(true);
       }
-      else if (b) {
-        b->left()->is_delayed(false);
-        b->right()->is_delayed(false);
-      }
-
+    }
+    // nested binary expression are never to be delayed
+    if (Binary_Expression* b = dynamic_cast<Binary_Expression*>(base)) {
+      if (dynamic_cast<Binary_Expression*>(b->left())) base->set_delayed(false);
+      if (dynamic_cast<Binary_Expression*>(b->right())) base->set_delayed(false);
     }
     return base;
   }