sassc 2.2.1 → 2.4.0

data/ext/libsass/src/memory/memory_pool.hpp

@@ -0,0 +1,186 @@
+#ifndef SASS_MEMORY_POOL_H
+#define SASS_MEMORY_POOL_H
+
+#include <stdlib.h>
+#include <iostream>
+#include <algorithm>
+#include <climits>
+#include <vector>
+
+namespace Sass {
+
+  // SIMPLE MEMORY-POOL ALLOCATOR WITH FREE-LIST ON TOP
+
+  // This is a memory pool allocator with a free list on top.
+  // We only allocate memory arenas from the system in specific
+  // sizes (`SassAllocatorArenaSize`). Users claim memory slices
+  // of certain sizes from the pool. If the allocation is too big
+  // to fit into our buckets, we use regular malloc/free instead.
+
+  // When the systems starts, we allocate the first arena and then
+  // start to give out addresses to memory slices. During that
+  // we steadily increase `offset` until the current arena is full.
+  // Once that happens we allocate a new arena and continue.
+  // https://en.wikipedia.org/wiki/Memory_pool
+
+  // Fragments that get deallocated are not really freed, we put
+  // them on our free-list. For every bucket we have a pointer to
+  // the first item for reuse. That item itself holds a pointer to
+  // the previously free item (regular free-list implementation).
+  // https://en.wikipedia.org/wiki/Free_list
+
+  // On allocation calls we first check if there is any suitable
+  // item on the free-list. If there is we pop it from the stack
+  // and return it to the caller. Otherwise we have to take out
+  // a new slice from the current `arena` and increase `offset`.
+
+  // Note that this is not thread safe. This is on purpose as we
+  // want to use the memory pool in a thread local usage. In order
+  // to get this thread safe you need to only allocate one pool
+  // per thread. This can be achieved by using thread local PODs.
+  // Simply create a pool on the first allocation and dispose
+  // it once all allocations have been returned. E.g. by using:
+  // static thread_local size_t allocations;
+  // static thread_local MemoryPool* pool;
+
+  class MemoryPool {
+
+    // Current arena we fill up
+    char* arena;
+
+    // Position into the arena
+    size_t offset = std::string::npos;
+
+    // A list of full arenas
+    std::vector<void*> arenas;
+
+    // One pointer for every bucket (zero init)
+    #ifdef _MSC_VER
+    #pragma warning (suppress:4351)
+    #endif
+    void* freeList[SassAllocatorBuckets]{};
+
+    // Increase the address until it sits on a
+    // memory aligned address (maybe use `aligned`).
+    inline static size_t alignMemAddr(size_t addr) {
+      return (addr + SASS_MEM_ALIGN - 1) & ~(SASS_MEM_ALIGN - 1);
+    }
+
+  public:
+
+    // Default ctor
+    MemoryPool() :
+      // Wait for first allocation
+      arena(nullptr),
+      // Set to maximum value in order to
+      // make an allocation on the first run
+      offset(std::string::npos)
+    {
+    }
+
+    // Destructor
+    ~MemoryPool() {
+      // Delete full arenas
+      for (auto area : arenas) {
+        free(area);
+      }
+      // Delete current arena
+      free(arena);
+
+    }
+
+    // Allocate a slice of the memory pool
+    void* allocate(size_t size)
+    {
+
+      // Increase size so its memory is aligned
+      size = alignMemAddr(
+        // Make sure we have enough space for us to
+        // create the pointer to the free list later
+        std::max(sizeof(void*), size)
+        // and the size needed for our book-keeping
+        + SassAllocatorBookSize);
+
+      // Size must be multiple of alignment
+      // So we can derive bucket index from it
+      size_t bucket = size / SASS_MEM_ALIGN;
+
+      // Everything bigger is allocated via malloc
+      // Malloc is optimized for exactly this case
+      if (bucket >= SassAllocatorBuckets) {
+        char* buffer = (char*)malloc(size);
+        if (buffer == nullptr) {
+          throw std::bad_alloc();
+        }
+        // Mark it for deallocation via free
+        ((unsigned int*)buffer)[0] = UINT_MAX;
+        // Return pointer after our book-keeping space
+        return (void*)(buffer + SassAllocatorBookSize);
+      }
+      // Use custom allocator
+      else {
+        // Get item from free list
+        void*& free = freeList[bucket];
+        // Do we have a free item?
+        if (free != nullptr) {
+          // Copy pointer to return
+          void* ptr = free;
+          // Update free list pointer
+          free = ((void**)ptr)[0];
+          // Return popped item
+          return ptr;
+        }
+      }
+
+      // Make sure we have enough space in the arena
+      if (!arena || offset > SassAllocatorArenaSize - size) {
+        if (arena) arenas.emplace_back(arena);
+        arena = (char*)malloc(SassAllocatorArenaSize);
+        if (arena == nullptr) throw std::bad_alloc();
+        offset = SassAllocatorArenaHeadSize;
+      }
+
+      // Get pointer into the arena
+      char* buffer = arena + offset;
+      // Consume object size
+      offset += size;
+
+      // Set the bucket index for this slice
+      ((unsigned int*)buffer)[0] = (unsigned int)bucket;
+
+      // Return pointer after our book-keeping space
+      return (void*)(buffer + SassAllocatorBookSize);
+
+    }
+    // EO allocate
+
+    void deallocate(void* ptr)
+    {
+
+      // Rewind buffer from pointer
+      char* buffer = (char*)ptr -
+        SassAllocatorBookSize;
+
+      // Get the bucket index stored in the header
+      unsigned int bucket = ((unsigned int*)buffer)[0];
+
+      // Check allocation method
+      if (bucket != UINT_MAX) {
+        // Let memory point to previous item in free list
+        ((void**)ptr)[0] = freeList[bucket];
+        // Free list now points to our memory
+        freeList[bucket] = (void*)ptr;
+      }
+      else {
+        // Release memory
+        free(buffer);
+      }
+
+    }
+    // EO deallocate
+
+  };
+
+}
+
+#endif

