Rename Complex_Selector AST node to Sequence_Selector

This better matches the Ruby Sass implementation.

Author: xzyfer

src/ast.cpp

@@ -2224,15 +2224,15 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  struct Complex_Selector_Pointer_Compare {
-    bool operator() (const Complex_Selector* const pLeft, const Complex_Selector* const pRight) const;
+  struct Sequence_Selector_Pointer_Compare {
+    bool operator() (const Sequence_Selector* const pLeft, const Sequence_Selector* const pRight) const;
   };
 
   ////////////////////////////////////////////////////////////////////////////
   // Simple selector sequences. Maintains flags indicating whether it contains
   // any parent references or placeholders, to simplify expansion.
   ////////////////////////////////////////////////////////////////////////////
-  typedef std::set<Complex_Selector*, Complex_Selector_Pointer_Compare> SourcesSet;
+  typedef std::set<Sequence_Selector*, Sequence_Selector_Pointer_Compare> SourcesSet;
   class Compound_Selector : public Selector, public Vectorized<Simple_Selector*> {
   private:
     SourcesSet sources_;
@@ -2263,7 +2263,7 @@ namespace Sass {
       return length() == 1 && (*this)[0]->is_universal();
     }
 
-    Complex_Selector* to_complex(Memory_Manager& mem);
+    Sequence_Selector* to_complex(Memory_Manager& mem);
     Compound_Selector* unify_with(Compound_Selector* rhs, Context& ctx);
     // virtual Placeholder_Selector* find_placeholder();
     virtual bool has_parent_ref();
@@ -2280,7 +2280,7 @@ namespace Sass {
       return 0;
     }
     virtual bool is_superselector_of(Compound_Selector* sub, std::string wrapped = "");
-    virtual bool is_superselector_of(Complex_Selector* sub, std::string wrapped = "");
+    virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapped = "");
     virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapped = "");
     virtual size_t hash()
     {
@@ -2334,24 +2334,24 @@ namespace Sass {
   // CSS selector combinators (">", "+", "~", and whitespace). Essentially a
   // linked list.
   ////////////////////////////////////////////////////////////////////////////
-  class Complex_Selector : public Selector {
+  class Sequence_Selector : public Selector {
   public:
     enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO, REFERENCE };
   private:
     ADD_PROPERTY(Combinator, combinator)
     ADD_PROPERTY(Compound_Selector*, head)
-    ADD_PROPERTY(Complex_Selector*, tail)
+    ADD_PROPERTY(Sequence_Selector*, tail)
     ADD_PROPERTY(String*, reference);
   public:
     bool contains_placeholder() {
       if (head() && head()->contains_placeholder()) return true;
       if (tail() && tail()->contains_placeholder()) return true;
       return false;
     };
-    Complex_Selector(ParserState pstate,
+    Sequence_Selector(ParserState pstate,
                      Combinator c = ANCESTOR_OF,
                      Compound_Selector* h = 0,
-                     Complex_Selector* t = 0,
+                     Sequence_Selector* t = 0,
                      String* r = 0)
     : Selector(pstate),
       combinator_(c),
@@ -2363,7 +2363,7 @@ namespace Sass {
     }
     virtual bool has_parent_ref();
 
-    Complex_Selector* skip_empty_reference()
+    Sequence_Selector* skip_empty_reference()
     {
       if ((!head_ || !head_->length() || head_->is_empty_reference()) &&
           combinator() == Combinator::ANCESTOR_OF)
@@ -2383,36 +2383,36 @@ namespace Sass {
              combinator() == Combinator::ANCESTOR_OF;
     }
 
-    Complex_Selector* context(Context&);
+    Sequence_Selector* context(Context&);
 
 
     // front returns the first real tail
     // skips over parent and empty ones
-    const Complex_Selector* first() const;
+    const Sequence_Selector* first() const;
 
     // last returns the last real tail
-    const Complex_Selector* last() const;
+    const Sequence_Selector* last() const;
 
     CommaSequence_Selector* tails(Context& ctx, CommaSequence_Selector* tails);
 
     // unconstant accessors
-    Complex_Selector* first();
-    Complex_Selector* last();
+    Sequence_Selector* first();
+    Sequence_Selector* last();
 
     // some shortcuts that should be removed
-    const Complex_Selector* innermost() const { return last(); };
-    Complex_Selector* innermost() { return last(); };
+    const Sequence_Selector* innermost() const { return last(); };
+    Sequence_Selector* innermost() { return last(); };
 
     size_t length() const;
     CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent);
     virtual bool is_superselector_of(Compound_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(Complex_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 = "");
     // virtual Placeholder_Selector* find_placeholder();
-    CommaSequence_Selector* unify_with(Complex_Selector* rhs, Context& ctx);
+    CommaSequence_Selector* unify_with(Sequence_Selector* rhs, Context& ctx);
     Combinator clear_innermost();
-    void append(Context&, Complex_Selector*);
-    void set_innermost(Complex_Selector*, Combinator);
+    void append(Context&, Sequence_Selector*);
+    void set_innermost(Sequence_Selector*, Combinator);
     virtual size_t hash()
     {
       if (hash_ == 0) {
@@ -2440,9 +2440,9 @@ namespace Sass {
       if (tail_ && tail_->has_wrapped_selector()) return true;
       return false;
     }
-    bool operator<(const Complex_Selector& rhs) const;
-    bool operator==(const Complex_Selector& rhs) const;
-    inline bool operator!=(const Complex_Selector& rhs) const { return !(*this == rhs); }
+    bool operator<(const Sequence_Selector& rhs) const;
+    bool operator==(const Sequence_Selector& rhs) const;
+    inline bool operator!=(const Sequence_Selector& rhs) const { return !(*this == rhs); }
     SourcesSet sources()
     {
       //s = Set.new
@@ -2452,7 +2452,7 @@ namespace Sass {
       SourcesSet srcs;
 
       Compound_Selector* pHead = head();
-      Complex_Selector*  pTail = tail();
+      Sequence_Selector*  pTail = tail();
 
       if (pHead) {
         SourcesSet& headSources = pHead->sources();
@@ -2468,7 +2468,7 @@ namespace Sass {
     }
     void addSources(SourcesSet& sources, Context& ctx) {
       // members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
-      Complex_Selector* pIter = this;
+      Sequence_Selector* pIter = this;
       while (pIter) {
         Compound_Selector* pHead = pIter->head();
 
@@ -2480,7 +2480,7 @@ namespace Sass {
       }
     }
     void clearSources() {
-      Complex_Selector* pIter = this;
+      Sequence_Selector* pIter = this;
       while (pIter) {
         Compound_Selector* pHead = pIter->head();
 
@@ -2491,25 +2491,25 @@ namespace Sass {
         pIter = pIter->tail();
       }
     }
-    Complex_Selector* clone(Context&) const;      // does not clone Compound_Selector*s
-    Complex_Selector* cloneFully(Context&) const; // clones Compound_Selector*s
+    Sequence_Selector* clone(Context&) const;      // does not clone Compound_Selector*s
+    Sequence_Selector* cloneFully(Context&) const; // clones Compound_Selector*s
     // std::vector<Compound_Selector*> to_vector();
     ATTACH_OPERATIONS()
   };
 
-  typedef std::deque<Complex_Selector*> ComplexSelectorDeque;
-  typedef Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> > ExtensionSubsetMap;
+  typedef std::deque<Sequence_Selector*> ComplexSelectorDeque;
+  typedef Subset_Map<std::string, std::pair<Sequence_Selector*, Compound_Selector*> > ExtensionSubsetMap;
 
   ///////////////////////////////////
   // Comma-separated selector groups.
   ///////////////////////////////////
-  class CommaSequence_Selector : public Selector, public Vectorized<Complex_Selector*> {
+  class CommaSequence_Selector : public Selector, public Vectorized<Sequence_Selector*> {
     ADD_PROPERTY(std::vector<std::string>, wspace)
   protected:
-    void adjust_after_pushing(Complex_Selector* c);
+    void adjust_after_pushing(Sequence_Selector* c);
   public:
     CommaSequence_Selector(ParserState pstate, size_t s = 0)
-    : Selector(pstate), Vectorized<Complex_Selector*>(s), wspace_(0)
+    : Selector(pstate), Vectorized<Sequence_Selector*>(s), wspace_(0)
     { }
     std::string type() { return "list"; }
     // remove parent selector references
@@ -2519,7 +2519,7 @@ namespace Sass {
     // virtual Placeholder_Selector* find_placeholder();
     CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent = true);
     virtual bool is_superselector_of(Compound_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(Complex_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 = "");
     CommaSequence_Selector* unify_with(CommaSequence_Selector*, Context&);
     void populate_extends(CommaSequence_Selector*, Context&, ExtensionSubsetMap&);
@@ -2544,12 +2544,12 @@ namespace Sass {
     }
     virtual void set_media_block(Media_Block* mb) {
       media_block(mb);
-      for (Complex_Selector* cs : elements()) {
+      for (Sequence_Selector* cs : elements()) {
         cs->set_media_block(mb);
       }
     }
     virtual bool has_wrapped_selector() {
-      for (Complex_Selector* cs : elements()) {
+      for (Sequence_Selector* cs : elements()) {
         if (cs->has_wrapped_selector()) return true;
       }
       return false;
@@ -2573,7 +2573,7 @@ namespace Sass {
     // members of a SimpleSequence (Compound_Selector)).
     //
     // Due to the reliance on operator== and operater< behavior, this templated method is currently only intended for
-    // use with Compound_Selector and Complex_Selector objects.
+    // use with Compound_Selector and Sequence_Selector objects.
     if (simpleSelectorOrderDependent) {
       return !(one < two) && !(two < one);
     } else {
@@ -2582,7 +2582,7 @@ namespace Sass {
   }
 
   // compare function for sorting and probably other other uses
-  struct cmp_complex_selector { inline bool operator() (const Complex_Selector* l, const Complex_Selector* r) { return (*l < *r); } };
+  struct cmp_complex_selector { inline bool operator() (const Sequence_Selector* l, const Sequence_Selector* r) { return (*l < *r); } };
   struct cmp_compound_selector { inline bool operator() (const Compound_Selector* l, const Compound_Selector* r) { return (*l < *r); } };
   struct cmp_simple_selector { inline bool operator() (const Simple_Selector* l, const Simple_Selector* r) { return (*l < *r); } };
 

src/ast.hpp

@@ -84,7 +84,7 @@ namespace Sass {
     Pseudo_Selector* new_Pseudo_Selector(std::string p, size_t l, std::string n, Expression* expr = 0);
     Wrapped_Selector* new_Wrapped_Selector(std::string p, size_t l, std::string n, Simple_Base* sel);
     Compound_Selector* new_Compound_Selector(std::string p, size_t l, size_t s = 0);
-    Complex_Selector* new_Complex_Selector(std::string p, size_t l, Complex_Selector::Combinator c, Complex_Selector* ctx, Compound_Selector* sel);
+    Sequence_Selector* new_Sequence_Selector(std::string p, size_t l, Sequence_Selector::Combinator c, Sequence_Selector* ctx, Compound_Selector* sel);
     CommaSequence_Selector* new_CommaSequence_Selector(std::string p, size_t l, size_t s = 0);
   };
 }

src/ast_factory.hpp

@@ -80,7 +80,7 @@ namespace Sass {
   class Pseudo_Selector;
   class Wrapped_Selector;
   class Compound_Selector;
-  class Complex_Selector;
+  class Sequence_Selector;
   class CommaSequence_Selector;
 
   // common classes

src/ast_fwd_decl.hpp

@@ -50,7 +50,7 @@ namespace Sass {
     std::vector<char*> strings;
     std::vector<Resource> resources;
     std::map<const std::string, const StyleSheet> sheets;
-    Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> > subset_map;
+    Subset_Map<std::string, std::pair<Sequence_Selector*, Compound_Selector*> > subset_map;
     std::vector<Sass_Import_Entry> import_stack;
 
     struct Sass_Compiler* c_compiler;

src/context.hpp

@@ -108,9 +108,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
 //    debug_ast(selector->selector(), ind + "->", env);
 
-  } else if (dynamic_cast<Complex_Selector*>(node)) {
-    Complex_Selector* selector = dynamic_cast<Complex_Selector*>(node);
-    std::cerr << ind << "Complex_Selector " << selector
+  } else if (dynamic_cast<Sequence_Selector*>(node)) {
+    Sequence_Selector* selector = dynamic_cast<Sequence_Selector*>(node);
+    std::cerr << ind << "Sequence_Selector " << selector
       << " (" << pstate_source_position(node) << ")"
       << " <" << selector->hash() << ">"
       << " [weight:" << longToHex(selector->specificity()) << "]"
@@ -122,11 +122,11 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
       << " -- ";
       std::string del;
       switch (selector->combinator()) {
-        case Complex_Selector::PARENT_OF:   del = ">"; break;
-        case Complex_Selector::PRECEDES:    del = "~"; break;
-        case Complex_Selector::ADJACENT_TO: del = "+"; break;
-        case Complex_Selector::ANCESTOR_OF: del = " "; break;
-        case Complex_Selector::REFERENCE:   del = "//"; break;
+        case Sequence_Selector::PARENT_OF:   del = ">"; break;
+        case Sequence_Selector::PRECEDES:    del = "~"; break;
+        case Sequence_Selector::ADJACENT_TO: del = "+"; break;
+        case Sequence_Selector::ANCESTOR_OF: del = " "; break;
+        case Sequence_Selector::REFERENCE:   del = "//"; break;
       }
       // if (del = "/") del += selector->reference()->perform(&to_string) + "/";
     std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
@@ -682,11 +682,11 @@ inline void debug_node(Node* node, std::string ind = "")
     std::cerr << node << " ";
     if (node->got_line_feed) std::cerr << "[LF] ";
     switch (node->combinator()) {
-      case Complex_Selector::ADJACENT_TO: std::cerr << "{+} "; break;
-      case Complex_Selector::PARENT_OF:   std::cerr << "{>} "; break;
-      case Complex_Selector::PRECEDES:    std::cerr << "{~} "; break;
-      case Complex_Selector::REFERENCE:   std::cerr << "{@} "; break;
-      case Complex_Selector::ANCESTOR_OF: std::cerr << "{ } "; break;
+      case Sequence_Selector::ADJACENT_TO: std::cerr << "{+} "; break;
+      case Sequence_Selector::PARENT_OF:   std::cerr << "{>} "; break;
+      case Sequence_Selector::PRECEDES:    std::cerr << "{~} "; break;
+      case Sequence_Selector::REFERENCE:   std::cerr << "{@} "; break;
+      case Sequence_Selector::ANCESTOR_OF: std::cerr << "{ } "; break;
     }
     std::cerr << std::endl;
     // debug_ast(node->combinator(), ind + "  ");
@@ -742,7 +742,7 @@ inline void debug_subset_map(Sass::ExtensionSubsetMap& map, std::string ind = ""
   if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
 }
 
-typedef std::pair<Complex_Selector*, Compound_Selector*> ExtensionPair;
+typedef std::pair<Sequence_Selector*, Compound_Selector*> ExtensionPair;
 typedef std::vector<ExtensionPair> SubsetMapEntries;
 
 inline void debug_subset_entries(SubsetMapEntries* entries, std::string ind = "")

src/debugger.hpp

@@ -1644,7 +1644,7 @@ namespace Sass {
   }
 
 
-  CommaSequence_Selector* Eval::operator()(Complex_Selector* s)
+  CommaSequence_Selector* Eval::operator()(Sequence_Selector* s)
   {
     bool implicit_parent = !exp.old_at_root_without_rule;
     return s->resolve_parent_refs(ctx, selector(), implicit_parent);

src/eval.cpp

@@ -71,7 +71,7 @@ namespace Sass {
 
     // these will return selectors
     CommaSequence_Selector* operator()(CommaSequence_Selector*);
-    CommaSequence_Selector* operator()(Complex_Selector*);
+    CommaSequence_Selector* operator()(Sequence_Selector*);
     Attribute_Selector* operator()(Attribute_Selector*);
     // they don't have any specific implementatio (yet)
     Element_Selector* operator()(Element_Selector* s) { return s; };

src/eval.hpp

@@ -106,8 +106,8 @@ namespace Sass {
     // do some special checks for the base level rules
     if (r->is_root()) {
       if (CommaSequence_Selector* selector_list = dynamic_cast<CommaSequence_Selector*>(r->selector())) {
-        for (Complex_Selector* complex_selector : selector_list->elements()) {
-          Complex_Selector* tail = complex_selector;
+        for (Sequence_Selector* complex_selector : selector_list->elements()) {
+          Sequence_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
@@ -555,8 +555,8 @@ namespace Sass {
   void Expand::expand_selector_list(Selector* s, CommaSequence_Selector* extender) {
 
     if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(s)) {
-      for (Complex_Selector* complex_selector : sl->elements()) {
-        Complex_Selector* tail = complex_selector;
+      for (Sequence_Selector* complex_selector : sl->elements()) {
+        Sequence_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
@@ -572,21 +572,21 @@ namespace Sass {
     CommaSequence_Selector* contextualized = dynamic_cast<CommaSequence_Selector*>(s->perform(&eval));
     if (contextualized == NULL) return;
     for (auto complex_sel : contextualized->elements()) {
-      Complex_Selector* c = complex_sel;
+      Sequence_Selector* c = complex_sel;
       if (!c->head() || c->tail()) {
         std::string sel_str(contextualized->to_string(ctx.c_options));
         error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
       }
       Compound_Selector* placeholder = c->head();
       if (contextualized->is_optional()) placeholder->is_optional(true);
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
-        Complex_Selector* sel = (*extender)[i];
+        Sequence_Selector* sel = (*extender)[i];
         if (!(sel->head() && sel->head()->length() > 0 &&
             dynamic_cast<Parent_Selector*>((*sel->head())[0])))
         {
           Compound_Selector* hh = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, (*extender)[i]->pstate());
           hh->media_block((*extender)[i]->media_block());
-          Complex_Selector* ssel = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, (*extender)[i]->pstate());
+          Sequence_Selector* ssel = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, (*extender)[i]->pstate());
           ssel->media_block((*extender)[i]->media_block());
           if (sel->has_line_feed()) ssel->has_line_feed(true);
           Parent_Selector* ps = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, (*extender)[i]->pstate());
@@ -611,7 +611,7 @@ namespace Sass {
         if (schema->has_parent_ref()) s = eval(schema);
       }
       if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(s)) {
-        for (Complex_Selector* cs : *sl) {
+        for (Sequence_Selector* cs : *sl) {
           if (cs != NULL && cs->head() != NULL) {
             cs->head()->media_block(media_block_stack.back());
           }