Handle fake parent selectors when evaling

LibSass fully parses selectors during the parsing stage. This is
different from Ruby Sass which parse selectors and string during
the parsing stage, and lazily eval'ing when required. This
difference causes some pathological selector issues. Our eager
parsing of selectors has resulted in us hacking in fake
`Parent_Selector` into `Sequence_Selector` during parsing.

These fake `Parent_Selector` play havoc with `resolve_parent_refs`
when within `@at-root` blocks. I spent a couple weeks going down
the rabbit whole of refactoring our selector parsing to be lazy before
bailing.

Explicitly marking which `Parent_Selector` are fake during parsing
allows us faithfully implement the `implicit_parent` flag in
`resolve_parent_refs`.

Fixes #2006
Fixes #2198
Spec sass/sass-spec#936

Author: xzyfer

src/ast.cpp

@@ -157,12 +157,26 @@ namespace Sass {
     return false;
   }
 
+  bool SimpleSequence_Selector::has_real_parent_ref()
+  {
+    for (Simple_Selector* s : *this) {
+      if (s && s->has_real_parent_ref()) return true;
+    }
+    return false;
+  }
+
   bool Sequence_Selector::has_parent_ref()
   {
     return (head() && head()->has_parent_ref()) ||
            (tail() && tail()->has_parent_ref());
   }
 
+  bool Sequence_Selector::has_real_parent_ref()
+  {
+    return (head() && head()->has_real_parent_ref()) ||
+           (tail() && tail()->has_real_parent_ref());
+  }
+
   bool Sequence_Selector::operator< (const Sequence_Selector& rhs) const
   {
     // const iterators for tails
@@ -1110,6 +1124,12 @@ namespace Sass {
     Sequence_Selector* tail = this->tail();
     SimpleSequence_Selector* head = this->head();
 
+    if (!this->has_real_parent_ref() && !implicit_parent) {
+      CommaSequence_Selector* retval = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pstate());
+      *retval << this;
+      return retval;
+    }
+
     // first resolve_parent_refs the tail (which may return an expanded list)
     CommaSequence_Selector* tails = tail ? tail->resolve_parent_refs(ctx, parents, implicit_parent) : 0;
 
@@ -1396,6 +1416,14 @@ namespace Sass {
     return false;
   }
 
+  bool CommaSequence_Selector::has_real_parent_ref()
+  {
+    for (Sequence_Selector* s : *this) {
+      if (s && s->has_real_parent_ref()) return true;
+    }
+    return false;
+  }
+
   bool Selector_Schema::has_parent_ref()
   {
     if (String_Schema* schema = dynamic_cast<String_Schema*>(contents())) {
@@ -1404,6 +1432,15 @@ namespace Sass {
     return false;
   }
 
+  bool Selector_Schema::has_real_parent_ref()
+  {
+    if (String_Schema* schema = dynamic_cast<String_Schema*>(contents())) {
+      Parent_Selector* p = dynamic_cast<Parent_Selector*>(schema->at(0));
+      return schema->length() > 0 && p != NULL && p->is_real_parent_ref();
+    }
+    return false;
+  }
+
   void CommaSequence_Selector::adjust_after_pushing(Sequence_Selector* c)
   {
     // if (c->has_reference())   has_reference(true);

src/ast.hpp

@@ -1897,6 +1897,9 @@ namespace Sass {
     virtual bool has_parent_ref() {
       return false;
     }
+    virtual bool has_real_parent_ref() {
+      return false;
+    }
   };
   inline Selector::~Selector() { }
 
@@ -1912,6 +1915,7 @@ namespace Sass {
     : Selector(pstate), contents_(c), at_root_(false)
     { }
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
     virtual size_t hash() {
       if (hash_ == 0) {
         hash_combine(hash_, contents_->hash());
@@ -1990,6 +1994,7 @@ namespace Sass {
     virtual ~Simple_Selector() = 0;
     virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
     virtual bool has_parent_ref() { return false; };
+    virtual bool has_real_parent_ref() { return false; };
     virtual bool is_pseudo_element() { return false; }
     virtual bool is_pseudo_class() { return false; }
 
@@ -2012,11 +2017,14 @@ namespace Sass {
   // inside strings in declarations (SimpleSequence_Selector).
   // only one simple parent selector means the first case.
   class Parent_Selector : public Simple_Selector {
+    ADD_PROPERTY(bool, real)
   public:
-    Parent_Selector(ParserState pstate)
-    : Simple_Selector(pstate, "&")
+    Parent_Selector(ParserState pstate, bool r = true)
+    : Simple_Selector(pstate, "&"), real_(r)
     { /* has_reference(true); */ }
+    bool is_real_parent_ref() { return real(); };
     virtual bool has_parent_ref() { return true; };
+    virtual bool has_real_parent_ref() { return is_real_parent_ref(); };
     virtual unsigned long specificity()
     {
       return 0;
@@ -2225,6 +2233,11 @@ namespace Sass {
       if (!selector()) return false;
       return selector()->has_parent_ref();
     }
+    virtual bool has_real_parent_ref() {
+      // if (has_reference()) return true;
+      if (!selector()) return false;
+      return selector()->has_real_parent_ref();
+    }
     virtual bool has_wrapped_selector()
     {
       return true;
@@ -2283,6 +2296,7 @@ namespace Sass {
     SimpleSequence_Selector* unify_with(SimpleSequence_Selector* rhs, Context& ctx);
     // virtual Placeholder_Selector* find_placeholder();
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
     Simple_Selector* base()
     {
       // Implement non-const in terms of const. Safe to const_cast since this method is non-const
@@ -2387,6 +2401,7 @@ namespace Sass {
       // if ((h && h->has_placeholder()) || (t && t->has_placeholder())) has_placeholder(true);
     }
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
 
     Sequence_Selector* skip_empty_reference()
     {
@@ -2429,7 +2444,7 @@ namespace Sass {
     Sequence_Selector* innermost() { return last(); };
 
     size_t length() const;
-    CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent);
+    CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent = true);
     virtual bool is_superselector_of(SimpleSequence_Selector* sub, std::string wrapping = "");
     virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapping = "");
     virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapping = "");
@@ -2545,6 +2560,7 @@ namespace Sass {
     // remove parent selector references
     // basically unwraps parsed selectors
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
     void remove_parent_selectors();
     // virtual Placeholder_Selector* find_placeholder();
     CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent = true);

src/debugger.hpp

@@ -107,6 +107,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
 //    if (selector->not_selector()) cerr << " [in_declaration]";
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
+    std::cerr << " [" << (selector->is_real_parent_ref() ? "REAL" : "FAKE") << "]";
     std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
 //    debug_ast(selector->selector(), ind + "->", env);
 

src/inspect.cpp

@@ -876,7 +876,7 @@ namespace Sass {
 
   void Inspect::operator()(Parent_Selector* p)
   {
-    append_string("&");
+    if (p->is_real_parent_ref()) append_string("&");
   }
 
   void Inspect::operator()(Placeholder_Selector* s)

src/parser.cpp

@@ -703,7 +703,7 @@ namespace Sass {
     // 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);
+      Parent_Selector* parent = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, pstate, false);
       parent->media_block(last_media_block);
       SimpleSequence_Selector* head = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, pstate);
       head->media_block(last_media_block);