sassc 1.11.1 → 1.11.2

data/ext/libsass/src/node.cpp

@@ -8,20 +8,20 @@
 namespace Sass {
 
 
-  Node Node::createCombinator(const Sequence_Selector::Combinator& combinator) {
+  Node Node::createCombinator(const Complex_Selector::Combinator& combinator) {
     NodeDequePtr null;
     return Node(COMBINATOR, combinator, NULL /*pSelector*/, null /*pCollection*/);
   }
 
 
-  Node Node::createSelector(Sequence_Selector* pSelector, Context& ctx) {
+  Node Node::createSelector(Complex_Selector_Ptr pSelector, Context& ctx) {
     NodeDequePtr null;
 
-    Sequence_Selector* pStripped = pSelector->clone(ctx);
+    Complex_Selector_Ptr pStripped = SASS_MEMORY_COPY(pSelector);
     pStripped->tail(NULL);
-    pStripped->combinator(Sequence_Selector::ANCESTOR_OF);
+    pStripped->combinator(Complex_Selector::ANCESTOR_OF);
 
-    Node n(SELECTOR, Sequence_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
+    Node n(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
     if (pSelector) n.got_line_feed = pSelector->has_line_feed();
     return n;
   }
@@ -29,37 +29,37 @@ namespace Sass {
 
   Node Node::createCollection() {
     NodeDequePtr pEmptyCollection = std::make_shared<NodeDeque>();
-    return Node(COLLECTION, Sequence_Selector::ANCESTOR_OF, NULL /*pSelector*/, pEmptyCollection);
+    return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pEmptyCollection);
   }
 
 
   Node Node::createCollection(const NodeDeque& values) {
     NodeDequePtr pShallowCopiedCollection = std::make_shared<NodeDeque>(values);
-    return Node(COLLECTION, Sequence_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);
+    return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);
   }
 
 
   Node Node::createNil() {
     NodeDequePtr null;
-    return Node(NIL, Sequence_Selector::ANCESTOR_OF, NULL /*pSelector*/, null /*pCollection*/);
+    return Node(NIL, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, null /*pCollection*/);
   }
 
 
-  Node::Node(const TYPE& type, Sequence_Selector::Combinator combinator, Sequence_Selector* pSelector, NodeDequePtr& pCollection)
+  Node::Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector_Ptr pSelector, NodeDequePtr& pCollection)
   : got_line_feed(false), mType(type), mCombinator(combinator), mpSelector(pSelector), mpCollection(pCollection)
   { if (pSelector) got_line_feed = pSelector->has_line_feed(); }
 
 
-  Node Node::clone(Context& ctx) const {
+  Node Node::klone(Context& ctx) const {
     NodeDequePtr pNewCollection = std::make_shared<NodeDeque>();
     if (mpCollection) {
       for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
         Node& toClone = *iter;
-        pNewCollection->push_back(toClone.clone(ctx));
+        pNewCollection->push_back(toClone.klone(ctx));
       }
     }
 
-    Node n(mType, mCombinator, mpSelector ? mpSelector->clone(ctx) : NULL, pNewCollection);
+    Node n(mType, mCombinator, mpSelector ? SASS_MEMORY_COPY(mpSelector) : NULL, pNewCollection);
     n.got_line_feed = got_line_feed;
     return n;
   }
@@ -101,7 +101,7 @@ namespace Sass {
 
     } else if (lhs.isSelector()){
 
-      return selectors_equal(*lhs.selector(), *rhs.selector(), simpleSelectorOrderDependent);
+      return selectors_equal(*&lhs.selector(), *&rhs.selector(), simpleSelectorOrderDependent);
 
     } else if (lhs.isCollection()) {
 
@@ -140,11 +140,11 @@ namespace Sass {
     if (node.isCombinator()) {
 
       switch (node.combinator()) {
-        case Sequence_Selector::ANCESTOR_OF: os << "\" \""; break;
-        case Sequence_Selector::PARENT_OF:   os << "\">\""; break;
-        case Sequence_Selector::PRECEDES:    os << "\"~\""; break;
-        case Sequence_Selector::ADJACENT_TO: os << "\"+\""; break;
-        case Sequence_Selector::REFERENCE: os    << "\"/\""; break;
+        case Complex_Selector::ANCESTOR_OF: os << "\" \""; break;
+        case Complex_Selector::PARENT_OF:   os << "\">\""; break;
+        case Complex_Selector::PRECEDES:    os << "\"~\""; break;
+        case Complex_Selector::ADJACENT_TO: os << "\"+\""; break;
+        case Complex_Selector::REFERENCE: os    << "\"/\""; break;
       }
 
     } else if (node.isNil()) {
@@ -177,7 +177,7 @@ namespace Sass {
 #endif
 
 
-  Node complexSelectorToNode(Sequence_Selector* pToConvert, Context& ctx) {
+  Node complexSelectorToNode(Complex_Selector_Ptr pToConvert, Context& ctx) {
     if (pToConvert == NULL) {
       return Node::createNil();
     }
@@ -187,26 +187,26 @@ namespace Sass {
 
     // unwrap the selector from parent ref
     if (pToConvert->head() && pToConvert->head()->has_parent_ref()) {
-      Sequence_Selector* tail = pToConvert->tail();
+      Complex_Selector_Obj tail = pToConvert->tail();
       if (tail) tail->has_line_feed(pToConvert->has_line_feed());
-      pToConvert = tail;
+      pToConvert = &tail;
     }
 
     while (pToConvert) {
 
       bool empty_parent_ref = pToConvert->head() && pToConvert->head()->is_empty_reference();
 
-      if (pToConvert->head() == NULL || empty_parent_ref) {
+      if (pToConvert->head() || empty_parent_ref) {
       }
 
-      // the first Sequence_Selector may contain a dummy head pointer, skip it.
-      if (pToConvert->head() != NULL && !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, ctx));
         if (has_lf) node.collection()->back().got_line_feed = has_lf;
         has_lf = false;
       }
 
-      if (pToConvert->combinator() != Sequence_Selector::ANCESTOR_OF) {
+      if (pToConvert->combinator() != Complex_Selector::ANCESTOR_OF) {
         node.collection()->push_back(Node::createCombinator(pToConvert->combinator()));
         if (has_lf) node.collection()->back().got_line_feed = has_lf;
         has_lf = false;
@@ -216,21 +216,21 @@ namespace Sass {
         // pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());
       }
 
-      pToConvert = pToConvert->tail();
+      pToConvert = &pToConvert->tail();
     }
 
     return node;
   }
 
 
-  Sequence_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx) {
+  Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert, Context& ctx) {
     if (toConvert.isNil()) {
       return NULL;
     }
 
 
     if (!toConvert.isCollection()) {
-      throw "The node to convert to a Sequence_Selector* must be a collection type or nil.";
+      throw "The node to convert to a Complex_Selector_Ptr must be a collection type or nil.";
     }
 
 
@@ -238,9 +238,9 @@ namespace Sass {
 
     std::string noPath("");
     Position noPosition(-1, -1, -1);
-    Sequence_Selector* pFirst = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, ParserState("[NODE]"), Sequence_Selector::ANCESTOR_OF, NULL, NULL);
+    Complex_Selector_Obj pFirst = SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL);
 
-    Sequence_Selector* pCurrent = pFirst;
+    Complex_Selector_Obj pCurrent = pFirst;
 
     if (toConvert.isSelector()) pFirst->has_line_feed(toConvert.got_line_feed);
     if (toConvert.isCombinator()) pFirst->has_line_feed(toConvert.got_line_feed);
@@ -250,20 +250,22 @@ namespace Sass {
       Node& child = *childIter;
 
       if (child.isSelector()) {
-        pCurrent->tail(child.selector()->clone(ctx));   // JMA - need to clone the selector, because they can end up getting shared across Node collections, and can result in an infinite loop during the call to parentSuperselector()
+        // JMA - need to clone the selector, because they can end up getting shared across Node
+        // collections, and can result in an infinite loop during the call to parentSuperselector()
+        pCurrent->tail(SASS_MEMORY_COPY(child.selector()));
         // if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
-        pCurrent = pCurrent->tail();
+        pCurrent = &pCurrent->tail();
       } else if (child.isCombinator()) {
         pCurrent->combinator(child.combinator());
         if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
 
-        // if the next node is also a combinator, create another Sequence_Selector to hold it so it doesn't replace the current combinator
+        // if the next node is also a combinator, create another Complex_Selector to hold it so it doesn't replace the current combinator
         if (childIter+1 != childIterEnd) {
           Node& nextNode = *(childIter+1);
           if (nextNode.isCombinator()) {
-            pCurrent->tail(SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, ParserState("[NODE]"), Sequence_Selector::ANCESTOR_OF, NULL, NULL));
+            pCurrent->tail(SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL));
             if (nextNode.got_line_feed) pCurrent->tail()->has_line_feed(nextNode.got_line_feed);
-            pCurrent = pCurrent->tail();
+            pCurrent = &pCurrent->tail();
           }
         }
       } else {
@@ -271,22 +273,22 @@ namespace Sass {
       }
     }
 
-    // Put the dummy SimpleSequence_Selector in the first position, for consistency with the rest of libsass
-    SimpleSequence_Selector* fakeHead = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, ParserState("[NODE]"), 1);
-    Parent_Selector* selectorRef = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, ParserState("[NODE]"));
+    // Put the dummy Compound_Selector in the first position, for consistency with the rest of libsass
+    Compound_Selector_Ptr fakeHead = SASS_MEMORY_NEW(Compound_Selector, ParserState("[NODE]"), 1);
+    Parent_Selector_Ptr selectorRef = SASS_MEMORY_NEW(Parent_Selector, ParserState("[NODE]"));
     fakeHead->elements().push_back(selectorRef);
     if (toConvert.got_line_feed) pFirst->has_line_feed(toConvert.got_line_feed);
     // pFirst->has_line_feed(pFirst->has_line_feed() || pFirst->tail()->has_line_feed() || toConvert.got_line_feed);
     pFirst->head(fakeHead);
-    return pFirst;
+    return SASS_MEMORY_COPY(pFirst);
   }
 
   // A very naive trim function, which removes duplicates in a node
-  // This is only used in Sequence_Selector::unify_with for now, may need modifications to fit other needs
+  // This is only used in Complex_Selector::unify_with for now, may need modifications to fit other needs
   Node Node::naiveTrim(Node& seqses, Context& ctx) {
 
     std::vector<Node*> res;
-    std::vector<Sequence_Selector*> known;
+    std::vector<Complex_Selector_Obj> known;
 
     NodeDeque::reverse_iterator seqsesIter = seqses.collection()->rbegin(),
                                 seqsesIterEnd = seqses.collection()->rend();
@@ -295,8 +297,8 @@ namespace Sass {
     {
       Node& seqs1 = *seqsesIter;
       if( seqs1.isSelector() ) {
-        Sequence_Selector* sel = seqs1.selector();
-        std::vector<Sequence_Selector*>::iterator it;
+        Complex_Selector_Obj sel = seqs1.selector();
+        std::vector<Complex_Selector_Obj>::iterator it;
         bool found = false;
         for (it = known.begin(); it != known.end(); ++it) {
           if (**it == *sel) { found = true; break; }

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 Sequence_Selector) to a Sequence, which contains more metadata about the sequence than just the
+   equivalent is the Complex_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 Sequence_Selector that follows it, but
+   Note that the current libsass data model also pairs the combinator with the Complex_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;
 
-    Sequence_Selector::Combinator combinator() const { return mCombinator; }
+    Complex_Selector::Combinator combinator() const { return mCombinator; }
 
-    Sequence_Selector* selector() { return mpSelector; }
-    const Sequence_Selector* selector() const { return mpSelector; }
+    Complex_Selector_Obj selector() { return mpSelector; }
+    Complex_Selector_Obj selector() const { return mpSelector; }
 
     NodeDequePtr collection() { return mpCollection; }
     const NodeDequePtr collection() const { return mpCollection; }
 
-    static Node createCombinator(const Sequence_Selector::Combinator& combinator);
+    static Node createCombinator(const Complex_Selector::Combinator& combinator);
 
-    // This method will clone the selector, stripping off the tail and combinator
-    static Node createSelector(Sequence_Selector* pSelector, Context& ctx);
+    // This method will klone the selector, stripping off the tail and combinator
+    static Node createSelector(Complex_Selector_Ptr pSelector, Context& ctx);
 
     static Node createCollection();
     static Node createCollection(const NodeDeque& values);
@@ -69,7 +69,7 @@ namespace Sass {
     static Node createNil();
     static Node naiveTrim(Node& seqses, Context& ctx);
 
-    Node clone(Context& ctx) const;
+    Node klone(Context& ctx) const;
 
     bool operator==(const Node& rhs) const;
     inline bool operator!=(const Node& rhs) const { return !(*this == rhs); }
@@ -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 Sequence_Selector
+    selector due to the fact that we leverage the non-node selector code on the Complex_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, Sequence_Selector::Combinator combinator, Sequence_Selector* pSelector, NodeDequePtr& pCollection);
+    Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector_Ptr pSelector, NodeDequePtr& pCollection);
 
     TYPE mType;
 
     // TODO: can we union these to save on memory?
-    Sequence_Selector::Combinator mCombinator;
-    Sequence_Selector* mpSelector; // this is an AST_Node, so it will be handled by the Memory_Manager
+    Complex_Selector::Combinator mCombinator;
+    Complex_Selector_Obj mpSelector;
     NodeDequePtr mpCollection;
   };
 
 #ifdef DEBUG
   std::ostream& operator<<(std::ostream& os, const Node& node);
 #endif
-  Node complexSelectorToNode(Sequence_Selector* pToConvert, Context& ctx);
-  Sequence_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx);
+  Node complexSelectorToNode(Complex_Selector_Ptr pToConvert, Context& ctx);
+  Complex_Selector_Ptr nodeToComplexSelector(const Node& toConvert, Context& ctx);
 
   bool nodesEqual(const Node& one, const Node& two, bool simpleSelectorOrderDependent);
 

data/ext/libsass/src/operation.hpp

@@ -8,79 +8,79 @@ namespace Sass {
   template<typename T>
   class Operation {
   public:
-    virtual T operator()(AST_Node* x)               = 0;
+    virtual T operator()(AST_Node_Ptr x)               = 0;
     virtual ~Operation()                            { }
     // statements
-    virtual T operator()(Block* x)                  = 0;
-    virtual T operator()(Ruleset* 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()(Keyframe_Rule* x)          = 0;
-    virtual T operator()(Declaration* x)            = 0;
-    virtual T operator()(Assignment* x)             = 0;
-    virtual T operator()(Import* x)                 = 0;
-    virtual T operator()(Import_Stub* x)            = 0;
-    virtual T operator()(Warning* x)                = 0;
-    virtual T operator()(Error* x)                  = 0;
-    virtual T operator()(Debug* x)                  = 0;
-    virtual T operator()(Comment* x)                = 0;
-    virtual T operator()(If* x)                     = 0;
-    virtual T operator()(For* x)                    = 0;
-    virtual T operator()(Each* x)                   = 0;
-    virtual T operator()(While* x)                  = 0;
-    virtual T operator()(Return* x)                 = 0;
-    virtual T operator()(Content* x)                = 0;
-    virtual T operator()(Extension* x)              = 0;
-    virtual T operator()(Definition* x)             = 0;
-    virtual T operator()(Mixin_Call* x)             = 0;
+    virtual T operator()(Block_Ptr x)                  = 0;
+    virtual T operator()(Ruleset_Ptr x)                = 0;
+    virtual T operator()(Bubble_Ptr x)                 = 0;
+    virtual T operator()(Trace_Ptr x)                  = 0;
+    virtual T operator()(Supports_Block_Ptr x)         = 0;
+    virtual T operator()(Media_Block_Ptr x)            = 0;
+    virtual T operator()(At_Root_Block_Ptr x)          = 0;
+    virtual T operator()(Directive_Ptr x)              = 0;
+    virtual T operator()(Keyframe_Rule_Ptr x)          = 0;
+    virtual T operator()(Declaration_Ptr x)            = 0;
+    virtual T operator()(Assignment_Ptr x)             = 0;
+    virtual T operator()(Import_Ptr x)                 = 0;
+    virtual T operator()(Import_Stub_Ptr x)            = 0;
+    virtual T operator()(Warning_Ptr x)                = 0;
+    virtual T operator()(Error_Ptr x)                  = 0;
+    virtual T operator()(Debug_Ptr x)                  = 0;
+    virtual T operator()(Comment_Ptr x)                = 0;
+    virtual T operator()(If_Ptr x)                     = 0;
+    virtual T operator()(For_Ptr x)                    = 0;
+    virtual T operator()(Each_Ptr x)                   = 0;
+    virtual T operator()(While_Ptr x)                  = 0;
+    virtual T operator()(Return_Ptr x)                 = 0;
+    virtual T operator()(Content_Ptr x)                = 0;
+    virtual T operator()(Extension_Ptr x)              = 0;
+    virtual T operator()(Definition_Ptr x)             = 0;
+    virtual T operator()(Mixin_Call_Ptr x)             = 0;
     // expressions
-    virtual T operator()(List* x)                   = 0;
-    virtual T operator()(Map* x)                    = 0;
-    virtual T operator()(Binary_Expression* x)      = 0;
-    virtual T operator()(Unary_Expression* x)       = 0;
-    virtual T operator()(Function_Call* x)          = 0;
-    virtual T operator()(Function_Call_Schema* x)   = 0;
-    virtual T operator()(Custom_Warning* x)         = 0;
-    virtual T operator()(Custom_Error* x)           = 0;
-    virtual T operator()(Variable* x)               = 0;
-    virtual T operator()(Textual* x)                = 0;
-    virtual T operator()(Number* x)                 = 0;
-    virtual T operator()(Color* x)                  = 0;
-    virtual T operator()(Boolean* x)                = 0;
-    virtual T operator()(String_Schema* x)          = 0;
-    virtual T operator()(String_Quoted* x)          = 0;
-    virtual T operator()(String_Constant* x)        = 0;
-    virtual T operator()(Supports_Condition* x)     = 0;
-    virtual T operator()(Supports_Operator* x)      = 0;
-    virtual T operator()(Supports_Negation* x)      = 0;
-    virtual T operator()(Supports_Declaration* x)   = 0;
-    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()(Null* x)                   = 0;
-    virtual T operator()(Parent_Selector* x)        = 0;
+    virtual T operator()(List_Ptr x)                   = 0;
+    virtual T operator()(Map_Ptr x)                    = 0;
+    virtual T operator()(Binary_Expression_Ptr x)      = 0;
+    virtual T operator()(Unary_Expression_Ptr x)       = 0;
+    virtual T operator()(Function_Call_Ptr x)          = 0;
+    virtual T operator()(Function_Call_Schema_Ptr x)   = 0;
+    virtual T operator()(Custom_Warning_Ptr x)         = 0;
+    virtual T operator()(Custom_Error_Ptr x)           = 0;
+    virtual T operator()(Variable_Ptr x)               = 0;
+    virtual T operator()(Textual_Ptr x)                = 0;
+    virtual T operator()(Number_Ptr x)                 = 0;
+    virtual T operator()(Color_Ptr x)                  = 0;
+    virtual T operator()(Boolean_Ptr x)                = 0;
+    virtual T operator()(String_Schema_Ptr x)          = 0;
+    virtual T operator()(String_Quoted_Ptr x)          = 0;
+    virtual T operator()(String_Constant_Ptr x)        = 0;
+    virtual T operator()(Supports_Condition_Ptr x)     = 0;
+    virtual T operator()(Supports_Operator_Ptr x)      = 0;
+    virtual T operator()(Supports_Negation_Ptr x)      = 0;
+    virtual T operator()(Supports_Declaration_Ptr x)   = 0;
+    virtual T operator()(Supports_Interpolation_Ptr x) = 0;
+    virtual T operator()(Media_Query_Ptr x)            = 0;
+    virtual T operator()(Media_Query_Expression_Ptr x) = 0;
+    virtual T operator()(At_Root_Query_Ptr x)          = 0;
+    virtual T operator()(Null_Ptr x)                   = 0;
+    virtual T operator()(Parent_Selector_Ptr x)        = 0;
     // parameters and arguments
-    virtual T operator()(Parameter* x)              = 0;
-    virtual T operator()(Parameters* x)             = 0;
-    virtual T operator()(Argument* x)               = 0;
-    virtual T operator()(Arguments* x)              = 0;
+    virtual T operator()(Parameter_Ptr x)              = 0;
+    virtual T operator()(Parameters_Ptr x)             = 0;
+    virtual T operator()(Argument_Ptr x)               = 0;
+    virtual T operator()(Arguments_Ptr x)              = 0;
     // selectors
-    virtual T operator()(Selector_Schema* 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()(SimpleSequence_Selector* x)= 0;
-    virtual T operator()(Sequence_Selector* x)      = 0;
-    virtual T operator()(CommaSequence_Selector* x) = 0;
+    virtual T operator()(Selector_Schema_Ptr x)        = 0;
+    virtual T operator()(Placeholder_Selector_Ptr x)   = 0;
+    virtual T operator()(Element_Selector_Ptr x)       = 0;
+    virtual T operator()(Class_Selector_Ptr x)         = 0;
+    virtual T operator()(Id_Selector_Ptr x)            = 0;
+    virtual T operator()(Attribute_Selector_Ptr x)     = 0;
+    virtual T operator()(Pseudo_Selector_Ptr x)        = 0;
+    virtual T operator()(Wrapped_Selector_Ptr x)       = 0;
+    virtual T operator()(Compound_Selector_Ptr x)= 0;
+    virtual T operator()(Complex_Selector_Ptr x)      = 0;
+    virtual T operator()(Selector_List_Ptr x) = 0;
 
     template <typename U>
     T fallback(U x) { return T(); }
@@ -91,78 +91,78 @@ namespace Sass {
   public:
     D& impl() { return static_cast<D&>(*this); }
   public:
-    T operator()(AST_Node* x)               { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AST_Node_Ptr x)               { return static_cast<D*>(this)->fallback(x); }
     // 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()(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()(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); }
-    T operator()(Import* x)                 { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Import_Stub* x)            { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Warning* x)                { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Error* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Debug* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Comment* x)                { return static_cast<D*>(this)->fallback(x); }
-    T operator()(If* x)                     { return static_cast<D*>(this)->fallback(x); }
-    T operator()(For* x)                    { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Each* x)                   { return static_cast<D*>(this)->fallback(x); }
-    T operator()(While* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Return* x)                 { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Content* x)                { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Extension* x)              { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Definition* x)             { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Mixin_Call* x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Block_Ptr x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Ruleset_Ptr x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Bubble_Ptr x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Trace_Ptr x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Block_Ptr x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Media_Block_Ptr x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(At_Root_Block_Ptr x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Directive_Ptr x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Keyframe_Rule_Ptr x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Declaration_Ptr x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Assignment_Ptr x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Import_Ptr x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Import_Stub_Ptr x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Warning_Ptr x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Error_Ptr x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Debug_Ptr x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Comment_Ptr x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(If_Ptr x)                     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(For_Ptr x)                    { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Each_Ptr x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(While_Ptr x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Return_Ptr x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Content_Ptr x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Extension_Ptr x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Definition_Ptr x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Mixin_Call_Ptr x)             { return static_cast<D*>(this)->fallback(x); }
     // expressions
-    T operator()(List* x)                   { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Map* x)                    { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Binary_Expression* x)      { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Unary_Expression* x)       { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Function_Call* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Function_Call_Schema* x)   { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Custom_Warning* x)         { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Custom_Error* x)           { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Variable* x)               { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Textual* x)                { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Number* x)                 { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Color* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Boolean* x)                { return static_cast<D*>(this)->fallback(x); }
-    T operator()(String_Schema* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(String_Constant* x)        { return static_cast<D*>(this)->fallback(x); }
-    T operator()(String_Quoted* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Condition* x)     { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Operator* x)      { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Negation* x)      { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Declaration* x)   { return static_cast<D*>(this)->fallback(x); }
-    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()(Null* x)                   { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Parent_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(List_Ptr x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Map_Ptr x)                    { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Binary_Expression_Ptr x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Unary_Expression_Ptr x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Function_Call_Ptr x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Function_Call_Schema_Ptr x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Custom_Warning_Ptr x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Custom_Error_Ptr x)           { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Variable_Ptr x)               { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Textual_Ptr x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Number_Ptr x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Color_Ptr x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Boolean_Ptr x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(String_Schema_Ptr x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(String_Constant_Ptr x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(String_Quoted_Ptr x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Condition_Ptr x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Operator_Ptr x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Negation_Ptr x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Declaration_Ptr x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Interpolation_Ptr x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Media_Query_Ptr x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Media_Query_Expression_Ptr x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(At_Root_Query_Ptr x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Null_Ptr x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Parent_Selector_Ptr x)        { return static_cast<D*>(this)->fallback(x); }
     // parameters and arguments
-    T operator()(Parameter* x)              { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Parameters* x)             { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Argument* x)               { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Arguments* x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Parameter_Ptr x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Parameters_Ptr x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Argument_Ptr x)               { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Arguments_Ptr x)              { return static_cast<D*>(this)->fallback(x); }
     // selectors
-    T operator()(Selector_Schema* 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()(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); }
+    T operator()(Selector_Schema_Ptr x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Placeholder_Selector_Ptr x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Element_Selector_Ptr x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Class_Selector_Ptr x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Id_Selector_Ptr x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Attribute_Selector_Ptr x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Pseudo_Selector_Ptr x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Wrapped_Selector_Ptr x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Compound_Selector_Ptr x){ return static_cast<D*>(this)->fallback(x); }
+    T operator()(Complex_Selector_Ptr x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Selector_List_Ptr x) { return static_cast<D*>(this)->fallback(x); }
 
     template <typename U>
     T fallback(U x)                         { return T(); }