Heavily improve wrapped pseudo selector handling

Author: mgreter

src/context.cpp

@@ -664,6 +664,7 @@ namespace Sass {
     if (!subset_map.empty()) {
       // create crtp visitor object
       Extend extend(subset_map);
+      extend.setEval(expand.eval);
       // extend tree nodes
       extend(root);
     }

src/environment.cpp

@@ -219,7 +219,7 @@ namespace Sass {
     }
     return get_local(key);
   }
-
+/*
   #ifdef DEBUG
   template <typename T>
   size_t Environment<T>::print(std::string prefix)
@@ -238,7 +238,7 @@ namespace Sass {
     return indent ;
   }
   #endif
-
+*/
   // compile implementation for AST_Node
   template class Environment<AST_Node_Obj>;
 

src/eval.cpp

@@ -1763,9 +1763,27 @@ namespace Sass {
     if (is_in_selector_schema) exp.selector_stack.push_back(0);
     Selector_List_Obj resolved = s->resolve_parent_refs(exp.selector_stack, implicit_parent);
     if (is_in_selector_schema) exp.selector_stack.pop_back();
+    for (size_t i = 0; i < resolved->length(); i++) {
+      Complex_Selector_Ptr is = resolved->at(i)->first();
+      while (is) {
+        if (is->head()) {
+          is->head()->perform(this);
+        }
+        is = is->tail();
+      }
+    }
     return resolved.detach();
   }
 
+  Compound_Selector_Ptr Eval::operator()(Compound_Selector_Ptr s)
+  {
+    for (size_t i = 0; i < s->length(); i++) {
+      Simple_Selector_Ptr ss = s->at(i);
+      if (ss) ss->perform(this);
+    }
+    return s;
+  }
+
   // XXX: this is never hit via spec tests
   Attribute_Selector_Ptr Eval::operator()(Attribute_Selector_Ptr s)
   {
@@ -1821,4 +1839,39 @@ namespace Sass {
     }
   }
 
+  // hotfix to avoid invalid nested `:not` selectors
+  // probably the wrong place, but this should ultimately
+  // be fixed by implement superselector correctly for `:not`
+  // first use of "find" (ATM only implemented for selectors)
+  bool hasNotSelector(AST_Node_Obj obj) {
+    if (Wrapped_Selector_Ptr w = Cast<Wrapped_Selector>(obj)) {
+      return w->name() == ":not";
+    }
+    return false;
+  }
+
+  Wrapped_Selector_Ptr Eval::operator()(Wrapped_Selector_Ptr s)
+  {
+
+    if (s->name() == ":not") {
+      if (exp.selector_stack.back()) {
+        if (s->selector()->find(hasNotSelector)) {
+          s->selector()->clear();
+          s->name(" ");
+        } else if (s->selector()->length() == 1) {
+          Complex_Selector_Ptr cs = s->selector()->at(0);
+          if (cs->tail()) {
+            s->selector()->clear();
+            s->name(" ");
+          }
+        } else if (s->selector()->length() > 1) {
+          s->selector()->clear();
+          s->name(" ");
+        }
+      }
+    }
+
+    return s;
+  };
+
 }

src/eval.hpp

