Merge pull request #1527 from mgreter/bugfix/parent-selector-segfaults

Fix two segfaults with parent selectors

Author: mgreter

src/ast.cpp

@@ -1125,13 +1125,18 @@ namespace Sass {
     // Check every rhs selector against left hand list
     for(size_t i = 0, L = length(); i < L; ++i) {
       if (!(*this)[i]->head()) continue;
-      if ((*this)[i]->combinator() != Complex_Selector::ANCESTOR_OF) continue;
       if ((*this)[i]->head()->is_empty_reference()) {
-        Complex_Selector* tail = (*this)[i]->tail();
-        // if ((*this)[i]->has_line_feed()) {
-          // if (tail) tail->has_line_feed(true);
-        // }
-        (*this)[i] = tail;
+        // simply move to the next tail if we have "no" combinator
+        if ((*this)[i]->combinator() == Complex_Selector::ANCESTOR_OF) {
+          if ((*this)[i]->tail() && (*this)[i]->has_line_feed()) {
+            (*this)[i]->tail()->has_line_feed(true);
+          }
+          (*this)[i] = (*this)[i]->tail();
+        }
+        // otherwise remove the first item from head
+        else {
+          (*this)[i]->head()->erase((*this)[i]->head()->begin());
+        }
       }
     }
   }

src/ast.hpp

