zuora_connect_ui 0.8.1 → 0.8.2

data/vendor/ruby/2.6.0/gems/sassc-2.1.0-x86_64-linux/ext/libsass/src/node.cpp

@@ -0,0 +1,322 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <vector>
+
+#include "node.hpp"
+#include "context.hpp"
+#include "parser.hpp"
+
+namespace Sass {
+
+
+  Node Node::createCombinator(const Complex_Selector::Combinator& combinator) {
+    NodeDequePtr null;
+    return Node(COMBINATOR, combinator, NULL /*pSelector*/, null /*pCollection*/);
+  }
+
+
+  Node Node::createSelector(const Complex_Selector& pSelector) {
+    NodeDequePtr null;
+
+    Complex_Selector* pStripped = SASS_MEMORY_COPY(&pSelector);
+    pStripped->tail({});
+    pStripped->combinator(Complex_Selector::ANCESTOR_OF);
+
+    Node n(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
+    n.got_line_feed = pSelector.has_line_feed();
+    return n;
+  }
+
+
+  Node Node::createCollection() {
+    NodeDequePtr pEmptyCollection = std::make_shared<NodeDeque>();
+    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, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);
+  }
+
+
+  Node Node::createNil() {
+    NodeDequePtr null;
+    return Node(NIL, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, null /*pCollection*/);
+  }
+
+
+  Node::Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* 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::klone() 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.klone());
+      }
+    }
+
+    Node n(mType, mCombinator, mpSelector ? SASS_MEMORY_COPY(mpSelector) : NULL, pNewCollection);
+    n.got_line_feed = got_line_feed;
+    return n;
+  }
+
+
+  bool Node::contains(const Node& potentialChild) const {
+    bool found = false;
+
+    for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
+      Node& toTest = *iter;
+
+      if (toTest == potentialChild) {
+        found = true;
+        break;
+      }
+    }
+
+    return found;
+  }
+
+
+  bool Node::operator==(const Node& rhs) const {
+    if (this->type() != rhs.type()) {
+      return false;
+    }
+
+    if (this->isCombinator()) {
+
+      return this->combinator() == rhs.combinator();
+
+    } else if (this->isNil()) {
+
+      return true; // no state to check
+
+    } else if (this->isSelector()){
+
+      return *this->selector() == *rhs.selector();
+
+    } else if (this->isCollection()) {
+
+      if (this->collection()->size() != rhs.collection()->size()) {
+        return false;
+      }
+
+      for (NodeDeque::iterator lhsIter = this->collection()->begin(), lhsIterEnd = this->collection()->end(),
+           rhsIter = rhs.collection()->begin(); lhsIter != lhsIterEnd; lhsIter++, rhsIter++) {
+
+        if (*lhsIter != *rhsIter) {
+          return false;
+        }
+
+      }
+
+      return true;
+
+    }
+
+    // We shouldn't get here.
+    throw "Comparing unknown node types. A new type was probably added and this method wasn't implemented for it.";
+  }
+
+
+  void Node::plus(Node& rhs) {
+    if (!this->isCollection() || !rhs.isCollection()) {
+      throw "Both the current node and rhs must be collections.";
+    }
+    this->collection()->insert(this->collection()->end(), rhs.collection()->begin(), rhs.collection()->end());
+  }
+
+#ifdef DEBUG
+  std::ostream& operator<<(std::ostream& os, const Node& node) {
+
+    if (node.isCombinator()) {
+
+      switch (node.combinator()) {
+        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()) {
+
+      os << "nil";
+
+    } else if (node.isSelector()){
+
+      os << node.selector()->head()->to_string();
+
+    } else if (node.isCollection()) {
+
+      os << "[";
+
+      for (NodeDeque::iterator iter = node.collection()->begin(), iterBegin = node.collection()->begin(), iterEnd = node.collection()->end(); iter != iterEnd; iter++) {
+        if (iter != iterBegin) {
+          os << ", ";
+        }
+
+        os << (*iter);
+      }
+
+      os << "]";
+
+    }
+
+    return os;
+
+  }
+#endif
+
+
+  Node complexSelectorToNode(Complex_Selector* pToConvert) {
+    if (pToConvert == NULL) {
+      return Node::createNil();
+    }
+    Node node = Node::createCollection();
+    node.got_line_feed = pToConvert->has_line_feed();
+    bool has_lf = pToConvert->has_line_feed();
+
+    // unwrap the selector from parent ref
+    if (pToConvert->head() && pToConvert->head()->has_parent_ref()) {
+      Complex_Selector_Obj tail = pToConvert->tail();
+      if (tail) tail->has_line_feed(pToConvert->has_line_feed());
+      pToConvert = tail;
+    }
+
+    while (pToConvert) {
+
+      bool empty_parent_ref = pToConvert->head() && pToConvert->head()->is_empty_reference();
+
+      // 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;
+      }
+
+      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;
+      }
+
+      if (pToConvert && empty_parent_ref && pToConvert->tail()) {
+        // pToConvert->tail()->has_line_feed(pToConvert->has_line_feed());
+      }
+
+      pToConvert = pToConvert->tail();
+    }
+
+    return node;
+  }
+
+
+  Complex_Selector* nodeToComplexSelector(const Node& toConvert) {
+    if (toConvert.isNil()) {
+      return NULL;
+    }
+
+
+    if (!toConvert.isCollection()) {
+      throw "The node to convert to a Complex_Selector* must be a collection type or nil.";
+    }
+
+
+    NodeDeque& childNodes = *toConvert.collection();
+
+    std::string noPath("");
+    Complex_Selector_Obj pFirst = SASS_MEMORY_NEW(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, {}, {});
+
+    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);
+
+    for (NodeDeque::iterator childIter = childNodes.begin(), childIterEnd = childNodes.end(); childIter != childIterEnd; childIter++) {
+
+      Node& child = *childIter;
+
+      if (child.isSelector()) {
+        // 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();
+      } 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 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(Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, {}, {}));
+            if (nextNode.got_line_feed) pCurrent->tail()->has_line_feed(nextNode.got_line_feed);
+            pCurrent = pCurrent->tail();
+          }
+        }
+      } else {
+        throw "The node to convert's children must be only combinators or selectors.";
+      }
+    }
+
+    // Put the dummy Compound_Selector in the first position, for consistency with the rest of libsass
+    Compound_Selector* fakeHead = SASS_MEMORY_NEW(Compound_Selector, ParserState("[NODE]"), 1);
+    Parent_Selector* 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 SASS_MEMORY_COPY(pFirst);
+  }
+
+  // A very naive trim function, which removes duplicates in a node
+  // This is only used in Complex_Selector::unify_with for now, may need modifications to fit other needs
+  Node Node::naiveTrim(Node& seqses) {
+
+    std::vector<Node*> res;
+    std::vector<Complex_Selector_Obj> known;
+
+    NodeDeque::reverse_iterator seqsesIter = seqses.collection()->rbegin(),
+                                seqsesIterEnd = seqses.collection()->rend();
+
+    for (; seqsesIter != seqsesIterEnd; ++seqsesIter)
+    {
+      Node& seqs1 = *seqsesIter;
+      if( seqs1.isSelector() ) {
+        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; }
+        }
+        if( !found ) {
+          known.push_back(seqs1.selector());
+          res.push_back(&seqs1);
+        }
+      } else {
+        res.push_back(&seqs1);
+      }
+    }
+
+    Node result = Node::createCollection();
+
+    for (size_t i = res.size() - 1; i != std::string::npos; --i) {
+      result.collection()->push_back(*res[i]);
+    }
+
+    return result;
+  }
+}