@@ -75,11 +75,12 @@ namespace Sass {
     // these will return selectors
     Selector_List_Ptr operator()(Selector_List_Ptr);
     Selector_List_Ptr operator()(Complex_Selector_Ptr);
+    Compound_Selector_Ptr operator()(Compound_Selector_Ptr);
     Attribute_Selector_Ptr operator()(Attribute_Selector_Ptr);
     // they don't have any specific implementatio (yet)
     Element_Selector_Ptr operator()(Element_Selector_Ptr s) { return s; };
     Pseudo_Selector_Ptr operator()(Pseudo_Selector_Ptr s) { return s; };
-    Wrapped_Selector_Ptr operator()(Wrapped_Selector_Ptr s) { return s; };
+    Wrapped_Selector_Ptr operator()(Wrapped_Selector_Ptr s);
     Class_Selector_Ptr operator()(Class_Selector_Ptr s) { return s; };
     Id_Selector_Ptr operator()(Id_Selector_Ptr s) { return s; };
     Placeholder_Selector_Ptr operator()(Placeholder_Selector_Ptr s) { return s; };

src/extend.cpp

@@ -4,6 +4,7 @@
 #include "backtrace.hpp"
 #include "paths.hpp"
 #include "parser.hpp"
+#include "expand.hpp"
 #include "node.hpp"
 #include "sass_util.hpp"
 #include "remove_placeholders.hpp"
@@ -1475,6 +1476,13 @@ namespace Sass {
           toPush.plus(seqs);
           toPush.plus(last_current);
 
+          // move line feed from inner to outer selector (very hacky indeed)
+          if (last_current.collection() && last_current.collection()->front().selector()) {
+            toPush.got_line_feed = last_current.collection()->front().got_line_feed;
+            last_current.collection()->front().selector()->has_line_feed(false);
+            last_current.collection()->front().got_line_feed = false;
+          }
+
           tempResult.collection()->push_back(toPush);
 
         }
@@ -1786,7 +1794,7 @@ namespace Sass {
         ComplexSelectorSet srcset;
         srcset.insert(selector);
         sseqSel->addSources(srcset);
-        DEBUG_PRINTLN(EXTEND_COMPLEX, "ADD SOURCES: " << *pComplexSelector)
+        // DEBUG_PRINTLN(EXTEND_COMPLEX, "ADD SOURCES: " << *pComplexSelector)
       }
 
       bool isSuperselector = false;
@@ -1940,7 +1948,8 @@ namespace Sass {
                 // has wrapped not selectors
                 else if (ws->name() == ":not") {
                   // extend the inner list of wrapped selector
-                  Selector_List_Obj ext_sl = extendSelectorList(sl, recseen);
+                  bool extended = false;
+                  Selector_List_Obj ext_sl = extendSelectorList(sl, false, extended, recseen);
                   for (size_t i = 0; i < ext_sl->length(); i += 1) {
                     if (Complex_Selector_Obj ext_cs = ext_sl->at(i)) {
                       // create clones for wrapped selector and the inner list
@@ -1950,18 +1959,6 @@ namespace Sass {
                       Compound_Selector_Obj ext_head = NULL;
                       if (ext_cs->first()) ext_head = ext_cs->first()->head();
                       if (ext_head && ext_head && ext_head->length() > 0) {
-                        Wrapped_Selector_Ptr ext_ws = Cast<Wrapped_Selector>(ext_head->first());
-                        if (ext_ws/* && ext_cs->length() == 1*/) {
-                          Selector_List_Obj ws_cs = Cast<Selector_List>(ext_ws->selector());
-                          if (ws_cs && !ws_cs->empty() && ws_cs->first()) {
-                            Compound_Selector_Obj ws_ss = ws_cs->first()->head();
-                            if (ws_ss && !ws_ss->empty() && !(
-                              Cast<Pseudo_Selector>(ws_ss->first()) ||
-                              Cast<Element_Selector>(ws_ss->first()) ||
-                              Cast<Placeholder_Selector>(ws_ss->first())
-                            )) continue;
-                          }
-                        }
                         cpy_ws_sl->append(ext_cs->first());
                       }
                       // assign list to clone
@@ -1970,6 +1967,11 @@ namespace Sass {
                       cpy_head->append(cpy_ws);
                     }
                   }
+                  if (eval && extended) {
+                    eval->exp.selector_stack.push_back(pNewSelectors);
+                    cpy_head->perform(eval);
+                    eval->exp.selector_stack.pop_back();
+                  }
                 }
                 // has wrapped selectors
                 else {
@@ -2066,9 +2068,13 @@ namespace Sass {
   }
 
   Extend::Extend(Subset_Map& ssm)
-  : subset_map(ssm)
+  : subset_map(ssm), eval(NULL)
   { }
 
+  void Extend::setEval(Eval& e) {
+    eval = &e;
+  }
+
   void Extend::operator()(Block_Ptr b)
   {
     for (size_t i = 0, L = b->length(); i < L; ++i) {

src/extend.hpp

@@ -6,6 +6,7 @@
 
 #include "ast.hpp"
 #include "node.hpp"
+#include "eval.hpp"
 #include "operation.hpp"
 #include "subset_map.hpp"
 #include "ast_fwd_decl.hpp"
@@ -17,6 +18,7 @@ namespace Sass {
   class Extend : public Operation_CRTP<void, Extend> {
 
     Subset_Map& subset_map;
+    Eval* eval;
 
     void fallback_impl(AST_Node_Ptr n) { }
 
@@ -54,6 +56,7 @@ namespace Sass {
     Node weave(Node& path);
 
   public:
+    void setEval(Eval& eval);
     Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, bool isReplace, bool& extendedSomething, CompoundSelectorSet& seen);
     Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, bool isReplace = false) {
       bool extendedSomething = false;

src/inspect.cpp

@@ -939,20 +939,11 @@ namespace Sass {
     }
   }
 
-  // hotfix to avoid invalid nested `:not` selectors
-  // probably the wrong place, but this should ultimatively
-  // be fixed by implement superselector correctly for `:not`
-  // first use of "find" (ATM only implemented for selectors)
-  bool hasNotSelector(AST_Node_Obj obj) {
-    if (Wrapped_Selector_Ptr w = Cast<Wrapped_Selector>(obj)) {
-      return w->name() == ":not";
-    }
-    return false;
-  }
-
   void Inspect::operator()(Wrapped_Selector_Ptr s)
   {
-    if (!s->selector()->find(hasNotSelector)) {
+    if (s->name() == " ") {
+      append_string("");
+    } else {
       bool was = in_wrapped;
       in_wrapped = true;
       append_token(s->name(), s);

src/node.cpp

@@ -191,13 +191,15 @@ namespace Sass {
 
       bool empty_parent_ref = pToConvert->head() && pToConvert->head()->is_empty_reference();
 
-      if (pToConvert->head() || empty_parent_ref) {
-      }
-
       // the first Complex_Selector may contain a dummy head pointer, skip it.
       if (pToConvert->head() && !empty_parent_ref) {
         node.collection()->push_back(Node::createSelector(*pToConvert));
         if (has_lf) node.collection()->back().got_line_feed = has_lf;
+        if (pToConvert->head() || empty_parent_ref) {
+          if (pToConvert->tail()) {
+            pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());
+          }
+        }
         has_lf = false;
       }