data/ext/libsass/src/memory/{SharedPtr.cpp → shared_ptr.cpp}

@@ -2,7 +2,7 @@
 #include <iostream>
 #include <typeinfo>
 
-#include "SharedPtr.hpp"
+#include "shared_ptr.hpp"
 #include "../ast_fwd_decl.hpp"
 
 #ifdef DEBUG_SHARED_PTR
@@ -26,7 +26,7 @@ namespace Sass {
       }
     }
   }
-  std::vector<SharedObj*> SharedObj::all;
+  sass::vector<SharedObj*> SharedObj::all;
   #endif
 
   bool SharedObj::taint = false;

data/ext/libsass/src/memory/{SharedPtr.hpp → shared_ptr.hpp}

@@ -3,14 +3,21 @@
 
 #include "sass/base.h"
 
+#include "../sass.hpp"
+#include "allocator.hpp"
 #include <cstddef>
 #include <iostream>
 #include <string>
 #include <type_traits>
 #include <vector>
 
+// https://lokiastari.com/blog/2014/12/30/c-plus-plus-by-example-smart-pointer/index.html
+// https://lokiastari.com/blog/2015/01/15/c-plus-plus-by-example-smart-pointer-part-ii/index.html
+// https://lokiastari.com/blog/2015/01/23/c-plus-plus-by-example-smart-pointer-part-iii/index.html
+
 namespace Sass {
 
+  // Forward declaration
   class SharedPtr;
 
   ///////////////////////////////////////////////////////////////////////////////
@@ -42,6 +49,16 @@ namespace Sass {
 
   #endif
 
+  // SharedObj is the base class for all objects that can be stored as a shared object
+  // It adds the reference counter and other values directly to the objects
+  // This gives a slight overhead when directly used as a stack object, but has some
+  // advantages for our code. It is safe to create two shared pointers from the same
+  // objects, as the "control block" is directly attached to it. This would lead
+  // to undefined behavior with std::shared_ptr. This also avoids the need to
+  // allocate additional control blocks and/or the need to dereference two
+  // pointers on each operation. This can be optimized in `std::shared_ptr`
+  // too by using `std::make_shared` (where the control block and the actual
+  // object are allocated in one continuous memory block via one single call).
   class SharedObj {
    public:
     SharedObj() : refcount(0), detached(false) {
@@ -51,18 +68,23 @@ namespace Sass {
     }
     virtual ~SharedObj() {
       #ifdef DEBUG_SHARED_PTR
-      all.clear();
+      for (size_t i = 0; i < all.size(); i++) {
+        if (all[i] == this) {
+          all.erase(all.begin() + i);
+          break;
+        }
+      }
       #endif
     }
 
     #ifdef DEBUG_SHARED_PTR
     static void dumpMemLeaks();
-    SharedObj* trace(std::string file, size_t line) {
+    SharedObj* trace(sass::string file, size_t line) {
       this->file = file;
       this->line = line;
       return this;
     }
-    std::string getDbgFile() { return file; }
+    sass::string getDbgFile() { return file; }
     size_t getDbgLine() { return line; }
     void setDbg(bool dbg) { this->dbg = dbg; }
     size_t getRefCount() const { return refcount; }
@@ -70,7 +92,16 @@ namespace Sass {
 
     static void setTaint(bool val) { taint = val; }
 
-    virtual const std::string to_string() const = 0;
+    #ifdef SASS_CUSTOM_ALLOCATOR
+    inline void* operator new(size_t nbytes) {
+      return allocateMem(nbytes);
+    }
+    inline void operator delete(void* ptr) {
+      return deallocateMem(ptr);
+    }
+    #endif
+
+    virtual sass::string to_string() const = 0;
    protected:
     friend class SharedPtr;
     friend class Memory_Manager;
@@ -78,13 +109,16 @@ namespace Sass {
     bool detached;
     static bool taint;
     #ifdef DEBUG_SHARED_PTR
-    std::string file;
+    sass::string file;
     size_t line;
     bool dbg = false;
-    static std::vector<SharedObj*> all;
+    static sass::vector<SharedObj*> all;
     #endif
   };
 
+  // SharedPtr is a intermediate (template-less) base class for SharedImpl.
+  // ToDo: there should be a way to include this in SharedImpl and to get
+  // ToDo: rid of all the static_cast that are now needed in SharedImpl.
   class SharedPtr {
    public:
     SharedPtr() : node(nullptr) {}
@@ -114,6 +148,11 @@ namespace Sass {
     // Prevents all SharedPtrs from freeing this node until it is assigned to another SharedPtr.
     SharedObj* detach() {
       if (node != nullptr) node->detached = true;
+      #ifdef DEBUG_SHARED_PTR
+      if (node->dbg) {
+        std::cerr << "DETACHING NODE\n";
+      }
+      #endif 
       return node;
     }
 
@@ -136,6 +175,11 @@ namespace Sass {
         #endif
         delete node;
       }
+      else if (node->refcount == 0) {
+        #ifdef DEBUG_SHARED_PTR
+        if (node->dbg) std::cerr << "NODE EVAEDED DELETE " << node << "\n";
+        #endif
+      }
     }
     void incRefCount() {
       if (node == nullptr) return;
@@ -149,7 +193,8 @@ namespace Sass {
 
   template <class T>
   class SharedImpl : private SharedPtr {
-   public:
+
+  public:
     SharedImpl() : SharedPtr(nullptr) {}
 
     template <class U>
@@ -172,9 +217,9 @@ namespace Sass {
         SharedPtr::operator=(static_cast<const SharedImpl<T>&>(rhs)));
     }
 
-    operator const std::string() const {
+    operator sass::string() const {
       if (node) return node->to_string();
-      return "[nullptr]";
+      return "null";
     }
 
     using SharedPtr::isNull;
@@ -185,6 +230,7 @@ namespace Sass {
     T* operator-> () const { return static_cast<T*>(this->obj()); };
     T* ptr () const { return static_cast<T*>(this->obj()); };
     T* detach() { return static_cast<T*>(SharedPtr::detach()); }
+
   };
 
   // Comparison operators, based on:

data/ext/libsass/src/memory.hpp

@@ -0,0 +1,12 @@
+#ifndef SASS_MEMORY_H
+#define SASS_MEMORY_H
+
+#include "settings.hpp"
+
+// Include memory headers
+#include "memory/config.hpp"
+#include "memory/allocator.hpp"
+#include "memory/shared_ptr.hpp"
+#include "memory/memory_pool.hpp"
+
+#endif

data/ext/libsass/src/operation.hpp

@@ -1,9 +1,14 @@
 #ifndef SASS_OPERATION_H
 #define SASS_OPERATION_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 // base classes to implement curiously recurring template pattern (CRTP)
 // https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 
+#include <typeinfo>
 #include <stdexcept>
 
 #include "ast_fwd_decl.hpp"
@@ -14,13 +19,13 @@ namespace Sass {
   #define ATTACH_ABSTRACT_CRTP_PERFORM_METHODS()\
     virtual void perform(Operation<void>* op) = 0; \
     virtual Value* perform(Operation<Value*>* op) = 0; \
-    virtual std::string perform(Operation<std::string>* op) = 0; \
+    virtual sass::string perform(Operation<sass::string>* op) = 0; \
     virtual AST_Node* perform(Operation<AST_Node*>* op) = 0; \
     virtual Selector* perform(Operation<Selector*>* op) = 0; \
     virtual Statement* perform(Operation<Statement*>* op) = 0; \
     virtual Expression* perform(Operation<Expression*>* op) = 0; \
     virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) = 0; \
-    virtual Supports_Condition* perform(Operation<Supports_Condition*>* op) = 0; \
+    virtual SupportsCondition* perform(Operation<SupportsCondition*>* op) = 0; \
 
   // you must add operators to every class
   // ensures `this` of actual instance type
@@ -29,13 +34,13 @@ namespace Sass {
   #define ATTACH_CRTP_PERFORM_METHODS()\
     virtual void perform(Operation<void>* op) override { return (*op)(this); } \
     virtual Value* perform(Operation<Value*>* op) override { return (*op)(this); } \
-    virtual std::string perform(Operation<std::string>* op) override { return (*op)(this); } \
+    virtual sass::string perform(Operation<sass::string>* op) override { return (*op)(this); } \
     virtual AST_Node* perform(Operation<AST_Node*>* op) override { return (*op)(this); } \
     virtual Selector* perform(Operation<Selector*>* op) override { return (*op)(this); } \
     virtual Statement* perform(Operation<Statement*>* op) override { return (*op)(this); } \
     virtual Expression* perform(Operation<Expression*>* op) override { return (*op)(this); } \
     virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) override { return (*op)(this); } \
-    virtual Supports_Condition* perform(Operation<Supports_Condition*>* op) override { return (*op)(this); } \
+    virtual SupportsCondition* perform(Operation<SupportsCondition*>* op) override { return (*op)(this); } \
 
   template<typename T>
   class Operation {
@@ -43,29 +48,31 @@ namespace Sass {
     virtual T operator()(AST_Node* x)               = 0;
     // statements
     virtual T operator()(Block* x)                  = 0;
-    virtual T operator()(Ruleset* x)                = 0;
+    virtual T operator()(StyleRule* 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()(SupportsRule* x)         = 0;
+    virtual T operator()(MediaRule* x) = 0;
+    virtual T operator()(CssMediaRule* x) = 0;
+    virtual T operator()(CssMediaQuery* x) = 0;
+    virtual T operator()(AtRootRule* x)          = 0;
+    virtual T operator()(AtRule* 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()(WarningRule* x)                = 0;
+    virtual T operator()(ErrorRule* x)                  = 0;
+    virtual T operator()(DebugRule* 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()(ForRule* x)                    = 0;
+    virtual T operator()(EachRule* x)                   = 0;
+    virtual T operator()(WhileRule* x)                  = 0;
     virtual T operator()(Return* x)                 = 0;
     virtual T operator()(Content* x)                = 0;
-    virtual T operator()(Extension* x)              = 0;
+    virtual T operator()(ExtendRule* x)              = 0;
     virtual T operator()(Definition* x)             = 0;
     virtual T operator()(Mixin_Call* x)             = 0;
     // expressions
@@ -87,15 +94,14 @@ namespace Sass {
     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()(SupportsCondition* x)     = 0;
+    virtual T operator()(SupportsOperation* x)      = 0;
+    virtual T operator()(SupportsNegation* x)      = 0;
+    virtual T operator()(SupportsDeclaration* x)   = 0;
     virtual T operator()(Supports_Interpolation* x) = 0;
-    virtual T operator()(Media_Query* 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()(Parent_Selector* x)        = 0;
     virtual T operator()(Parent_Reference* x)        = 0;
     // parameters and arguments
     virtual T operator()(Parameter* x)              = 0;
@@ -104,51 +110,55 @@ namespace Sass {
     virtual T operator()(Arguments* x)              = 0;
     // selectors
     virtual T operator()(Selector_Schema* x)        = 0;
-    virtual T operator()(Placeholder_Selector* x)   = 0;
-    virtual T operator()(Type_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()(Compound_Selector* x)= 0;
-    virtual T operator()(Complex_Selector* x)      = 0;
-    virtual T operator()(Selector_List* x) = 0;
+    virtual T operator()(PlaceholderSelector* x)   = 0;
+    virtual T operator()(TypeSelector* x)       = 0;
+    virtual T operator()(ClassSelector* x)         = 0;
+    virtual T operator()(IDSelector* x)            = 0;
+    virtual T operator()(AttributeSelector* x)     = 0;
+    virtual T operator()(PseudoSelector* x)        = 0;
+    virtual T operator()(SelectorComponent* x) = 0;
+    virtual T operator()(SelectorCombinator* x) = 0;
+    virtual T operator()(CompoundSelector* x) = 0;
+    virtual T operator()(ComplexSelector* x) = 0;
+    virtual T operator()(SelectorList* x) = 0;
+
   };
 
   // example: Operation_CRTP<Expression*, Eval>
   // T is the base return type of all visitors
   // D is the class derived visitor class
-  // normaly you want to implement all operators
+  // normally you want to implement all operators
   template <typename T, typename D>
   class Operation_CRTP : public Operation<T> {
   public:
     T operator()(AST_Node* 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()(StyleRule* 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()(SupportsRule* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(MediaRule* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(CssMediaRule* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(CssMediaQuery* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AtRootRule* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AtRule* 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()(WarningRule* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(ErrorRule* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(DebugRule* 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()(ForRule* x)                    { return static_cast<D*>(this)->fallback(x); }
+    T operator()(EachRule* x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(WhileRule* 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()(ExtendRule* 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); }
     // expressions
@@ -170,15 +180,14 @@ namespace Sass {
     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()(SupportsCondition* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsOperation* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsNegation* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsDeclaration* 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()(Parent_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
     T operator()(Parent_Reference* x)        { return static_cast<D*>(this)->fallback(x); }
     // parameters and arguments
     T operator()(Parameter* x)              { return static_cast<D*>(this)->fallback(x); }
@@ -187,20 +196,21 @@ namespace Sass {
     T operator()(Arguments* 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()(Type_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()(Compound_Selector* x){ return static_cast<D*>(this)->fallback(x); }
-    T operator()(Complex_Selector* x)      { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Selector_List* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(PlaceholderSelector* x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(TypeSelector* x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(ClassSelector* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(IDSelector* x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AttributeSelector* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(PseudoSelector* x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SelectorComponent* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SelectorCombinator* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(CompoundSelector* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(ComplexSelector* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SelectorList* x) { return static_cast<D*>(this)->fallback(x); }
 
     // fallback with specific type U
     // will be called if not overloaded
-    template <typename U> T fallback(U x)
+    template <typename U> inline T fallback(U x)
     {
       throw std::runtime_error(
         std::string(typeid(*this).name()) + ": CRTP not implemented for " + typeid(x).name());