data/vendor/ruby/2.6.0/gems/sassc-2.1.0-x86_64-linux/ext/libsass/src/node.hpp

@@ -0,0 +1,118 @@
+#ifndef SASS_NODE_H
+#define SASS_NODE_H
+
+#include <deque>
+#include <memory>
+
+#include "ast.hpp"
+
+
+namespace Sass {
+
+
+
+
+  class Context;
+
+  /*
+   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 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
+   able to represent all of these as unique cases, we need to create a tree of variant objects. The tree nature allows
+   the inconsistent nesting levels. The variant nature (while making some of the C++ code uglier) allows the code to
+   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 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.
+   */
+
+  class Node;
+  typedef std::deque<Node> NodeDeque;
+  typedef std::shared_ptr<NodeDeque> NodeDequePtr;
+
+  class Node {
+  public:
+    enum TYPE {
+      SELECTOR,
+      COMBINATOR,
+      COLLECTION,
+      NIL
+    };
+
+    TYPE type() const { return mType; }
+    bool isCombinator() const { return mType == COMBINATOR; }
+    bool isSelector() const { return mType == SELECTOR; }
+    bool isCollection() const { return mType == COLLECTION; }
+    bool isNil() const { return mType == NIL; }
+    bool got_line_feed;
+
+    Complex_Selector::Combinator combinator() const { return mCombinator; }
+
+    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 Complex_Selector::Combinator& combinator);
+
+    // This method will klone the selector, stripping off the tail and combinator
+    static Node createSelector(const Complex_Selector& pSelector);
+
+    static Node createCollection();
+    static Node createCollection(const NodeDeque& values);
+
+    static Node createNil();
+    static Node naiveTrim(Node& seqses);
+
+    Node klone() const;
+
+    bool operator==(const Node& rhs) const;
+    inline bool operator!=(const Node& rhs) const { return !(*this == rhs); }
+
+
+    /*
+    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 Complex_Selector
+    whereever possible). The following methods are intended to be called on Node objects whose
+    type is COLLECTION only.
+    */
+
+    // rhs and this must be node collections. Shallow copy the nodes from rhs to the end of this.
+    // This function DOES NOT remove the nodes from rhs.
+    void plus(Node& rhs);
+
+    // potentialChild must be a node collection of selectors/combinators. this must be a collection
+    // of collections of nodes/combinators. This method checks if potentialChild is a child of this
+    // Node.
+    bool contains(const Node& potentialChild) const;
+
+  private:
+    // 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, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection);
+
+    TYPE mType;
+
+    // TODO: can we union these to save on memory?
+    Complex_Selector::Combinator mCombinator;
+    Complex_Selector_Obj mpSelector;
+    NodeDequePtr mpCollection;
+  };
+
+#ifdef DEBUG
+  std::ostream& operator<<(std::ostream& os, const Node& node);
+#endif
+  Node complexSelectorToNode(Complex_Selector* pToConvert);
+  Complex_Selector* nodeToComplexSelector(const Node& toConvert);
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.1.0-x86_64-linux/ext/libsass/src/operation.hpp