@@ -405,9 +405,10 @@ namespace Sass {
   class Ruleset : public Has_Block {
     ADD_PROPERTY(Selector*, selector)
     ADD_PROPERTY(bool, at_root);
+    ADD_PROPERTY(bool, is_root);
   public:
     Ruleset(ParserState pstate, Selector* s = 0, Block* b = 0)
-    : Has_Block(pstate, b), selector_(s), at_root_(false)
+    : Has_Block(pstate, b), selector_(s), at_root_(false), is_root_(false)
     { statement_type(RULESET); }
     bool is_invisible() const;
     // nested rulesets need to be hoisted out of their enclosing blocks

src/debugger.hpp

@@ -394,6 +394,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " [indent: " << ruleset->tabs() << "]";
     std::cerr << (ruleset->at_root() ? " [@ROOT]" : "");
+    std::cerr << (ruleset->is_root() ? " [root]" : "");
     std::cerr << std::endl;
     debug_ast(ruleset->selector(), ind + ">");
     debug_ast(ruleset->block(), ind + " ");

src/expand.cpp

@@ -97,6 +97,23 @@ namespace Sass {
       return k;
     }
 
+    // do some special checks for the base level rules
+    if (r->is_root()) {
+      if (Selector_List* selector_list = dynamic_cast<Selector_List*>(r->selector())) {
+        for (Complex_Selector* complex_selector : selector_list->elements()) {
+          Complex_Selector* tail = complex_selector;
+          while (tail) {
+            if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
+              if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
+              To_String to_string(&ctx); std::string sel_str(complex_selector->perform(&to_string));
+              error("Base-level rules cannot contain the parent-selector-referencing character '&'.", header->pstate(), backtrace());
+            }
+            tail = tail->tail();
+          }
+        }
+      }
+    }
+
     Expression* ex = r->selector()->perform(&eval);
     Selector_List* sel = dynamic_cast<Selector_List*>(ex);
     if (sel == 0) throw std::runtime_error("Expanded null selector");
@@ -499,21 +516,34 @@ namespace Sass {
   Statement* Expand::operator()(Extension* e)
   {
     To_String to_string(&ctx);
-    Selector_List* extender = static_cast<Selector_List*>(selector());
+    Selector_List* extender = dynamic_cast<Selector_List*>(selector());
     if (!extender) return 0;
     selector_stack.push_back(0);
-    // extender->remove_parent_selectors();
 
-    Selector_List* selector_list = static_cast<Selector_List*>(e->selector());
-    Selector_List* contextualized = static_cast<Selector_List*>(selector_list->perform(&eval));
-    // contextualized->remove_parent_selectors();
+    if (Selector_List* selector_list = dynamic_cast<Selector_List*>(e->selector())) {
+      for (Complex_Selector* complex_selector : selector_list->elements()) {
+        Complex_Selector* tail = complex_selector;
+        while (tail) {
+          if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
+            if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
+            To_String to_string(&ctx); std::string sel_str(complex_selector->perform(&to_string));
+            error("Can't extend " + sel_str + ": can't extend parent selectors", header->pstate(), backtrace());
+          }
+          tail = tail->tail();
+        }
+      }
+    }
+
+    Selector_List* contextualized = dynamic_cast<Selector_List*>(e->selector()->perform(&eval));
+    if (contextualized == NULL) return 0;
     for (auto complex_sel : contextualized->elements()) {
       Complex_Selector* c = complex_sel;
       if (!c->head() || c->tail()) {
-        error("nested selectors may not be extended", c->pstate(), backtrace());
+        To_String to_string(&ctx); std::string sel_str(contextualized->perform(&to_string));
+        error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
       }
       Compound_Selector* placeholder = c->head();
-      placeholder->is_optional(selector_list->is_optional());
+      placeholder->is_optional(e->selector()->is_optional());
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
         Complex_Selector* sel = (*extender)[i];
         if (!(sel->head() && sel->head()->length() > 0 &&
@@ -531,6 +561,7 @@ namespace Sass {
         ctx.subset_map.put(placeholder->to_str_vec(), std::make_pair(sel, placeholder));
       }
     }
+
     selector_stack.pop_back();
 
     return 0;

src/extend.cpp

@@ -2023,6 +2023,7 @@ namespace Sass {
     if (extendedSomething && pNewSelectorList) {
       DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND ORIGINAL SELECTORS: " << static_cast<Selector_List*>(pObject->selector())->perform(&to_string))
       DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND SETTING NEW SELECTORS: " << pNewSelectorList->perform(&to_string))
+      pNewSelectorList->remove_parent_selectors();
       pObject->selector(pNewSelectorList);
     } else {
       DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND DID NOT TRY TO EXTEND ANYTHING")

src/inspect.cpp

@@ -768,7 +768,7 @@ namespace Sass {
       }
     }
 
-    if (head && !head->is_empty_reference()) head->perform(this);
+    if (head && head->length() != 0) head->perform(this);
     bool is_empty = !head || head->length() == 0 || head->is_empty_reference();
     bool is_tail = head && !head->is_empty_reference() && tail;
     if (output_style() == COMPRESSED && comb != Complex_Selector::ANCESTOR_OF) scheduled_space = 0;

src/parser.cpp

@@ -48,7 +48,7 @@ namespace Sass {
     Parser p = Parser::from_c_str(src, ctx, pstate);
     // ToDo: ruby sass errors on parent references
     // ToDo: remap the source-map entries somehow
-    return p.parse_selector_list();
+    return p.parse_selector_list(false);
   }
 
   bool Parser::peek_newline(const char* start)
@@ -72,10 +72,12 @@ namespace Sass {
   /* main entry point to parse root block */
   Block* Parser::parse()
   {
+    bool is_root = false;
     Block* root = SASS_MEMORY_NEW(ctx.mem, Block, pstate, 0, true);
     read_bom();
 
     if (ctx.queue.size() == 1) {
+      is_root = true;
       Import* pre = SASS_MEMORY_NEW(ctx.mem, Import, pstate);
       std::string load_path(ctx.queue[0].load_path);
       do_import(load_path, pre, ctx.c_headers, false);
@@ -89,7 +91,7 @@ namespace Sass {
     }
 
     block_stack.push_back(root);
-    /* bool rv = */ parse_block_nodes();
+    /* bool rv = */ parse_block_nodes(is_root);
     block_stack.pop_back();
 
     // update for end position
@@ -147,7 +149,7 @@ namespace Sass {
 
   // the main block parsing function
   // parses stuff between `{` and `}`
-  bool Parser::parse_block_nodes()
+  bool Parser::parse_block_nodes(bool is_root)
   {
 
     // loop until end of string
@@ -161,7 +163,7 @@ namespace Sass {
       if (peek < end_of_file >()) return true;
       if (peek < exactly<'}'> >()) return true;
 
-      if (parse_block_node()) continue;
+      if (parse_block_node(is_root)) continue;
 
       parse_block_comments();
 
@@ -178,7 +180,7 @@ namespace Sass {
 
   // parser for a single node in a block
   // semicolons must be lexed beforehand
-  bool Parser::parse_block_node() {
+  bool Parser::parse_block_node(bool is_root) {
 
     Block* block = block_stack.back();
 
@@ -237,13 +239,13 @@ namespace Sass {
       if (!lookahead.found) css_error("Invalid CSS", " after ", ": expected selector, was ");
       Selector* target;
       if (lookahead.has_interpolants) target = parse_selector_schema(lookahead.found);
-      else                            target = parse_selector_list();
+      else                            target = parse_selector_list(true);
       (*block) << SASS_MEMORY_NEW(ctx.mem, Extension, pstate, target);
     }
 
     // selector may contain interpolations which need delayed evaluation
     else if (!(lookahead_result = lookahead_for_selector(position)).error)
-    { (*block) << parse_ruleset(lookahead_result); }
+    { (*block) << parse_ruleset(lookahead_result, is_root); }
 
     // parse multiple specific keyword directives
     else if (lex < kwd_media >(true)) { (*block) << parse_media_block(); }
@@ -566,19 +568,22 @@ namespace Sass {
   }
 
   // a ruleset connects a selector and a block
-  Ruleset* Parser::parse_ruleset(Lookahead lookahead)
+  Ruleset* Parser::parse_ruleset(Lookahead lookahead, bool is_root)
   {
     // make sure to move up the the last position
     lex < optional_css_whitespace >(false, true);
     // create the connector object (add parts later)
     Ruleset* ruleset = SASS_MEMORY_NEW(ctx.mem, Ruleset, pstate);
     // parse selector static or as schema to be evaluated later
-    if (lookahead.parsable) ruleset->selector(parse_selector_list());
+    if (lookahead.parsable) ruleset->selector(parse_selector_list(is_root));
     else ruleset->selector(parse_selector_schema(lookahead.found));
     // then parse the inner block
     ruleset->block(parse_block());
     // update for end position
     ruleset->update_pstate(pstate);
+    // inherit is_root from parent block
+    // need this info for sanity checks
+    ruleset->is_root(is_root);
     // return AST Node
     return ruleset;
   }
@@ -768,7 +773,7 @@ namespace Sass {
     // check if we got the abort condition (ToDo: optimize)
     if (!peek_css< class_char < complex_selector_delims > >()) {
       // parse next selector in sequence
-      sel->tail(parse_complex_selector());
+      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);
@@ -889,7 +894,7 @@ namespace Sass {
     lex< pseudo_not >();
     std::string name(lexed);
     ParserState nsource_position = pstate;
-    Selector* negated = parse_selector_list();
+    Selector* negated = parse_selector_list(true);
     if (!lex< exactly<')'> >()) {
       error("negated selector is missing ')'", pstate);
     }
@@ -933,7 +938,7 @@ namespace Sass {
           return SASS_MEMORY_NEW(ctx.mem, Pseudo_Selector, p, name, expr);
         }
       }
-      else if (Selector* wrapped = parse_selector_list()) {
+      else if (Selector* wrapped = parse_selector_list(true)) {
         if (wrapped && lex_css< exactly<')'> >()) {
           return SASS_MEMORY_NEW(ctx.mem, Wrapped_Selector, p, name, wrapped);
         }
@@ -2066,7 +2071,7 @@ namespace Sass {
       body = parse_block(true);
     }
     else if ((lookahead_result = lookahead_for_selector(position)).found) {
-      Ruleset* r = parse_ruleset(lookahead_result);
+      Ruleset* r = parse_ruleset(lookahead_result, false);
       body = SASS_MEMORY_NEW(ctx.mem, Block, r->pstate(), 1, true);
       *body << r;
     }
@@ -2105,7 +2110,7 @@ namespace Sass {
     At_Rule* at_rule = SASS_MEMORY_NEW(ctx.mem, At_Rule, pstate, kwd);
     Lookahead lookahead = lookahead_for_include(position);
     if (lookahead.found && !lookahead.has_interpolants) {
-      at_rule->selector(parse_selector_list());
+      at_rule->selector(parse_selector_list(true));
     }
 
     lex < css_comments >(false);

src/parser.hpp

@@ -223,7 +223,7 @@ namespace Sass {
     Argument* parse_argument(bool has_url = false);
     Assignment* parse_assignment();
     // Propset* parse_propset();
-    Ruleset* parse_ruleset(Lookahead lookahead);
+    Ruleset* parse_ruleset(Lookahead lookahead, bool is_root = false);
     Selector_Schema* parse_selector_schema(const char* end_of_selector);
     Selector_List* parse_selector_list(bool at_root = false);
     Complex_Selector* parse_complex_selector(bool in_root = true);
@@ -234,8 +234,8 @@ namespace Sass {
     Attribute_Selector* parse_attribute_selector();
     Block* parse_block(bool is_root = false);
     Block* parse_css_block(bool is_root = false);
-    bool parse_block_nodes();
-    bool parse_block_node();
+    bool parse_block_nodes(bool is_root = false);
+    bool parse_block_node(bool is_root = false);
 
     bool parse_number_prefix();
     Declaration* parse_declaration();