sassc 2.0.0 → 2.4.0

data/ext/libsass/src/backtrace.cpp

@@ -2,20 +2,20 @@
 
 namespace Sass {
 
-  const std::string traces_to_string(Backtraces traces, std::string indent) {
+  const sass::string traces_to_string(Backtraces traces, sass::string indent) {
 
-    std::stringstream ss;
-    std::string cwd(File::get_cwd());
+    sass::ostream ss;
+    sass::string cwd(File::get_cwd());
 
     bool first = true;
     size_t i_beg = traces.size() - 1;
-    size_t i_end = std::string::npos;
+    size_t i_end = sass::string::npos;
     for (size_t i = i_beg; i != i_end; i --) {
 
       const Backtrace& trace = traces[i];
 
       // make path relative to the current directory
-      std::string rel_path(File::abs2rel(trace.pstate.path, cwd, cwd));
+      sass::string rel_path(File::abs2rel(trace.pstate.getPath(), cwd, cwd));
 
       // skip functions on error cases (unsure why ruby sass does this)
       // if (trace.caller.substr(0, 6) == ", in f") continue;
@@ -23,7 +23,9 @@ namespace Sass {
       if (first) {
         ss << indent;
         ss << "on line ";
-        ss << trace.pstate.line + 1;
+        ss << trace.pstate.getLine();
+        ss << ":";
+        ss << trace.pstate.getColumn();
         ss << " of " << rel_path;
         // ss << trace.caller;
         first = false;
@@ -32,7 +34,9 @@ namespace Sass {
         ss << std::endl;
         ss << indent;
         ss << "from line ";
-        ss << trace.pstate.line + 1;
+        ss << trace.pstate.getLine();
+        ss << ":";
+        ss << trace.pstate.getColumn();
         ss << " of " << rel_path;
       }
 

data/ext/libsass/src/backtrace.hpp

@@ -10,19 +10,19 @@ namespace Sass {
 
   struct Backtrace {
 
-    ParserState pstate;
-    std::string caller;
+    SourceSpan pstate;
+    sass::string caller;
 
-    Backtrace(ParserState pstate, std::string c = "")
+    Backtrace(SourceSpan pstate, sass::string c = "")
     : pstate(pstate),
       caller(c)
     { }
 
   };
 
-  typedef std::vector<Backtrace> Backtraces;
+  typedef sass::vector<Backtrace> Backtraces;
 
-  const std::string traces_to_string(Backtraces traces, std::string indent = "\t");
+  const sass::string traces_to_string(Backtraces traces, sass::string indent = "\t");
 
 }
 

data/ext/libsass/src/base64vlq.cpp

@@ -1,11 +1,14 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "base64vlq.hpp"
 
 namespace Sass {
 
-  std::string Base64VLQ::encode(const int number) const
+  sass::string Base64VLQ::encode(const int number) const
   {
-    std::string encoded = "";
+    sass::string encoded = "";
 
     int vlq = to_vlq_signed(number);
 

data/ext/libsass/src/base64vlq.hpp

@@ -9,7 +9,7 @@ namespace Sass {
 
   public:
 
-    std::string encode(const int number) const;
+    sass::string encode(const int number) const;
 
   private:
 

data/ext/libsass/src/bind.cpp

@@ -1,6 +1,7 @@
 #include "sass.hpp"
 #include "bind.hpp"
 #include "ast.hpp"
+#include "backtrace.hpp"
 #include "context.hpp"
 #include "expand.hpp"
 #include "eval.hpp"
@@ -10,11 +11,11 @@
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Context* ctx, Env* env, Eval* eval)
+  void bind(sass::string type, sass::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
   {
-    std::string callee(type + " " + name);
+    sass::string callee(type + " " + name);
 
-    std::map<std::string, Parameter_Obj> param_map;
+    std::map<sass::string, Parameter_Obj> param_map;
     List_Obj varargs = SASS_MEMORY_NEW(List, as->pstate());
     varargs->is_arglist(true); // enable keyword size handling
 
@@ -51,10 +52,10 @@ namespace Sass {
             }
           }
         }
-        std::stringstream msg;
+        sass::ostream msg;
         msg << "wrong number of arguments (" << LA << " for " << LP << ")";
         msg << " for `" << name << "'";
-        return error(msg.str(), as->pstate(), eval->exp.traces);
+        return error(msg.str(), as->pstate(), traces);
       }
       Parameter_Obj p = ps->at(ip);
 
@@ -66,13 +67,13 @@ namespace Sass {
           // We should always get a list for rest arguments
           if (List_Obj rest = Cast<List>(a->value())) {
               // create a new list object for wrapped items
-              List_Ptr arglist = SASS_MEMORY_NEW(List,
+              List* arglist = SASS_MEMORY_NEW(List,
                                               p->pstate(),
                                               0,
                                               rest->separator(),
                                               true);
               // wrap each item from list as an argument
-              for (Expression_Obj item : rest->elements()) {
+              for (ExpressionObj item : rest->elements()) {
                 if (Argument_Obj arg = Cast<Argument>(item)) {
                   arglist->append(SASS_MEMORY_COPY(arg)); // copy
                 } else {
@@ -94,12 +95,12 @@ namespace Sass {
         } else if (a->is_keyword_argument()) {
 
           // expand keyword arguments into their parameters
-          List_Ptr arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
+          List* arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
           Map_Obj argmap = Cast<Map>(a->value());
           for (auto key : argmap->keys()) {
             if (String_Constant_Obj str = Cast<String_Constant>(key)) {
-              std::string param = unquote(str->value());
+              sass::string param = unquote(str->value());
               arglist->append(SASS_MEMORY_NEW(Argument,
                                               key->pstate(),
                                               argmap->at(key),
@@ -107,8 +108,8 @@ namespace Sass {
                                               false,
                                               false));
             } else {
-              eval->exp.traces.push_back(Backtrace(key->pstate()));
-              throw Exception::InvalidVarKwdType(key->pstate(), eval->exp.traces, key->inspect(), a);
+              traces.push_back(Backtrace(key->pstate()));
+              throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
             }
           }
 
@@ -129,7 +130,7 @@ namespace Sass {
             // skip any list completely if empty
             if (ls && ls->empty() && a->is_rest_argument()) continue;
 
-            Expression_Obj value = a->value();
+            ExpressionObj value = a->value();
             if (Argument_Obj arg = Cast<Argument>(value)) {
               arglist->append(arg);
             }
@@ -140,7 +141,7 @@ namespace Sass {
                 arglist->separator(rest->separator());
 
                 for (size_t i = 0, L = rest->length(); i < L; ++i) {
-                  Expression_Obj obj = rest->value_at_index(i);
+                  ExpressionObj obj = rest->value_at_index(i);
                   arglist->append(SASS_MEMORY_NEW(Argument,
                                                 obj->pstate(),
                                                 obj,
@@ -167,7 +168,7 @@ namespace Sass {
         }
         // consumed parameter
         ++ip;
-        // no more paramaters
+        // no more parameters
         break;
       }
 
@@ -176,7 +177,7 @@ namespace Sass {
         // normal param and rest arg
         List_Obj arglist = Cast<List>(a->value());
         if (!arglist) {
-          if (Expression_Obj arg = Cast<Expression>(a->value())) {
+          if (ExpressionObj arg = Cast<Expression>(a->value())) {
             arglist = SASS_MEMORY_NEW(List, a->pstate(), 1);
             arglist->append(arg);
           }
@@ -188,7 +189,7 @@ namespace Sass {
         } else {
           if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {
             size_t arg_count = (arglist->length() + LA - 1);
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " takes " << LP;
             msg << (LP == 1 ? " argument" : " arguments");
             msg << " but " << arg_count;
@@ -201,9 +202,9 @@ namespace Sass {
           }
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
-        Expression_Obj obj = arglist->at(0);
+        ExpressionObj obj = arglist->at(0);
         if (!(a = Cast<Argument>(obj))) {
-          Expression_Ptr a_to_convert = obj;
+          Expression* a_to_convert = obj;
           a = SASS_MEMORY_NEW(Argument,
                               a_to_convert->pstate(),
                               a_to_convert,
@@ -220,17 +221,17 @@ namespace Sass {
         Map_Obj argmap = Cast<Map>(a->value());
 
         for (auto key : argmap->keys()) {
-          String_Constant_Ptr val = Cast<String_Constant>(key);
+          String_Constant* val = Cast<String_Constant>(key);
           if (val == NULL) {
-            eval->exp.traces.push_back(Backtrace(key->pstate()));
-            throw Exception::InvalidVarKwdType(key->pstate(), eval->exp.traces, key->inspect(), a);
+            traces.push_back(Backtrace(key->pstate()));
+            throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
           }
-          std::string param = "$" + unquote(val->value());
+          sass::string param = "$" + unquote(val->value());
 
           if (!param_map.count(param)) {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " has no parameter named " << param;
-            error(msg.str(), a->pstate(), eval->exp.traces);
+            error(msg.str(), a->pstate(), traces);
           }
           env->local_frame()[param] = argmap->at(key);
         }
@@ -242,10 +243,10 @@ namespace Sass {
 
       if (a->name().empty()) {
         if (env->has_local(p->name())) {
-          std::stringstream msg;
+          sass::ostream msg;
           msg << "parameter " << p->name()
           << " provided more than once in call to " << callee;
-          error(msg.str(), a->pstate(), eval->exp.traces);
+          error(msg.str(), a->pstate(), traces);
         }
         // ordinal arg -- bind it to the next param
         env->local_frame()[p->name()] = a->value();
@@ -257,24 +258,24 @@ namespace Sass {
           if (ps->has_rest_parameter()) {
             varargs->append(a);
           } else {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " has no parameter named " << a->name();
-            error(msg.str(), a->pstate(), eval->exp.traces);
+            error(msg.str(), a->pstate(), traces);
           }
         }
         if (param_map[a->name()]) {
           if (param_map[a->name()]->is_rest_parameter()) {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << "argument " << a->name() << " of " << callee
                 << "cannot be used as named argument";
-            error(msg.str(), a->pstate(), eval->exp.traces);
+            error(msg.str(), a->pstate(), traces);
           }
         }
         if (env->has_local(a->name())) {
-          std::stringstream msg;
+          sass::ostream msg;
           msg << "parameter " << p->name()
               << "provided more than once in call to " << callee;
-          error(msg.str(), a->pstate(), eval->exp.traces);
+          error(msg.str(), a->pstate(), traces);
         }
         env->local_frame()[a->name()] = a->value();
       }
@@ -294,12 +295,12 @@ namespace Sass {
           env->local_frame()[leftover->name()] = varargs;
         }
         else if (leftover->default_value()) {
-          Expression_Ptr dv = leftover->default_value()->perform(eval);
+          Expression* dv = leftover->default_value()->perform(eval);
           env->local_frame()[leftover->name()] = dv;
         }
         else {
           // param is unbound and has no default value -- error
-          throw Exception::MissingArgument(as->pstate(), eval->exp.traces, name, leftover->name(), type);
+          throw Exception::MissingArgument(as->pstate(), traces, name, leftover->name(), type);
         }
       }
     }

data/ext/libsass/src/bind.hpp

@@ -2,12 +2,14 @@
 #define SASS_BIND_H
 
 #include <string>
+#include "backtrace.hpp"
 #include "environment.hpp"
 #include "ast_fwd_decl.hpp"
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Context*, Env*, Eval*);
+  void bind(sass::string type, sass::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
+
 }
 
 #endif

data/ext/libsass/src/c2ast.cpp

@@ -0,0 +1,64 @@
+#include "ast.hpp"
+#include "units.hpp"
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "sass/values.h"
+#include "ast_fwd_decl.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate)
+  {
+    using std::strlen;
+    using std::strcpy;
+    Value* e = NULL;
+    switch (sass_value_get_tag(v)) {
+      case SASS_BOOLEAN: {
+        e = SASS_MEMORY_NEW(Boolean, pstate, !!sass_boolean_get_value(v));
+      } break;
+      case SASS_NUMBER: {
+        e = SASS_MEMORY_NEW(Number, pstate, sass_number_get_value(v), sass_number_get_unit(v));
+      } break;
+      case SASS_COLOR: {
+        e = SASS_MEMORY_NEW(Color_RGBA, pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
+      } break;
+      case SASS_STRING: {
+        if (sass_string_is_quoted(v))
+          e = SASS_MEMORY_NEW(String_Quoted, pstate, sass_string_get_value(v));
+        else {
+          e = SASS_MEMORY_NEW(String_Constant, pstate, sass_string_get_value(v));
+        }
+      } break;
+      case SASS_LIST: {
+        List* l = SASS_MEMORY_NEW(List, pstate, sass_list_get_length(v), sass_list_get_separator(v));
+        for (size_t i = 0, L = sass_list_get_length(v); i < L; ++i) {
+          l->append(c2ast(sass_list_get_value(v, i), traces, pstate));
+        }
+        l->is_bracketed(sass_list_get_is_bracketed(v));
+        e = l;
+      } break;
+      case SASS_MAP: {
+        Map* m = SASS_MEMORY_NEW(Map, pstate);
+        for (size_t i = 0, L = sass_map_get_length(v); i < L; ++i) {
+          *m << std::make_pair(
+            c2ast(sass_map_get_key(v, i), traces, pstate),
+            c2ast(sass_map_get_value(v, i), traces, pstate));
+        }
+        e = m;
+      } break;
+      case SASS_NULL: {
+        e = SASS_MEMORY_NEW(Null, pstate);
+      } break;
+      case SASS_ERROR: {
+        error("Error in C function: " + sass::string(sass_error_get_message(v)), pstate, traces);
+      } break;
+      case SASS_WARNING: {
+        error("Warning in C function: " + sass::string(sass_warning_get_message(v)), pstate, traces);
+      } break;
+      default: break;
+    }
+    return e;
+  }
+
+}

data/ext/libsass/src/c2ast.hpp

@@ -0,0 +1,14 @@
+#ifndef SASS_C2AST_H
+#define SASS_C2AST_H
+
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate);
+
+}
+
+#endif

data/ext/libsass/src/cencode.c

@@ -46,9 +46,8 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			result = (fragment & 0x0fc) >> 2;
 			*codechar++ = base64_encode_value(result);
 			result = (fragment & 0x003) << 4;
-			#ifndef _MSC_VER
-				__attribute__ ((fallthrough));
-			#endif
+			/* fall through */
+
 	case step_B:
 			if (plainchar == plaintextend)
 			{
@@ -60,9 +59,8 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			result |= (fragment & 0x0f0) >> 4;
 			*codechar++ = base64_encode_value(result);
 			result = (fragment & 0x00f) << 2;
-			#ifndef _MSC_VER
-				__attribute__ ((fallthrough));
-			#endif
+			/* fall through */
+
 	case step_C:
 			if (plainchar == plaintextend)
 			{

data/ext/libsass/src/check_nesting.cpp

@@ -1,31 +1,32 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include <vector>
-
+#include "ast.hpp"
 #include "check_nesting.hpp"
 
 namespace Sass {
 
   CheckNesting::CheckNesting()
-  : parents(std::vector<Statement_Ptr>()),
-    traces(std::vector<Backtrace>()),
+  : parents(sass::vector<Statement*>()),
+    traces(sass::vector<Backtrace>()),
     parent(0), current_mixin_definition(0)
   { }
 
-  void error(AST_Node_Ptr node, Backtraces traces, std::string msg) {
+  void error(AST_Node* node, Backtraces traces, sass::string msg) {
     traces.push_back(Backtrace(node->pstate()));
     throw Exception::InvalidSass(node->pstate(), traces, msg);
   }
 
-  Statement_Ptr CheckNesting::visit_children(Statement_Ptr parent)
+  Statement* CheckNesting::visit_children(Statement* parent)
   {
-    Statement_Ptr old_parent = this->parent;
+    Statement* old_parent = this->parent;
 
-    if (At_Root_Block_Ptr root = Cast<At_Root_Block>(parent)) {
-      std::vector<Statement_Ptr> old_parents = this->parents;
-      std::vector<Statement_Ptr> new_parents;
+    if (AtRootRule* root = Cast<AtRootRule>(parent)) {
+      sass::vector<Statement*> old_parents = this->parents;
+      sass::vector<Statement*> new_parents;
 
       for (size_t i = 0, L = this->parents.size(); i < L; i++) {
-        Statement_Ptr p = this->parents.at(i);
+        Statement* p = this->parents.at(i);
         if (!root->exclude_node(p)) {
           new_parents.push_back(p);
         }
@@ -33,8 +34,8 @@ namespace Sass {
       this->parents = new_parents;
 
       for (size_t i = this->parents.size(); i > 0; i--) {
-        Statement_Ptr p = 0;
-        Statement_Ptr gp = 0;
+        Statement* p = 0;
+        Statement* gp = 0;
         if (i > 0) p = this->parents.at(i - 1);
         if (i > 1) gp = this->parents.at(i - 2);
 
@@ -44,8 +45,8 @@ namespace Sass {
         }
       }
 
-      At_Root_Block_Ptr ar = Cast<At_Root_Block>(parent);
-      Block_Ptr ret = ar->block();
+      AtRootRule* ar = Cast<AtRootRule>(parent);
+      Block* ret = ar->block();
 
       if (ret != NULL) {
         for (auto n : ret->elements()) {
@@ -65,16 +66,16 @@ namespace Sass {
 
     this->parents.push_back(parent);
 
-    Block_Ptr b = Cast<Block>(parent);
+    Block* b = Cast<Block>(parent);
 
-    if (Trace_Ptr trace = Cast<Trace>(parent)) {
+    if (Trace* trace = Cast<Trace>(parent)) {
       if (trace->type() == 'i') {
         this->traces.push_back(Backtrace(trace->pstate()));
       }
     }
 
     if (!b) {
-      if (Has_Block_Ptr bb = Cast<Has_Block>(parent)) {
+      if (ParentStatement* bb = Cast<ParentStatement>(parent)) {
         b = bb->block();
       }
     }
@@ -88,7 +89,7 @@ namespace Sass {
     this->parent = old_parent;
     this->parents.pop_back();
 
-    if (Trace_Ptr trace = Cast<Trace>(parent)) {
+    if (Trace* trace = Cast<Trace>(parent)) {
       if (trace->type() == 'i') {
         this->traces.pop_back();
       }
@@ -98,12 +99,12 @@ namespace Sass {
   }
 
 
-  Statement_Ptr CheckNesting::operator()(Block_Ptr b)
+  Statement* CheckNesting::operator()(Block* b)
   {
     return this->visit_children(b);
   }
 
-  Statement_Ptr CheckNesting::operator()(Definition_Ptr n)
+  Statement* CheckNesting::operator()(Definition* n)
   {
     if (!this->should_visit(n)) return NULL;
     if (!is_mixin(n)) {
@@ -111,7 +112,7 @@ namespace Sass {
       return n;
     }
 
-    Definition_Ptr old_mixin_definition = this->current_mixin_definition;
+    Definition* old_mixin_definition = this->current_mixin_definition;
     this->current_mixin_definition = n;
 
     visit_children(n);
@@ -121,25 +122,18 @@ namespace Sass {
     return n;
   }
 
-  Statement_Ptr CheckNesting::operator()(If_Ptr i)
+  Statement* CheckNesting::operator()(If* i)
   {
     this->visit_children(i);
 
-    if (Block_Ptr b = Cast<Block>(i->alternative())) {
+    if (Block* b = Cast<Block>(i->alternative())) {
       for (auto n : b->elements()) n->perform(this);
     }
 
     return i;
   }
 
-  Statement_Ptr CheckNesting::fallback_impl(Statement_Ptr s)
-  {
-    Block_Ptr b1 = Cast<Block>(s);
-    Has_Block_Ptr b2 = Cast<Has_Block>(s);
-    return b1 || b2 ? visit_children(s) : s;
-  }
-
-  bool CheckNesting::should_visit(Statement_Ptr node)
+  bool CheckNesting::should_visit(Statement* node)
   {
     if (!this->parent) return true;
 
@@ -149,7 +143,7 @@ namespace Sass {
     if (is_charset(node))
     { this->invalid_charset_parent(this->parent, node); }
 
-    if (Cast<Extension>(node))
+    if (Cast<ExtendRule>(node))
     { this->invalid_extend_parent(this->parent, node); }
 
     // if (Cast<Import>(node))
@@ -164,7 +158,7 @@ namespace Sass {
     if (this->is_function(this->parent))
     { this->invalid_function_child(node); }
 
-    if (Declaration_Ptr d = Cast<Declaration>(node))
+    if (Declaration* d = Cast<Declaration>(node))
     {
       this->invalid_prop_parent(this->parent, node);
       this->invalid_value_child(d->value());
@@ -179,14 +173,14 @@ namespace Sass {
     return true;
   }
 
-  void CheckNesting::invalid_content_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_content_parent(Statement* parent, AST_Node* node)
   {
     if (!this->current_mixin_definition) {
       error(node, traces, "@content may only be used within a mixin.");
     }
   }
 
-  void CheckNesting::invalid_charset_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_charset_parent(Statement* parent, AST_Node* node)
   {
     if (!(
         is_root_node(parent)
@@ -195,10 +189,10 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_extend_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_extend_parent(Statement* parent, AST_Node* node)
   {
     if (!(
-        Cast<Ruleset>(parent) ||
+        Cast<StyleRule>(parent) ||
         Cast<Mixin_Call>(parent) ||
         is_mixin(parent)
     )) {
@@ -206,14 +200,14 @@ namespace Sass {
     }
   }
 
-  // void CheckNesting::invalid_import_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  // void CheckNesting::invalid_import_parent(Statement* parent, AST_Node* node)
   // {
   //   for (auto pp : this->parents) {
   //     if (
-  //         Cast<Each>(pp) ||
-  //         Cast<For>(pp) ||
+  //         Cast<EachRule>(pp) ||
+  //         Cast<ForRule>(pp) ||
   //         Cast<If>(pp) ||
-  //         Cast<While>(pp) ||
+  //         Cast<WhileRule>(pp) ||
   //         Cast<Trace>(pp) ||
   //         Cast<Mixin_Call>(pp) ||
   //         is_mixin(pp)
@@ -231,14 +225,14 @@ namespace Sass {
   //   }
   // }
 
-  void CheckNesting::invalid_mixin_definition_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_mixin_definition_parent(Statement* parent, AST_Node* node)
   {
-    for (Statement_Ptr pp : this->parents) {
+    for (Statement* pp : this->parents) {
       if (
-          Cast<Each>(pp) ||
-          Cast<For>(pp) ||
+          Cast<EachRule>(pp) ||
+          Cast<ForRule>(pp) ||
           Cast<If>(pp) ||
-          Cast<While>(pp) ||
+          Cast<WhileRule>(pp) ||
           Cast<Trace>(pp) ||
           Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
@@ -248,14 +242,14 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_function_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_function_parent(Statement* parent, AST_Node* node)
   {
-    for (Statement_Ptr pp : this->parents) {
+    for (Statement* pp : this->parents) {
       if (
-          Cast<Each>(pp) ||
-          Cast<For>(pp) ||
+          Cast<EachRule>(pp) ||
+          Cast<ForRule>(pp) ||
           Cast<If>(pp) ||
-          Cast<While>(pp) ||
+          Cast<WhileRule>(pp) ||
           Cast<Trace>(pp) ||
           Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
@@ -265,34 +259,34 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_function_child(Statement_Ptr child)
+  void CheckNesting::invalid_function_child(Statement* child)
   {
     if (!(
-        Cast<Each>(child) ||
-        Cast<For>(child) ||
+        Cast<EachRule>(child) ||
+        Cast<ForRule>(child) ||
         Cast<If>(child) ||
-        Cast<While>(child) ||
+        Cast<WhileRule>(child) ||
         Cast<Trace>(child) ||
         Cast<Comment>(child) ||
-        Cast<Debug>(child) ||
+        Cast<DebugRule>(child) ||
         Cast<Return>(child) ||
         Cast<Variable>(child) ||
         // Ruby Sass doesn't distinguish variables and assignments
         Cast<Assignment>(child) ||
-        Cast<Warning>(child) ||
-        Cast<Error>(child)
+        Cast<WarningRule>(child) ||
+        Cast<ErrorRule>(child)
     )) {
       error(child, traces, "Functions can only contain variable declarations and control directives.");
     }
   }
 
-  void CheckNesting::invalid_prop_child(Statement_Ptr child)
+  void CheckNesting::invalid_prop_child(Statement* child)
   {
     if (!(
-        Cast<Each>(child) ||
-        Cast<For>(child) ||
+        Cast<EachRule>(child) ||
+        Cast<ForRule>(child) ||
         Cast<If>(child) ||
-        Cast<While>(child) ||
+        Cast<WhileRule>(child) ||
         Cast<Trace>(child) ||
         Cast<Comment>(child) ||
         Cast<Declaration>(child) ||
@@ -302,12 +296,12 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_prop_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_prop_parent(Statement* parent, AST_Node* node)
   {
     if (!(
         is_mixin(parent) ||
         is_directive_node(parent) ||
-        Cast<Ruleset>(parent) ||
+        Cast<StyleRule>(parent) ||
         Cast<Keyframe_Rule>(parent) ||
         Cast<Declaration>(parent) ||
         Cast<Mixin_Call>(parent)
@@ -316,13 +310,13 @@ namespace Sass {
     }
   }
 
-  void CheckNesting::invalid_value_child(AST_Node_Ptr d)
+  void CheckNesting::invalid_value_child(AST_Node* d)
   {
-    if (Map_Ptr m = Cast<Map>(d)) {
+    if (Map* m = Cast<Map>(d)) {
       traces.push_back(Backtrace(m->pstate()));
       throw Exception::InvalidValue(traces, *m);
     }
-    if (Number_Ptr n = Cast<Number>(d)) {
+    if (Number* n = Cast<Number>(d)) {
       if (!n->is_valid_css_unit()) {
         traces.push_back(Backtrace(n->pstate()));
         throw Exception::InvalidValue(traces, *n);
@@ -333,14 +327,14 @@ namespace Sass {
 
   }
 
-  void CheckNesting::invalid_return_parent(Statement_Ptr parent, AST_Node_Ptr node)
+  void CheckNesting::invalid_return_parent(Statement* parent, AST_Node* node)
   {
     if (!this->is_function(parent)) {
       error(node, traces, "@return may only be used within a function.");
     }
   }
 
-  bool CheckNesting::is_transparent_parent(Statement_Ptr parent, Statement_Ptr grandparent)
+  bool CheckNesting::is_transparent_parent(Statement* parent, Statement* grandparent)
   {
     bool parent_bubbles = parent && parent->bubbles();
 
@@ -349,50 +343,51 @@ namespace Sass {
                              !is_at_root_node(grandparent);
 
     return Cast<Import>(parent) ||
-           Cast<Each>(parent) ||
-           Cast<For>(parent) ||
+           Cast<EachRule>(parent) ||
+           Cast<ForRule>(parent) ||
            Cast<If>(parent) ||
-           Cast<While>(parent) ||
+           Cast<WhileRule>(parent) ||
            Cast<Trace>(parent) ||
            valid_bubble_node;
   }
 
-  bool CheckNesting::is_charset(Statement_Ptr n)
+  bool CheckNesting::is_charset(Statement* n)
   {
-    Directive_Ptr d = Cast<Directive>(n);
+    AtRule* d = Cast<AtRule>(n);
     return d && d->keyword() == "charset";
   }
 
-  bool CheckNesting::is_mixin(Statement_Ptr n)
+  bool CheckNesting::is_mixin(Statement* n)
   {
-    Definition_Ptr def = Cast<Definition>(n);
+    Definition* def = Cast<Definition>(n);
     return def && def->type() == Definition::MIXIN;
   }
 
-  bool CheckNesting::is_function(Statement_Ptr n)
+  bool CheckNesting::is_function(Statement* n)
   {
-    Definition_Ptr def = Cast<Definition>(n);
+    Definition* def = Cast<Definition>(n);
     return def && def->type() == Definition::FUNCTION;
   }
 
-  bool CheckNesting::is_root_node(Statement_Ptr n)
+  bool CheckNesting::is_root_node(Statement* n)
   {
-    if (Cast<Ruleset>(n)) return false;
+    if (Cast<StyleRule>(n)) return false;
 
-    Block_Ptr b = Cast<Block>(n);
+    Block* b = Cast<Block>(n);
     return b && b->is_root();
   }
 
-  bool CheckNesting::is_at_root_node(Statement_Ptr n)
+  bool CheckNesting::is_at_root_node(Statement* n)
   {
-    return Cast<At_Root_Block>(n) != NULL;
+    return Cast<AtRootRule>(n) != NULL;
   }
 
-  bool CheckNesting::is_directive_node(Statement_Ptr n)
+  bool CheckNesting::is_directive_node(Statement* n)
   {
-    return Cast<Directive>(n) ||
+    return Cast<AtRule>(n) ||
            Cast<Import>(n) ||
-           Cast<Media_Block>(n) ||
-           Cast<Supports_Block>(n);
+      Cast<MediaRule>(n) ||
+      Cast<CssMediaRule>(n) ||
+      Cast<SupportsRule>(n);
   }
 }