@@ -0,0 +1,213 @@
+#ifndef SASS_OPERATION_H
+#define SASS_OPERATION_H
+
+// base classes to implement curiously recurring template pattern (CRTP)
+// https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
+
+#include <stdexcept>
+
+#include "ast_fwd_decl.hpp"
+#include "ast_def_macros.hpp"
+
+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 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; \
+
+  // you must add operators to every class
+  // ensures `this` of actual instance type
+  // we therefore call the specific operator
+  // they are virtual so most specific is used
+  #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 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); } \
+
+  template<typename T>
+  class Operation {
+  public:
+    virtual T operator()(AST_Node* x)               = 0;
+    // 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;
+    // expressions
+    virtual T operator()(Null* x)                   = 0;
+    virtual T operator()(List* x)                   = 0;
+    virtual T operator()(Map* x)                    = 0;
+    virtual T operator()(Function* 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()(Custom_Warning* x)         = 0;
+    virtual T operator()(Custom_Error* x)           = 0;
+    virtual T operator()(Variable* x)               = 0;
+    virtual T operator()(Number* x)                 = 0;
+    virtual T operator()(Color* x)                  = 0;
+    virtual T operator()(Color_RGBA* x)             = 0;
+    virtual T operator()(Color_HSLA* 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()(Parent_Selector* x)        = 0;
+    virtual T operator()(Parent_Reference* 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;
+    // 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;
+  };
+
+  // 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
+  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()(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); }
+    // expressions
+    T operator()(Null* x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(List* x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Map* x)                    { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Function* 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()(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()(Number* x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Color* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Color_RGBA* x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Color_HSLA* 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()(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); }
+    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); }
+    // 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); }
+
+    // fallback with specific type U
+    // will be called if not overloaded
+    template <typename U> T fallback(U x)
+    {
+      throw std::runtime_error(
+        std::string(typeid(*this).name()) + ": CRTP not implemented for " + typeid(x).name());
+    }
+
+  };
+
+}
+
+#endif