sassc 2.1.0.pre3 → 2.4.0

data/ext/libsass/src/cssize.hpp

@@ -12,58 +12,52 @@ namespace Sass {
 
   class Cssize : public Operation_CRTP<Statement*, Cssize> {
 
-    Context&                    ctx;
     Backtraces&                 traces;
     BlockStack      block_stack;
-    std::vector<Statement*>  p_stack;
+    sass::vector<Statement*>  p_stack;
 
   public:
     Cssize(Context&);
     ~Cssize() { }
 
-    Selector_List* selector();
-
     Block* operator()(Block*);
-    Statement* operator()(Ruleset*);
+    Statement* operator()(StyleRule*);
     // Statement* operator()(Bubble*);
-    Statement* operator()(Media_Block*);
-    Statement* operator()(Supports_Block*);
-    Statement* operator()(At_Root_Block*);
-    Statement* operator()(Directive*);
+    Statement* operator()(CssMediaRule*);
+    Statement* operator()(SupportsRule*);
+    Statement* operator()(AtRootRule*);
+    Statement* operator()(AtRule*);
     Statement* operator()(Keyframe_Rule*);
     Statement* operator()(Trace*);
     Statement* operator()(Declaration*);
     // Statement* operator()(Assignment*);
     // Statement* operator()(Import*);
     // Statement* operator()(Import_Stub*);
-    // Statement* operator()(Warning*);
+    // Statement* operator()(WarningRule*);
     // Statement* operator()(Error*);
     // Statement* operator()(Comment*);
     // Statement* operator()(If*);
-    // Statement* operator()(For*);
-    // Statement* operator()(Each*);
-    // Statement* operator()(While*);
+    // Statement* operator()(ForRule*);
+    // Statement* operator()(EachRule*);
+    // Statement* operator()(WhileRule*);
     // Statement* operator()(Return*);
-    // Statement* operator()(Extension*);
+    // Statement* operator()(ExtendRule*);
     // Statement* operator()(Definition*);
     // Statement* operator()(Mixin_Call*);
     // Statement* operator()(Content*);
     Statement* operator()(Null*);
 
     Statement* parent();
-    std::vector<std::pair<bool, Block_Obj>> slice_by_bubble(Block*);
-    Statement* bubble(Directive*);
-    Statement* bubble(At_Root_Block*);
-    Statement* bubble(Media_Block*);
-    Statement* bubble(Supports_Block*);
+    sass::vector<std::pair<bool, Block_Obj>> slice_by_bubble(Block*);
+    Statement* bubble(AtRule*);
+    Statement* bubble(AtRootRule*);
+    Statement* bubble(CssMediaRule*);
+    Statement* bubble(SupportsRule*);
 
     Block* debubble(Block* children, Statement* parent = 0);
-    Block* flatten(Block*);
+    Block* flatten(const Block*);
     bool bubblable(Statement*);
 
-    List* merge_media_queries(Media_Block*, Media_Block*);
-    Media_Query* merge_media_query(Media_Query*, Media_Query*);
-
     // generic fallback
     template <typename U>
     Statement* fallback(U x)

data/ext/libsass/src/dart_helpers.hpp

@@ -0,0 +1,199 @@
+#ifndef SASS_DART_HELPERS_H
+#define SASS_DART_HELPERS_H
+
+#include <vector>
+#include <utility>
+#include <iterator>
+#include <functional>
+
+namespace Sass {
+
+  // ##########################################################################
+  // Flatten `vector<vector<T>>` to `vector<T>`
+  // ##########################################################################
+  template <class T>
+  T flatten(const sass::vector<T>& all)
+  {
+    T flattened;
+    for (const auto& sub : all) {
+      std::copy(std::begin(sub), std::end(sub),
+        std::back_inserter(flattened));
+    }
+    return flattened;
+  }
+
+  // ##########################################################################
+  // Expands each element of this Iterable into zero or more elements.
+  // Calls a function on every element and ads all results to flat array
+  // ##########################################################################
+  // Equivalent to dart `cnt.any`
+  // Pass additional closure variables to `fn`
+  template <class T, class U, typename ...Args>
+  T expand(const T& cnt, U fn, Args... args) {
+    T flattened;
+    for (const auto& sub : cnt) {
+      auto rv = fn(sub, args...);
+      flattened.insert(flattened.end(),
+        rv.begin(), rv.end());
+    }
+    return flattened;
+  }
+
+  // ##########################################################################
+  // ##########################################################################
+  template <class T>
+  T flattenInner(const sass::vector<T>& vec)
+  {
+    T outer;
+    for (const auto& sub : vec) {
+      outer.emplace_back(std::move(flatten(sub)));
+    }
+    return outer;
+  }
+  // EO flattenInner
+
+  // ##########################################################################
+  // Equivalent to dart `cnt.any`
+  // Pass additional closure variables to `fn`
+  // ##########################################################################
+  template <class T, class U, typename ...Args>
+  bool hasAny(const T& cnt, U fn, Args... args) {
+    for (const auto& sub : cnt) {
+      if (fn(sub, args...)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // EO hasAny
+
+  // ##########################################################################
+  // Equivalent to dart `cnt.take(len).any`
+  // Pass additional closure variables to `fn`
+  // ##########################################################################
+  template <class T, class U, typename ...Args>
+  bool hasSubAny(const T& cnt, size_t len, U fn, Args... args) {
+    for (size_t i = 0; i < len; i++) {
+      if (fn(cnt[i], args...)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // ##########################################################################
+  // Default predicate for lcs algorithm
+  // ##########################################################################
+  template <class T>
+  inline bool lcsIdentityCmp(const T& X, const T& Y, T& result)
+  {
+    // Assert equality
+    if (!ObjEqualityFn(X, Y)) {
+      return false;
+    }
+    // Store in reference
+    result = X;
+    // Return success
+    return true;
+  }
+  // EO lcsIdentityCmp
+
+  // ##########################################################################
+  // Longest common subsequence with predicate
+  // ##########################################################################
+  template <class T>
+  sass::vector<T> lcs(
+    const sass::vector<T>& X, const sass::vector<T>& Y,
+    bool(*select)(const T&, const T&, T&) = lcsIdentityCmp<T>)
+  {
+
+    std::size_t m = X.size(), mm = X.size() + 1;
+    std::size_t n = Y.size(), nn = Y.size() + 1;
+
+    if (m == 0) return {};
+    if (n == 0) return {};
+
+    // MSVC does not support variable-length arrays
+    // To circumvent, allocate one array on the heap
+    // Then use a macro to access via double index
+    // e.g. `size_t L[m][n]` is supported by gcc
+    size_t* len = new size_t[mm * nn + 1];
+    bool* acc = new bool[mm * nn + 1];
+    T* res = new T[mm * nn + 1];
+
+    #define LEN(x, y) len[(x) * nn + (y)]
+    #define ACC(x, y) acc[(x) * nn + (y)]
+    #define RES(x, y) res[(x) * nn + (y)]
+
+    /* Following steps build L[m+1][n+1] in bottom up fashion. Note
+      that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */
+    for (size_t i = 0; i <= m; i++) {
+      for (size_t j = 0; j <= n; j++) {
+        if (i == 0 || j == 0)
+          LEN(i, j) = 0;
+        else {
+          ACC(i - 1, j - 1) = select(X[i - 1], Y[j - 1], RES(i - 1, j - 1));
+          if (ACC(i - 1, j - 1))
+            LEN(i, j) = LEN(i - 1, j - 1) + 1;
+          else
+            LEN(i, j) = std::max(LEN(i - 1, j), LEN(i, j - 1));
+        }
+      }
+    }
+
+    // Following code is used to print LCS
+    sass::vector<T> lcs;
+    std::size_t index = LEN(m, n);
+    lcs.reserve(index);
+
+    // Start from the right-most-bottom-most corner
+    // and one by one store objects in lcs[]
+    std::size_t i = m, j = n;
+    while (i > 0 && j > 0) {
+
+      // If current objects in X[] and Y are same,
+      // then current object is part of LCS
+      if (ACC(i - 1, j - 1))
+      {
+        // Put the stored object in result
+        // Note: we push instead of unshift
+        // Note: reverse the vector later
+        // ToDo: is deque more performant?
+        lcs.push_back(RES(i - 1, j - 1));
+        // reduce values of i, j and index
+        i -= 1; j -= 1; index -= 1;
+      }
+
+      // If not same, then find the larger of two and
+      // go in the direction of larger value
+      else if (LEN(i - 1, j) > LEN(i, j - 1)) {
+        i--;
+      }
+      else {
+        j--;
+      }
+
+    }
+
+    // reverse now as we used push_back
+    std::reverse(lcs.begin(), lcs.end());
+
+    // Delete temp memory on heap
+    delete[] len;
+    delete[] acc;
+    delete[] res;
+
+    #undef LEN
+    #undef ACC
+    #undef RES
+
+    return lcs;
+  }
+  // EO lcs
+
+  // ##########################################################################
+  // ##########################################################################
+
+}
+
+#endif

data/ext/libsass/src/debugger.hpp

@@ -1,33 +1,292 @@
 #ifndef SASS_DEBUGGER_H
 #define SASS_DEBUGGER_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <queue>
+#include <vector>
 #include <string>
 #include <sstream>
-#include "node.hpp"
+#include "ast.hpp"
 #include "ast_fwd_decl.hpp"
+#include "extension.hpp"
+
+#include "ordered_map.hpp"
 
 using namespace Sass;
 
-inline void debug_ast(AST_Node* node, std::string ind = "", Env* env = 0);
+inline void debug_ast(AST_Node* node, sass::string ind = "", Env* env = 0);
 
-inline void debug_ast(const AST_Node* node, std::string ind = "", Env* env = 0) {
-  debug_ast(const_cast<AST_Node*>(node), ind, env);
+inline sass::string debug_vec(const AST_Node* node) {
+  if (node == NULL) return "null";
+  else return node->to_string();
 }
 
-inline void debug_sources_set(ComplexSelectorSet& set, std::string ind = "")
-{
-  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
-  for(auto const &pair : set) {
-    debug_ast(pair, ind + "");
-    // debug_ast(set[pair], ind + "first: ");
+inline sass::string debug_dude(sass::vector<sass::vector<int>> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinOut = false;
+  for (auto ct : vec) {
+    if (joinOut) out << ", ";
+    joinOut = true;
+    out << "{";
+    bool joinIn = false;
+    for (auto nr : ct) {
+      if (joinIn) out << ", ";
+      joinIn = true;
+      out << nr;
+    }
+    out << "}";
+  }
+  out << "}";
+  return out.str();
+}
+
+inline sass::string debug_vec(sass::string& str) {
+  return str;
+}
+
+inline sass::string debug_vec(Extension& ext) {
+  sass::sstream out;
+  out << debug_vec(ext.extender);
+  out << " {@extend ";
+  out << debug_vec(ext.target);
+  if (ext.isOptional) {
+    out << " !optional";
+  }
+  out << "}";
+  return out.str();
+}
+
+template <class T>
+inline sass::string debug_vec(sass::vector<T> vec) {
+  sass::sstream out;
+  out << "[";
+  for (size_t i = 0; i < vec.size(); i += 1) {
+    if (i > 0) out << ", ";
+    out << debug_vec(vec[i]);
+  }
+  out << "]";
+  return out.str();
+}
+
+template <class T>
+inline sass::string debug_vec(std::queue<T> vec) {
+  sass::sstream out;
+  out << "{";
+  for (size_t i = 0; i < vec.size(); i += 1) {
+    if (i > 0) out << ", ";
+    out << debug_vec(vec[i]);
+  }
+  out << "}";
+  return out.str();
+}
+
+template <class T, class U, class O>
+inline sass::string debug_vec(std::map<T, U, O> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(it->first) // string (key)
+      << ": "
+      << debug_vec(it->second); // string's value
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+template <class T, class U, class O, class V>
+inline sass::string debug_vec(const ordered_map<T, U, O, V>& vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(*it); // string (key)
+    // << debug_vec(it->second); // string's value
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+template <class T, class U, class O, class V>
+inline sass::string debug_vec(std::unordered_map<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(it->first) // string (key)
+      << ": "
+      << debug_vec(it->second); // string's value
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+template <class T, class U, class O, class V>
+inline sass::string debug_keys(std::unordered_map<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(it->first); // string (key)
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+inline sass::string debug_vec(ExtListSelSet& vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(*it); // string (key)
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+/*
+template <class T, class U, class O, class V>
+inline sass::string debug_values(tsl::ordered_map<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(const_cast<U&>(it->second)); // string's value
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+ 
+template <class T, class U, class O, class V>
+inline sass::string debug_vec(tsl::ordered_map<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(it->first) // string (key)
+      << ": "
+      << debug_vec(const_cast<U&>(it->second)); // string's value
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+template <class T, class U, class O, class V>
+inline sass::string debug_vals(tsl::ordered_map<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(const_cast<U&>(it->second)); // string's value
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+template <class T, class U, class O, class V>
+inline sass::string debug_keys(tsl::ordered_map<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto it = vec.begin(); it != vec.end(); it++)
+  {
+    if (joinit) out << ", ";
+    out << debug_vec(it->first);
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+*/
+
+template <class T, class U>
+inline sass::string debug_vec(std::set<T, U> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto item : vec) {
+    if (joinit) out << ", ";
+    out << debug_vec(item);
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+
+/*
+template <class T, class U, class O, class V>
+inline sass::string debug_vec(tsl::ordered_set<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto item : vec) {
+    if (joinit) out << ", ";
+    out << debug_vec(item);
+    joinit = true;
+  }
+  out << "}";
+  return out.str();
+}
+*/
+
+template <class T, class U, class O, class V>
+inline sass::string debug_vec(std::unordered_set<T, U, O, V> vec) {
+  sass::sstream out;
+  out << "{";
+  bool joinit = false;
+  for (auto item : vec) {
+    if (joinit) out << ", ";
+    out << debug_vec(item);
+    joinit = true;
   }
-  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
+  out << "}";
+  return out.str();
 }
 
-inline std::string str_replace(std::string str, const std::string& oldStr, const std::string& newStr)
+inline sass::string debug_bool(bool val) {
+  return val ? "true" : "false";
+}
+inline sass::string debug_vec(ExtSmplSelSet* node) {
+  if (node == NULL) return "null";
+  else return debug_vec(*node);
+}
+
+inline void debug_ast(const AST_Node* node, sass::string ind = "", Env* env = 0) {
+  debug_ast(const_cast<AST_Node*>(node), ind, env);
+}
+
+inline sass::string str_replace(sass::string str, const sass::string& oldStr, const sass::string& newStr)
 {
   size_t pos = 0;
-  while((pos = str.find(oldStr, pos)) != std::string::npos)
+  while((pos = str.find(oldStr, pos)) != sass::string::npos)
   {
      str.replace(pos, oldStr.length(), newStr);
      pos += newStr.length();
@@ -35,25 +294,26 @@ inline std::string str_replace(std::string str, const std::string& oldStr, const
   return str;
 }
 
-inline std::string prettyprint(const std::string& str) {
-  std::string clean = str_replace(str, "\n", "\\n");
+inline sass::string prettyprint(const sass::string& str) {
+  sass::string clean = str_replace(str, "\n", "\\n");
   clean = str_replace(clean, "	", "\\t");
   clean = str_replace(clean, "\r", "\\r");
   return clean;
 }
 
-inline std::string longToHex(long long t) {
-  std::stringstream is;
+inline sass::string longToHex(long long t) {
+  sass::sstream is;
   is << std::hex << t;
   return is.str();
 }
 
-inline std::string pstate_source_position(AST_Node* node)
+inline sass::string pstate_source_position(AST_Node* node)
 {
-  std::stringstream str;
-  Position start(node->pstate());
-  Position end(start + node->pstate().offset);
-  str << (start.file == std::string::npos ? -1 : start.file)
+  sass::sstream str;
+  Offset start(node->pstate().position);
+  Offset end(start + node->pstate().offset);
+  size_t file = node->pstate().getSrcId();
+  str << (file == sass::string::npos ? 99999999 : file)
     << "@[" << start.line << ":" << start.column << "]"
     << "-[" << end.line << ":" << end.column << "]";
 #ifdef DEBUG_SHARED_PTR
@@ -64,7 +324,7 @@ inline std::string pstate_source_position(AST_Node* node)
   return str.str();
 }
 
-inline void debug_ast(AST_Node* node, std::string ind, Env* env)
+inline void debug_ast(AST_Node* node, sass::string ind, Env* env)
 {
   if (node == 0) return;
   if (ind == "") std::cerr << "####################################################################\n";
@@ -82,194 +342,144 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     << " [name:" << trace->name() << ", type: " << trace->type() << "]"
     << std::endl;
     debug_ast(trace->block(), ind + " ", env);
-  } else if (Cast<At_Root_Block>(node)) {
-    At_Root_Block* root_block = Cast<At_Root_Block>(node);
-    std::cerr << ind << "At_Root_Block " << root_block;
+  } else if (Cast<AtRootRule>(node)) {
+    AtRootRule* root_block = Cast<AtRootRule>(node);
+    std::cerr << ind << "AtRootRule " << root_block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << root_block->tabs();
     std::cerr << std::endl;
     debug_ast(root_block->expression(), ind + ":", env);
     debug_ast(root_block->block(), ind + " ", env);
-  } else if (Cast<Selector_List>(node)) {
-    Selector_List* selector = Cast<Selector_List>(node);
-    std::cerr << ind << "Selector_List " << selector;
+  } else if (Cast<SelectorList>(node)) {
+    SelectorList* selector = Cast<SelectorList>(node);
+    std::cerr << ind << "SelectorList " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
-    std::cerr << " [@media:" << selector->media_block() << "]";
-    std::cerr << (selector->is_invisible() ? " [INVISIBLE]": " -");
-    std::cerr << (selector->has_placeholder() ? " [PLACEHOLDER]": " -");
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
+    std::cerr << (selector->is_invisible() ? " [is_invisible]" : " -");
+    std::cerr << (selector->isInvisible() ? " [isInvisible]" : " -");
+    std::cerr << (selector->has_real_parent_ref() ? " [real-parent]": " -");
     std::cerr << std::endl;
-    debug_ast(selector->schema(), ind + "#{} ");
 
-    for(const Complex_Selector_Obj& i : selector->elements()) { debug_ast(i, ind + " ", env); }
+    for(const ComplexSelector_Obj& i : selector->elements()) { debug_ast(i, ind + " ", env); }
 
-//  } else if (Cast<Expression>(node)) {
-//    Expression* expression = Cast<Expression>(node);
-//    std::cerr << ind << "Expression " << expression << " " << expression->concrete_type() << std::endl;
+  } else if (Cast<ComplexSelector>(node)) {
+    ComplexSelector* selector = Cast<ComplexSelector>(node);
+    std::cerr << ind << "ComplexSelector " << selector
+      << " (" << pstate_source_position(node) << ")"
+      << " <" << selector->hash() << ">"
+      << " [" << (selector->chroots() ? "CHROOT" : "CONNECT") << "]"
+      << " [length:" << longToHex(selector->length()) << "]"
+      << " [weight:" << longToHex(selector->specificity()) << "]"
+      << (selector->is_invisible() ? " [is_invisible]" : " -")
+      << (selector->isInvisible() ? " [isInvisible]" : " -")
+      << (selector->hasPreLineFeed() ? " [hasPreLineFeed]" : " -")
 
-  } else if (Cast<Parent_Reference>(node)) {
-    Parent_Reference* selector = Cast<Parent_Reference>(node);
-    std::cerr << ind << "Parent_Reference " << selector;
-//    if (selector->not_selector()) cerr << " [in_declaration]";
-    std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " <" << selector->hash() << ">";
-    std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
-//    debug_ast(selector->selector(), ind + "->", env);
+      // << (selector->is_invisible() ? " [INVISIBLE]": " -")
+      // << (selector->has_placeholder() ? " [PLACEHOLDER]": " -")
+      // << (selector->is_optional() ? " [is_optional]": " -")
+      << (selector->has_real_parent_ref() ? " [real parent]": " -")
+      // << (selector->has_line_feed() ? " [line-feed]": " -")
+      // << (selector->has_line_break() ? " [line-break]": " -")
+      << " -- \n";
 
-  } else if (Cast<Parent_Selector>(node)) {
-    Parent_Selector* selector = Cast<Parent_Selector>(node);
-    std::cerr << ind << "Parent_Selector " << selector;
-//    if (selector->not_selector()) cerr << " [in_declaration]";
-    std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " <" << selector->hash() << ">";
-    std::cerr << " [" << (selector->real() ? "REAL" : "FAKE") << "]";
-    std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
-//    debug_ast(selector->selector(), ind + "->", env);
+    for(const SelectorComponentObj& i : selector->elements()) { debug_ast(i, ind + " ", env); }
 
-  } else if (Cast<Complex_Selector>(node)) {
-    Complex_Selector* selector = Cast<Complex_Selector>(node);
-    std::cerr << ind << "Complex_Selector " << selector
+  } else if (Cast<SelectorCombinator>(node)) {
+    SelectorCombinator* selector = Cast<SelectorCombinator>(node);
+    std::cerr << ind << "SelectorCombinator " << selector
       << " (" << pstate_source_position(node) << ")"
       << " <" << selector->hash() << ">"
-      << " [length:" << longToHex(selector->length()) << "]"
       << " [weight:" << longToHex(selector->specificity()) << "]"
-      << " [@media:" << selector->media_block() << "]"
-      << (selector->is_invisible() ? " [INVISIBLE]": " -")
-      << (selector->has_placeholder() ? " [PLACEHOLDER]": " -")
-      << (selector->is_optional() ? " [is_optional]": " -")
-      << (selector->has_parent_ref() ? " [has parent]": " -")
-      << (selector->has_line_feed() ? " [line-feed]": " -")
-      << (selector->has_line_break() ? " [line-break]": " -")
+      << (selector->has_real_parent_ref() ? " [real parent]": " -")
       << " -- ";
-      std::string del;
+
+      sass::string del;
       switch (selector->combinator()) {
-        case Complex_Selector::PARENT_OF:   del = ">"; break;
-        case Complex_Selector::PRECEDES:    del = "~"; break;
-        case Complex_Selector::ADJACENT_TO: del = "+"; break;
-        case Complex_Selector::ANCESTOR_OF: del = " "; break;
-        case Complex_Selector::REFERENCE:   del = "//"; break;
+        case SelectorCombinator::CHILD:    del = ">"; break;
+        case SelectorCombinator::GENERAL:  del = "~"; break;
+        case SelectorCombinator::ADJACENT: del = "+"; break;
       }
-      // if (del = "/") del += selector->reference()->perform(&to_string) + "/";
-    std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
-    debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
-    if (selector->tail()) {
-      debug_ast(selector->tail(), ind + "{" + del + "}", env);
-    } else if(del != " ") {
-      std::cerr << ind << " |" << del << "| {trailing op}" << std::endl;
-    }
-    ComplexSelectorSet set = selector->sources();
-    // debug_sources_set(set, ind + "  @--> ");
-  } else if (Cast<Compound_Selector>(node)) {
-    Compound_Selector* selector = Cast<Compound_Selector>(node);
-    std::cerr << ind << "Compound_Selector " << selector;
+
+      std::cerr << "[" << del << "]" << "\n";
+
+  } else if (Cast<CompoundSelector>(node)) {
+    CompoundSelector* selector = Cast<CompoundSelector>(node);
+    std::cerr << ind << "CompoundSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
+    std::cerr << (selector->hasRealParent() ? " [REAL PARENT]" : "") << ">";
     std::cerr << " [weight:" << longToHex(selector->specificity()) << "]";
-    std::cerr << " [@media:" << selector->media_block() << "]";
-    std::cerr << (selector->extended() ? " [extended]": " -");
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
-    std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
-    for(const Simple_Selector_Obj& i : selector->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<Wrapped_Selector>(node)) {
-    Wrapped_Selector* selector = Cast<Wrapped_Selector>(node);
-    std::cerr << ind << "Wrapped_Selector " << selector;
+    std::cerr << (selector->hasPostLineBreak() ? " [hasPostLineBreak]" : " -");
+    std::cerr << (selector->is_invisible() ? " [is_invisible]" : " -");
+    std::cerr << (selector->isInvisible() ? " [isInvisible]" : " -");
+    std::cerr << "\n";
+    for(const SimpleSelector_Obj& i : selector->elements()) { debug_ast(i, ind + " ", env); }
+
+  } else if (Cast<Parent_Reference>(node)) {
+    Parent_Reference* selector = Cast<Parent_Reference>(node);
+    std::cerr << ind << "Parent_Reference " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
-    std::cerr << " <<" << selector->ns_name() << ">>";
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
     std::cerr << std::endl;
-    debug_ast(selector->selector(), ind + " () ", env);
-  } else if (Cast<Pseudo_Selector>(node)) {
-    Pseudo_Selector* selector = Cast<Pseudo_Selector>(node);
-    std::cerr << ind << "Pseudo_Selector " << selector;
+
+  } else if (Cast<PseudoSelector>(node)) {
+    PseudoSelector* selector = Cast<PseudoSelector>(node);
+    std::cerr << ind << "PseudoSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
     std::cerr << " <<" << selector->ns_name() << ">>";
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
+    std::cerr << (selector->isClass() ? " [isClass]": " -");
+    std::cerr << (selector->isSyntacticClass() ? " [isSyntacticClass]": " -");
     std::cerr << std::endl;
-    debug_ast(selector->expression(), ind + " <= ", env);
-  } else if (Cast<Attribute_Selector>(node)) {
-    Attribute_Selector* selector = Cast<Attribute_Selector>(node);
-    std::cerr << ind << "Attribute_Selector " << selector;
+    debug_ast(selector->argument(), ind + " <= ", env);
+    debug_ast(selector->selector(), ind + " || ", env);
+  } else if (Cast<AttributeSelector>(node)) {
+    AttributeSelector* selector = Cast<AttributeSelector>(node);
+    std::cerr << ind << "AttributeSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
     std::cerr << " <<" << selector->ns_name() << ">>";
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
     std::cerr << std::endl;
     debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
-  } else if (Cast<Class_Selector>(node)) {
-    Class_Selector* selector = Cast<Class_Selector>(node);
-    std::cerr << ind << "Class_Selector " << selector;
+  } else if (Cast<ClassSelector>(node)) {
+    ClassSelector* selector = Cast<ClassSelector>(node);
+    std::cerr << ind << "ClassSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
     std::cerr << " <<" << selector->ns_name() << ">>";
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
     std::cerr << std::endl;
-  } else if (Cast<Id_Selector>(node)) {
-    Id_Selector* selector = Cast<Id_Selector>(node);
-    std::cerr << ind << "Id_Selector " << selector;
+  } else if (Cast<IDSelector>(node)) {
+    IDSelector* selector = Cast<IDSelector>(node);
+    std::cerr << ind << "IDSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
     std::cerr << " <<" << selector->ns_name() << ">>";
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
     std::cerr << std::endl;
-  } else if (Cast<Type_Selector>(node)) {
-    Type_Selector* selector = Cast<Type_Selector>(node);
-    std::cerr << ind << "Type_Selector " << selector;
+  } else if (Cast<TypeSelector>(node)) {
+    TypeSelector* selector = Cast<TypeSelector>(node);
+    std::cerr << ind << "TypeSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
     std::cerr << " <<" << selector->ns_name() << ">>";
-    std::cerr << (selector->is_optional() ? " [is_optional]": " -");
-    std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -");
-    std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
-    std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">";
     std::cerr << std::endl;
-  } else if (Cast<Placeholder_Selector>(node)) {
+  } else if (Cast<PlaceholderSelector>(node)) {
 
-    Placeholder_Selector* selector = Cast<Placeholder_Selector>(node);
-    std::cerr << ind << "Placeholder_Selector [" << selector->ns_name() << "] " << selector;
+    PlaceholderSelector* selector = Cast<PlaceholderSelector>(node);
+    std::cerr << ind << "PlaceholderSelector [" << selector->ns_name() << "] " << selector;
     std::cerr << " (" << pstate_source_position(selector) << ")"
       << " <" << selector->hash() << ">"
-      << " [@media:" << selector->media_block() << "]"
-      << (selector->is_optional() ? " [is_optional]": " -")
-      << (selector->has_line_break() ? " [line-break]": " -")
-      << (selector->has_line_feed() ? " [line-feed]": " -")
+      << (selector->isInvisible() ? " [isInvisible]" : " -")
     << std::endl;
 
-  } else if (Cast<Simple_Selector>(node)) {
-    Simple_Selector* selector = Cast<Simple_Selector>(node);
-    std::cerr << ind << "Simple_Selector " << selector;
+  } else if (Cast<SimpleSelector>(node)) {
+    SimpleSelector* selector = Cast<SimpleSelector>(node);
+    std::cerr << ind << "SimpleSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << std::endl;
 
   } else if (Cast<Selector_Schema>(node)) {
     Selector_Schema* selector = Cast<Selector_Schema>(node);
     std::cerr << ind << "Selector_Schema " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")"
-      << " [@media:" << selector->media_block() << "]"
       << (selector->connect_parent() ? " [connect-parent]": " -")
     << std::endl;
 
@@ -279,9 +489,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
   } else if (Cast<Selector>(node)) {
     Selector* selector = Cast<Selector>(node);
     std::cerr << ind << "Selector " << selector;
-    std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << (selector->has_line_break() ? " [line-break]": " -")
-      << (selector->has_line_feed() ? " [line-feed]": " -")
+    std::cerr << " (" << pstate_source_position(node) << ")"
     << std::endl;
 
   } else if (Cast<Media_Query_Expression>(node)) {
@@ -302,31 +510,50 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     << std::endl;
     debug_ast(block->media_type(), ind + " ");
     for(const auto& i : block->elements()) { debug_ast(i, ind + " ", env); }
-
-  } else if (Cast<Media_Block>(node)) {
-    Media_Block* block = Cast<Media_Block>(node);
-    std::cerr << ind << "Media_Block " << block;
-    std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " " << block->tabs() << std::endl;
-    debug_ast(block->media_queries(), ind + " =@ ");
-    if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<Supports_Block>(node)) {
-    Supports_Block* block = Cast<Supports_Block>(node);
-    std::cerr << ind << "Supports_Block " << block;
+  }
+  else if (Cast<MediaRule>(node)) {
+    MediaRule* rule = Cast<MediaRule>(node);
+    std::cerr << ind << "MediaRule " << rule;
+    std::cerr << " (" << pstate_source_position(rule) << ")";
+    std::cerr << " " << rule->tabs() << std::endl;
+    debug_ast(rule->schema(), ind + " =@ ");
+    debug_ast(rule->block(), ind + " ");
+  }
+  else if (Cast<CssMediaRule>(node)) {
+    CssMediaRule* rule = Cast<CssMediaRule>(node);
+    std::cerr << ind << "CssMediaRule " << rule;
+    std::cerr << " (" << pstate_source_position(rule) << ")";
+    std::cerr << " " << rule->tabs() << std::endl;
+    for (auto item : rule->elements()) {
+      debug_ast(item, ind + " == ");
+    }
+    debug_ast(rule->block(), ind + " ");
+  }
+  else if (Cast<CssMediaQuery>(node)) {
+    CssMediaQuery* query = Cast<CssMediaQuery>(node);
+    std::cerr << ind << "CssMediaQuery " << query;
+    std::cerr << " (" << pstate_source_position(query) << ")";
+    std::cerr << " [" << (query->modifier()) << "] ";
+    std::cerr << " [" << (query->type()) << "] ";
+    std::cerr << " " << debug_vec(query->features());
+    std::cerr << std::endl;
+  } else if (Cast<SupportsRule>(node)) {
+    SupportsRule* block = Cast<SupportsRule>(node);
+    std::cerr << ind << "SupportsRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->condition(), ind + " =@ ");
     debug_ast(block->block(), ind + " <>");
-  } else if (Cast<Supports_Operator>(node)) {
-    Supports_Operator* block = Cast<Supports_Operator>(node);
-    std::cerr << ind << "Supports_Operator " << block;
+  } else if (Cast<SupportsOperation>(node)) {
+    SupportsOperation* block = Cast<SupportsOperation>(node);
+    std::cerr << ind << "SupportsOperation " << block;
     std::cerr << " (" << pstate_source_position(node) << ")"
     << std::endl;
     debug_ast(block->left(), ind + " left) ");
     debug_ast(block->right(), ind + " right) ");
-  } else if (Cast<Supports_Negation>(node)) {
-    Supports_Negation* block = Cast<Supports_Negation>(node);
-    std::cerr << ind << "Supports_Negation " << block;
+  } else if (Cast<SupportsNegation>(node)) {
+    SupportsNegation* block = Cast<SupportsNegation>(node);
+    std::cerr << ind << "SupportsNegation " << block;
     std::cerr << " (" << pstate_source_position(node) << ")"
     << std::endl;
     debug_ast(block->condition(), ind + " condition) ");
@@ -337,9 +564,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     << std::endl;
     debug_ast(block->feature(), ind + " feature) ");
     debug_ast(block->value(), ind + " value) ");
-  } else if (Cast<Supports_Declaration>(node)) {
-    Supports_Declaration* block = Cast<Supports_Declaration>(node);
-    std::cerr << ind << "Supports_Declaration " << block;
+  } else if (Cast<SupportsDeclaration>(node)) {
+    SupportsDeclaration* block = Cast<SupportsDeclaration>(node);
+    std::cerr << ind << "SupportsDeclaration " << block;
     std::cerr << " (" << pstate_source_position(node) << ")"
     << std::endl;
     debug_ast(block->feature(), ind + " feature) ");
@@ -349,22 +576,23 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << ind << "Block " << root_block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     if (root_block->is_root()) std::cerr << " [root]";
+    if (root_block->isInvisible()) std::cerr << " [isInvisible]";
     std::cerr << " " << root_block->tabs() << std::endl;
     for(const Statement_Obj& i : root_block->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<Warning>(node)) {
-    Warning* block = Cast<Warning>(node);
-    std::cerr << ind << "Warning " << block;
+  } else if (Cast<WarningRule>(node)) {
+    WarningRule* block = Cast<WarningRule>(node);
+    std::cerr << ind << "WarningRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->message(), ind + " : ");
-  } else if (Cast<Error>(node)) {
-    Error* block = Cast<Error>(node);
-    std::cerr << ind << "Error " << block;
+  } else if (Cast<ErrorRule>(node)) {
+    ErrorRule* block = Cast<ErrorRule>(node);
+    std::cerr << ind << "ErrorRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
-  } else if (Cast<Debug>(node)) {
-    Debug* block = Cast<Debug>(node);
-    std::cerr << ind << "Debug " << block;
+  } else if (Cast<DebugRule>(node)) {
+    DebugRule* block = Cast<DebugRule>(node);
+    std::cerr << ind << "DebugRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->value(), ind + " ");
@@ -372,8 +600,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     Comment* block = Cast<Comment>(node);
     std::cerr << ind << "Comment " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " " << block->tabs() <<
-      " <" << prettyprint(block->pstate().token.ws_before()) << ">" << std::endl;
+    std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->text(), ind + "// ", env);
   } else if (Cast<If>(node)) {
     If* block = Cast<If>(node);
@@ -387,10 +614,11 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     Return* block = Cast<Return>(node);
     std::cerr << ind << "Return " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " " << block->tabs() << std::endl;
-  } else if (Cast<Extension>(node)) {
-    Extension* block = Cast<Extension>(node);
-    std::cerr << ind << "Extension " << block;
+    std::cerr << " " << block->tabs();
+    std::cerr << " [" << block->value()->to_string() << "]" << std::endl;
+  } else if (Cast<ExtendRule>(node)) {
+    ExtendRule* block = Cast<ExtendRule>(node);
+    std::cerr << ind << "ExtendRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->selector(), ind + "-> ", env);
@@ -411,7 +639,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << ind << "Import " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
-    // std::vector<std::string>         files_;
+    // sass::vector<sass::string>         files_;
     for (auto imp : block->urls()) debug_ast(imp, ind + "@: ", env);
     debug_ast(block->import_queries(), ind + "@@ ");
   } else if (Cast<Assignment>(node)) {
@@ -430,35 +658,35 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     debug_ast(block->value(), ind + " value: ", env);
     debug_ast(block->block(), ind + " ", env);
   } else if (Cast<Keyframe_Rule>(node)) {
-    Keyframe_Rule* has_block = Cast<Keyframe_Rule>(node);
-    std::cerr << ind << "Keyframe_Rule " << has_block;
+    Keyframe_Rule* ParentStatement = Cast<Keyframe_Rule>(node);
+    std::cerr << ind << "Keyframe_Rule " << ParentStatement;
     std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " " << has_block->tabs() << std::endl;
-    if (has_block->name()) debug_ast(has_block->name(), ind + "@");
-    if (has_block->block()) for(const Statement_Obj& i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<Directive>(node)) {
-    Directive* block = Cast<Directive>(node);
-    std::cerr << ind << "Directive " << block;
+    std::cerr << " " << ParentStatement->tabs() << std::endl;
+    if (ParentStatement->name()) debug_ast(ParentStatement->name(), ind + "@");
+    if (ParentStatement->block()) for(const Statement_Obj& i : ParentStatement->block()->elements()) { debug_ast(i, ind + " ", env); }
+  } else if (Cast<AtRule>(node)) {
+    AtRule* block = Cast<AtRule>(node);
+    std::cerr << ind << "AtRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " [" << block->keyword() << "] " << block->tabs() << std::endl;
     debug_ast(block->selector(), ind + "~", env);
     debug_ast(block->value(), ind + "+", env);
     if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<Each>(node)) {
-    Each* block = Cast<Each>(node);
-    std::cerr << ind << "Each " << block;
+  } else if (Cast<EachRule>(node)) {
+    EachRule* block = Cast<EachRule>(node);
+    std::cerr << ind << "EachRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<For>(node)) {
-    For* block = Cast<For>(node);
-    std::cerr << ind << "For " << block;
+  } else if (Cast<ForRule>(node)) {
+    ForRule* block = Cast<ForRule>(node);
+    std::cerr << ind << "ForRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (Cast<While>(node)) {
-    While* block = Cast<While>(node);
-    std::cerr << ind << "While " << block;
+  } else if (Cast<WhileRule>(node)) {
+    WhileRule* block = Cast<WhileRule>(node);
+    std::cerr << ind << "WhileRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
@@ -483,8 +711,8 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     debug_ast(block->arguments(), ind + " args: ", env);
     debug_ast(block->block_parameters(), ind + " block_params: ", env);
     if (block->block()) debug_ast(block->block(), ind + " ", env);
-  } else if (Ruleset* ruleset = Cast<Ruleset>(node)) {
-    std::cerr << ind << "Ruleset " << ruleset;
+  } else if (StyleRule* ruleset = Cast<StyleRule>(node)) {
+    std::cerr << ind << "StyleRule " << ruleset;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " [indent: " << ruleset->tabs() << "]";
     std::cerr << (ruleset->is_invisible() ? " [INVISIBLE]" : "");
@@ -505,7 +733,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " [" << expression->name() << "]" << std::endl;
-    std::string name(expression->name());
+    sass::string name(expression->name());
     if (env && env->has(name)) debug_ast(Cast<Expression>((*env)[name]), ind + " -> ", env);
   } else if (Cast<Function_Call>(node)) {
     Function_Call* expression = Cast<Function_Call>(node);
@@ -652,7 +880,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     if (expression->is_delayed()) std::cerr << " [delayed]";
     if (expression->is_interpolant()) std::cerr << " [interpolant]";
     if (expression->quote_mark()) std::cerr << " [quote_mark: " << expression->quote_mark() << "]";
-    std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
+    std::cerr << std::endl;
   } else if (Cast<String_Constant>(node)) {
     String_Constant* expression = Cast<String_Constant>(node);
     std::cerr << ind << "String_Constant " << expression;
@@ -663,7 +891,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " [" << prettyprint(expression->value()) << "]";
     if (expression->is_delayed()) std::cerr << " [delayed]";
     if (expression->is_interpolant()) std::cerr << " [interpolant]";
-    std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
+    std::cerr << std::endl;
   } else if (Cast<String_Schema>(node)) {
     String_Schema* expression = Cast<String_Schema>(node);
     std::cerr << ind << "String_Schema " << expression;
@@ -676,7 +904,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     if (expression->has_interpolant()) std::cerr << " [has interpolant]";
     if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
     if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
-    std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
+    std::cerr << std::endl;
     for(const auto& i : expression->elements()) { debug_ast(i, ind + " ", env); }
   } else if (Cast<String>(node)) {
     String* expression = Cast<String>(node);
@@ -684,7 +912,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " " << expression->concrete_type();
     std::cerr << " (" << pstate_source_position(node) << ")";
     if (expression->is_interpolant()) std::cerr << " [interpolant]";
-    std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
+    std::cerr << std::endl;
   } else if (Cast<Expression>(node)) {
     Expression* expression = Cast<Expression>(node);
     std::cerr << ind << "Expression " << expression;
@@ -708,12 +936,12 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
       case Expression::Type::PARENT: std::cerr << " [PARENT]"; break;
     }
     std::cerr << std::endl;
-  } else if (Cast<Has_Block>(node)) {
-    Has_Block* has_block = Cast<Has_Block>(node);
-    std::cerr << ind << "Has_Block " << has_block;
+  } else if (Cast<ParentStatement>(node)) {
+    ParentStatement* parent = Cast<ParentStatement>(node);
+    std::cerr << ind << "ParentStatement " << parent;
     std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " " << has_block->tabs() << std::endl;
-    if (has_block->block()) for(const Statement_Obj& i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
+    std::cerr << " " << parent->tabs() << std::endl;
+    if (parent->block()) for(const Statement_Obj& i : parent->block()->elements()) { debug_ast(i, ind + " ", env); }
   } else if (Cast<Statement>(node)) {
     Statement* statement = Cast<Statement>(node);
     std::cerr << ind << "Statement " << statement;
@@ -724,84 +952,12 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
   if (ind == "") std::cerr << "####################################################################\n";
 }
 
-inline void debug_node(Node* node, std::string ind = "")
-{
-  if (ind == "") std::cerr << "#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
-  if (node->isCombinator()) {
-    std::cerr << ind;
-    std::cerr << "Combinator ";
-    std::cerr << node << " ";
-    if (node->got_line_feed) std::cerr << "[LF] ";
-    switch (node->combinator()) {
-      case Complex_Selector::ADJACENT_TO: std::cerr << "{+} "; break;
-      case Complex_Selector::PARENT_OF:   std::cerr << "{>} "; break;
-      case Complex_Selector::PRECEDES:    std::cerr << "{~} "; break;
-      case Complex_Selector::REFERENCE:   std::cerr << "{@} "; break;
-      case Complex_Selector::ANCESTOR_OF: std::cerr << "{ } "; break;
-    }
-    std::cerr << std::endl;
-    // debug_ast(node->combinator(), ind + "  ");
-  } else if (node->isSelector()) {
-    std::cerr << ind;
-    std::cerr << "Selector ";
-    std::cerr << node << " ";
-    if (node->got_line_feed) std::cerr << "[LF] ";
-    std::cerr << std::endl;
-    debug_ast(node->selector(), ind + "  ");
-  } else if (node->isCollection()) {
-    std::cerr << ind;
-    std::cerr << "Collection ";
-    std::cerr << node << " ";
-    if (node->got_line_feed) std::cerr << "[LF] ";
-    std::cerr << std::endl;
-    for(auto n : (*node->collection())) {
-      debug_node(&n, ind + "  ");
-    }
-  } else if (node->isNil()) {
-    std::cerr << ind;
-    std::cerr << "Nil ";
-    std::cerr << node << " ";
-    if (node->got_line_feed) std::cerr << "[LF] ";
-    std::cerr << std::endl;
-  } else {
-    std::cerr << ind;
-    std::cerr << "OTHER ";
-    std::cerr << node << " ";
-    if (node->got_line_feed) std::cerr << "[LF] ";
-    std::cerr << std::endl;
-  }
-  if (ind == "") std::cerr << "#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
-}
 
 /*
-inline void debug_ast(const AST_Node* node, std::string ind = "", Env* env = 0)
+inline void debug_ast(const AST_Node* node, sass::string ind = "", Env* env = 0)
 {
   debug_ast(const_cast<AST_Node*>(node), ind, env);
 }
 */
-inline void debug_node(const Node* node, std::string ind = "")
-{
-  debug_node(const_cast<Node*>(node), ind);
-}
-
-inline void debug_subset_map(Sass::Subset_Map& map, std::string ind = "")
-{
-  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
-  for(auto const &it : map.values()) {
-    debug_ast(it.first, ind + "first: ");
-    debug_ast(it.second, ind + "second: ");
-  }
-  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
-}
-
-inline void debug_subset_entries(SubSetMapPairs* entries, std::string ind = "")
-{
-  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
-  for(auto const &pair : *entries) {
-    debug_ast(pair.first, ind + "first: ");
-    debug_ast(pair.second, ind + "second: ");
-  }
-  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
-}
 
 #endif // SASS_DEBUGGER