sassc 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aebf2c0084662833c589a03cd0de02b8b72d3968f4c33a27d1b37c330a692bf2
-  data.tar.gz: b828b00fb88f9ed8414cd7abfd86afdced6458f47e9560789690d8f9a3670c43
+  metadata.gz: 75155de90eb3449ed2a1214ca6ab2b82ffe69b144c2a8eaf8a6a4fd522b58ea4
+  data.tar.gz: 8575ebe24a2d56a9bea0e4574ebd23753e283d3b34bf571489f318a357bce2b9
 SHA512:
-  metadata.gz: 802546b5350e0b550b8ba01a125e03dbe52ce9541003ae811782b4cf2c197e12b5056520376a5dbf5317a2b033f70808fafd1e62fe40ecd12cf2d56c52881c6e
-  data.tar.gz: 864f16c8f74351159107fb1ccfd3abf837447b41a846a1c990481e7b28732222c4abde988aebe953fb500db2424a0d7d7ce2fc1c351ed2711aa1fa5ea88e37c1
+  metadata.gz: ae3eb9431fb5d9de9e1c1759844e1144aba73f59b7de40e1b06d77ba5567bc894a2f0a4ef2d3b6dcce9226044d52de5eeacb7759e715f3eb1bd4818b56b9876c
+  data.tar.gz: e4a07f5789ec2d9f4dbf04bfaf13b5d12224cf4ffd9f72721fac8edfd10eb2b7085af53d70248ce78112ee7af0ea06fb5e452388997eab810d07bd5a7de08a5c

data/.travis.yml

@@ -10,6 +10,7 @@ rvm:
   - 2.4.6
   - 2.5.5
   - 2.6.3
+  - 2.7.0
   - truffleruby
 notifications:
   email: false

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+- **2.4.0**
+  - [Update libsass to 3.6.4](https://github.com/sass/sassc-ruby/pull/199)
+  - [Use FFI::MemoryPointer instead of libc's malloc()](https://github.com/sass/sassc-ruby/pull/205)
+  - [Test against Ruby 2.7.0](https://github.com/sass/sassc-ruby/pull/193)
+
 - **2.3.0**
   - [Fix rake gem:native task](https://github.com/sass/sassc-ruby/pull/196)
   - [disable lto flag for darwin + nix](https://github.com/sass/sassc-ruby/pull/166)

data/ext/libsass/VERSION

@@ -1 +1 @@
-3.6.3
+3.6.4

data/ext/libsass/include/sass/context.h

@@ -125,6 +125,9 @@ ADDAPI char** ADDCALL sass_context_get_included_files (struct Sass_Context* ctx)
 // Getters for options include path array
 ADDAPI size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i);
+// Plugin paths to load dynamic libraries work the same
+ADDAPI size_t ADDCALL sass_option_get_plugin_path_size(struct Sass_Options* options);
+ADDAPI const char* ADDCALL sass_option_get_plugin_path(struct Sass_Options* options, size_t i);
 
 // Calculate the size of the stored null terminated array
 ADDAPI size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx);

data/ext/libsass/src/MurmurHash2.hpp

@@ -0,0 +1,91 @@
+//-----------------------------------------------------------------------------
+// MurmurHash2 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+//-----------------------------------------------------------------------------
+// LibSass only needs MurmurHash2, so we made this header only
+//-----------------------------------------------------------------------------
+
+#ifndef _MURMURHASH2_H_
+#define _MURMURHASH2_H_
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;
+
+// Other compilers
+
+#else	// defined(_MSC_VER)
+
+#include <stdint.h>
+
+#endif // !defined(_MSC_VER)
+
+//-----------------------------------------------------------------------------
+
+inline uint32_t MurmurHash2 ( const void * key, int len, uint32_t seed )
+{
+  // 'm' and 'r' are mixing constants generated offline.
+  // They're not really 'magic', they just happen to work well.
+
+  const uint32_t m = 0x5bd1e995;
+  const int r = 24;
+
+  // Initialize the hash to a 'random' value
+
+  uint32_t h = seed ^ len;
+
+  // Mix 4 bytes at a time into the hash
+
+  const unsigned char * data = (const unsigned char *)key;
+
+  while(len >= 4)
+  {
+    uint32_t k = *(uint32_t*)data;
+
+    k *= m;
+    k ^= k >> r;
+    k *= m;
+
+    h *= m;
+    h ^= k;
+
+    data += 4;
+    len -= 4;
+  }
+
+  // Handle the last few bytes of the input array
+
+  switch(len)
+  {
+  case 3:
+    h ^= data[2] << 16;
+    /* fall through */
+  case 2:
+    h ^= data[1] << 8;
+    /* fall through */
+  case 1:
+    h ^= data[0];
+    h *= m;
+  };
+
+  // Do a few final mixes of the hash to ensure the last few
+  // bytes are well-incorporated.
+
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
+
+  return h;
+} 
+
+//-----------------------------------------------------------------------------
+
+#endif // _MURMURHASH2_H_
+

data/ext/libsass/src/ast.cpp

@@ -6,7 +6,7 @@
 
 namespace Sass {
 
-  static Null sass_null(ParserState("null"));
+  static Null sass_null(SourceSpan("null"));
 
   const char* sass_op_to_name(enum Sass_OP op) {
     switch (op) {
@@ -53,12 +53,12 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  void AST_Node::update_pstate(const ParserState& pstate)
+  void AST_Node::update_pstate(const SourceSpan& pstate)
   {
-    pstate_.offset += pstate - pstate_ + pstate.offset;
+    pstate_.offset += pstate.position - pstate_.position + pstate.offset;
   }
 
-  std::string AST_Node::to_string(Sass_Inspect_Options opt) const
+  sass::string AST_Node::to_string(Sass_Inspect_Options opt) const
   {
     Sass_Output_Options out(opt);
     Emitter emitter(out);
@@ -69,7 +69,7 @@ namespace Sass {
     return i.get_buffer();
   }
 
-  std::string AST_Node::to_css(Sass_Inspect_Options opt) const
+  sass::string AST_Node::to_css(Sass_Inspect_Options opt) const
   {
     opt.output_style = TO_CSS;
     Sass_Output_Options out(opt);
@@ -81,7 +81,7 @@ namespace Sass {
     return i.get_buffer();
   }
 
-  std::string AST_Node::to_string() const
+  sass::string AST_Node::to_string() const
   {
     return to_string({ NESTED, 5 });
   }
@@ -89,7 +89,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Statement::Statement(ParserState pstate, Type st, size_t t)
+  Statement::Statement(SourceSpan pstate, Type st, size_t t)
   : AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)
   { }
   Statement::Statement(const Statement* ptr)
@@ -117,7 +117,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Block::Block(ParserState pstate, size_t s, bool r)
+  Block::Block(SourceSpan pstate, size_t s, bool r)
   : Statement(pstate),
     Vectorized<Statement_Obj>(s),
     is_root_(r)
@@ -147,14 +147,14 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Has_Block::Has_Block(ParserState pstate, Block_Obj b)
+  ParentStatement::ParentStatement(SourceSpan pstate, Block_Obj b)
   : Statement(pstate), block_(b)
   { }
-  Has_Block::Has_Block(const Has_Block* ptr)
+  ParentStatement::ParentStatement(const ParentStatement* ptr)
   : Statement(ptr), block_(ptr->block_)
   { }
 
-  bool Has_Block::has_content()
+  bool ParentStatement::has_content()
   {
     return (block_ && block_->has_content()) || Statement::has_content();
   }
@@ -162,17 +162,17 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Ruleset::Ruleset(ParserState pstate, SelectorListObj s, Block_Obj b)
-  : Has_Block(pstate, b), selector_(s), schema_(), is_root_(false)
+  StyleRule::StyleRule(SourceSpan pstate, SelectorListObj s, Block_Obj b)
+  : ParentStatement(pstate, b), selector_(s), schema_(), is_root_(false)
   { statement_type(RULESET); }
-  Ruleset::Ruleset(const Ruleset* ptr)
-  : Has_Block(ptr),
+  StyleRule::StyleRule(const StyleRule* ptr)
+  : ParentStatement(ptr),
     selector_(ptr->selector_),
     schema_(ptr->schema_),
     is_root_(ptr->is_root_)
   { statement_type(RULESET); }
 
-  bool Ruleset::is_invisible() const {
+  bool StyleRule::is_invisible() const {
     if (const SelectorList * sl = Cast<SelectorList>(selector())) {
       for (size_t i = 0, L = sl->length(); i < L; i += 1)
         if (!(*sl)[i]->isInvisible()) return false;
@@ -183,7 +183,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Bubble::Bubble(ParserState pstate, Statement_Obj n, Statement_Obj g, size_t t)
+  Bubble::Bubble(SourceSpan pstate, Statement_Obj n, Statement_Obj g, size_t t)
   : Statement(pstate, Statement::BUBBLE, t), node_(n), group_end_(g == nullptr)
   { }
   Bubble::Bubble(const Bubble* ptr)
@@ -200,11 +200,11 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Trace::Trace(ParserState pstate, std::string n, Block_Obj b, char type)
-  : Has_Block(pstate, b), type_(type), name_(n)
+  Trace::Trace(SourceSpan pstate, sass::string n, Block_Obj b, char type)
+  : ParentStatement(pstate, b), type_(type), name_(n)
   { }
   Trace::Trace(const Trace* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     type_(ptr->type_),
     name_(ptr->name_)
   { }
@@ -212,25 +212,25 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Directive::Directive(ParserState pstate, std::string kwd, SelectorListObj sel, Block_Obj b, Expression_Obj val)
-  : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
+  AtRule::AtRule(SourceSpan pstate, sass::string kwd, SelectorListObj sel, Block_Obj b, ExpressionObj val)
+  : ParentStatement(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
   { statement_type(DIRECTIVE); }
-  Directive::Directive(const Directive* ptr)
-  : Has_Block(ptr),
+  AtRule::AtRule(const AtRule* ptr)
+  : ParentStatement(ptr),
     keyword_(ptr->keyword_),
     selector_(ptr->selector_),
     value_(ptr->value_) // set value manually if needed
   { statement_type(DIRECTIVE); }
 
-  bool Directive::bubbles() { return is_keyframes() || is_media(); }
+  bool AtRule::bubbles() { return is_keyframes() || is_media(); }
 
-  bool Directive::is_media() {
+  bool AtRule::is_media() {
     return keyword_.compare("@-webkit-media") == 0 ||
             keyword_.compare("@-moz-media") == 0 ||
             keyword_.compare("@-o-media") == 0 ||
             keyword_.compare("@media") == 0;
   }
-  bool Directive::is_keyframes() {
+  bool AtRule::is_keyframes() {
     return keyword_.compare("@-webkit-keyframes") == 0 ||
             keyword_.compare("@-moz-keyframes") == 0 ||
             keyword_.compare("@-o-keyframes") == 0 ||
@@ -240,21 +240,21 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Keyframe_Rule::Keyframe_Rule(ParserState pstate, Block_Obj b)
-  : Has_Block(pstate, b), name_()
+  Keyframe_Rule::Keyframe_Rule(SourceSpan pstate, Block_Obj b)
+  : ParentStatement(pstate, b), name_()
   { statement_type(KEYFRAMERULE); }
   Keyframe_Rule::Keyframe_Rule(const Keyframe_Rule* ptr)
-  : Has_Block(ptr), name_(ptr->name_)
+  : ParentStatement(ptr), name_(ptr->name_)
   { statement_type(KEYFRAMERULE); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Declaration::Declaration(ParserState pstate, String_Obj prop, Expression_Obj val, bool i, bool c, Block_Obj b)
-  : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)
+  Declaration::Declaration(SourceSpan pstate, String_Obj prop, ExpressionObj val, bool i, bool c, Block_Obj b)
+  : ParentStatement(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)
   { statement_type(DECLARATION); }
   Declaration::Declaration(const Declaration* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     property_(ptr->property_),
     value_(ptr->value_),
     is_important_(ptr->is_important_),
@@ -271,7 +271,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Assignment::Assignment(ParserState pstate, std::string var, Expression_Obj val, bool is_default, bool is_global)
+  Assignment::Assignment(SourceSpan pstate, sass::string var, ExpressionObj val, bool is_default, bool is_global)
   : Statement(pstate), variable_(var), value_(val), is_default_(is_default), is_global_(is_global)
   { statement_type(ASSIGNMENT); }
   Assignment::Assignment(const Assignment* ptr)
@@ -285,10 +285,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Import::Import(ParserState pstate)
+  Import::Import(SourceSpan pstate)
   : Statement(pstate),
-    urls_(std::vector<Expression_Obj>()),
-    incs_(std::vector<Include>()),
+    urls_(sass::vector<ExpressionObj>()),
+    incs_(sass::vector<Include>()),
     import_queries_()
   { statement_type(IMPORT); }
   Import::Import(const Import* ptr)
@@ -298,56 +298,56 @@ namespace Sass {
     import_queries_(ptr->import_queries_)
   { statement_type(IMPORT); }
 
-  std::vector<Include>& Import::incs() { return incs_; }
-  std::vector<Expression_Obj>& Import::urls() { return urls_; }
+  sass::vector<Include>& Import::incs() { return incs_; }
+  sass::vector<ExpressionObj>& Import::urls() { return urls_; }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Import_Stub::Import_Stub(ParserState pstate, Include res)
+  Import_Stub::Import_Stub(SourceSpan pstate, Include res)
   : Statement(pstate), resource_(res)
   { statement_type(IMPORT_STUB); }
   Import_Stub::Import_Stub(const Import_Stub* ptr)
   : Statement(ptr), resource_(ptr->resource_)
   { statement_type(IMPORT_STUB); }
   Include Import_Stub::resource() { return resource_; };
-  std::string Import_Stub::imp_path() { return resource_.imp_path; };
-  std::string Import_Stub::abs_path() { return resource_.abs_path; };
+  sass::string Import_Stub::imp_path() { return resource_.imp_path; };
+  sass::string Import_Stub::abs_path() { return resource_.abs_path; };
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Warning::Warning(ParserState pstate, Expression_Obj msg)
+  WarningRule::WarningRule(SourceSpan pstate, ExpressionObj msg)
   : Statement(pstate), message_(msg)
   { statement_type(WARNING); }
-  Warning::Warning(const Warning* ptr)
+  WarningRule::WarningRule(const WarningRule* ptr)
   : Statement(ptr), message_(ptr->message_)
   { statement_type(WARNING); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Error::Error(ParserState pstate, Expression_Obj msg)
+  ErrorRule::ErrorRule(SourceSpan pstate, ExpressionObj msg)
   : Statement(pstate), message_(msg)
   { statement_type(ERROR); }
-  Error::Error(const Error* ptr)
+  ErrorRule::ErrorRule(const ErrorRule* ptr)
   : Statement(ptr), message_(ptr->message_)
   { statement_type(ERROR); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Debug::Debug(ParserState pstate, Expression_Obj val)
+  DebugRule::DebugRule(SourceSpan pstate, ExpressionObj val)
   : Statement(pstate), value_(val)
   { statement_type(DEBUGSTMT); }
-  Debug::Debug(const Debug* ptr)
+  DebugRule::DebugRule(const DebugRule* ptr)
   : Statement(ptr), value_(ptr->value_)
   { statement_type(DEBUGSTMT); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Comment::Comment(ParserState pstate, String_Obj txt, bool is_important)
+  Comment::Comment(SourceSpan pstate, String_Obj txt, bool is_important)
   : Statement(pstate), text_(txt), is_important_(is_important)
   { statement_type(COMMENT); }
   Comment::Comment(const Comment* ptr)
@@ -364,30 +364,30 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  If::If(ParserState pstate, Expression_Obj pred, Block_Obj con, Block_Obj alt)
-  : Has_Block(pstate, con), predicate_(pred), alternative_(alt)
+  If::If(SourceSpan pstate, ExpressionObj pred, Block_Obj con, Block_Obj alt)
+  : ParentStatement(pstate, con), predicate_(pred), alternative_(alt)
   { statement_type(IF); }
   If::If(const If* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     predicate_(ptr->predicate_),
     alternative_(ptr->alternative_)
   { statement_type(IF); }
 
   bool If::has_content()
   {
-    return Has_Block::has_content() || (alternative_ && alternative_->has_content());
+    return ParentStatement::has_content() || (alternative_ && alternative_->has_content());
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  For::For(ParserState pstate,
-      std::string var, Expression_Obj lo, Expression_Obj hi, Block_Obj b, bool inc)
-  : Has_Block(pstate, b),
+  ForRule::ForRule(SourceSpan pstate,
+      sass::string var, ExpressionObj lo, ExpressionObj hi, Block_Obj b, bool inc)
+  : ParentStatement(pstate, b),
     variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)
   { statement_type(FOR); }
-  For::For(const For* ptr)
-  : Has_Block(ptr),
+  ForRule::ForRule(const ForRule* ptr)
+  : ParentStatement(ptr),
     variable_(ptr->variable_),
     lower_bound_(ptr->lower_bound_),
     upper_bound_(ptr->upper_bound_),
@@ -397,27 +397,27 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Each::Each(ParserState pstate, std::vector<std::string> vars, Expression_Obj lst, Block_Obj b)
-  : Has_Block(pstate, b), variables_(vars), list_(lst)
+  EachRule::EachRule(SourceSpan pstate, sass::vector<sass::string> vars, ExpressionObj lst, Block_Obj b)
+  : ParentStatement(pstate, b), variables_(vars), list_(lst)
   { statement_type(EACH); }
-  Each::Each(const Each* ptr)
-  : Has_Block(ptr), variables_(ptr->variables_), list_(ptr->list_)
+  EachRule::EachRule(const EachRule* ptr)
+  : ParentStatement(ptr), variables_(ptr->variables_), list_(ptr->list_)
   { statement_type(EACH); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  While::While(ParserState pstate, Expression_Obj pred, Block_Obj b)
-  : Has_Block(pstate, b), predicate_(pred)
+  WhileRule::WhileRule(SourceSpan pstate, ExpressionObj pred, Block_Obj b)
+  : ParentStatement(pstate, b), predicate_(pred)
   { statement_type(WHILE); }
-  While::While(const While* ptr)
-  : Has_Block(ptr), predicate_(ptr->predicate_)
+  WhileRule::WhileRule(const WhileRule* ptr)
+  : ParentStatement(ptr), predicate_(ptr->predicate_)
   { statement_type(WHILE); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Return::Return(ParserState pstate, Expression_Obj val)
+  Return::Return(SourceSpan pstate, ExpressionObj val)
   : Statement(pstate), value_(val)
   { statement_type(RETURN); }
   Return::Return(const Return* ptr)
@@ -427,10 +427,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-    ExtendRule::ExtendRule(ParserState pstate, SelectorListObj s)
+    ExtendRule::ExtendRule(SourceSpan pstate, SelectorListObj s)
   : Statement(pstate), isOptional_(false), selector_(s), schema_()
   { statement_type(EXTEND); }
-  ExtendRule::ExtendRule(ParserState pstate, Selector_Schema_Obj s)
+  ExtendRule::ExtendRule(SourceSpan pstate, Selector_Schema_Obj s)
     : Statement(pstate), isOptional_(false), selector_(), schema_(s)
   {
     statement_type(EXTEND);
@@ -446,7 +446,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Definition::Definition(const Definition* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     name_(ptr->name_),
     parameters_(ptr->parameters_),
     environment_(ptr->environment_),
@@ -458,12 +458,12 @@ namespace Sass {
     signature_(ptr->signature_)
   { }
 
-  Definition::Definition(ParserState pstate,
-              std::string n,
+  Definition::Definition(SourceSpan pstate,
+              sass::string n,
               Parameters_Obj params,
               Block_Obj b,
               Type t)
-  : Has_Block(pstate, b),
+  : ParentStatement(pstate, b),
     name_(n),
     parameters_(params),
     environment_(0),
@@ -475,13 +475,13 @@ namespace Sass {
     signature_(0)
   { }
 
-  Definition::Definition(ParserState pstate,
+  Definition::Definition(SourceSpan pstate,
               Signature sig,
-              std::string n,
+              sass::string n,
               Parameters_Obj params,
               Native_Function func_ptr,
               bool overload_stub)
-  : Has_Block(pstate, {}),
+  : ParentStatement(pstate, {}),
     name_(n),
     parameters_(params),
     environment_(0),
@@ -493,12 +493,12 @@ namespace Sass {
     signature_(sig)
   { }
 
-  Definition::Definition(ParserState pstate,
+  Definition::Definition(SourceSpan pstate,
               Signature sig,
-              std::string n,
+              sass::string n,
               Parameters_Obj params,
               Sass_Function_Entry c_func)
-  : Has_Block(pstate, {}),
+  : ParentStatement(pstate, {}),
     name_(n),
     parameters_(params),
     environment_(0),
@@ -513,11 +513,11 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Mixin_Call::Mixin_Call(ParserState pstate, std::string n, Arguments_Obj args, Parameters_Obj b_params, Block_Obj b)
-  : Has_Block(pstate, b), name_(n), arguments_(args), block_parameters_(b_params)
+  Mixin_Call::Mixin_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Parameters_Obj b_params, Block_Obj b)
+  : ParentStatement(pstate, b), name_(n), arguments_(args), block_parameters_(b_params)
   { }
   Mixin_Call::Mixin_Call(const Mixin_Call* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     name_(ptr->name_),
     arguments_(ptr->arguments_),
     block_parameters_(ptr->block_parameters_)
@@ -526,7 +526,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Content::Content(ParserState pstate, Arguments_Obj args)
+  Content::Content(SourceSpan pstate, Arguments_Obj args)
   : Statement(pstate),
     arguments_(args)
   { statement_type(CONTENT); }
@@ -538,7 +538,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Expression::Expression(ParserState pstate, bool d, bool e, bool i, Type ct)
+  Expression::Expression(SourceSpan pstate, bool d, bool e, bool i, Type ct)
   : AST_Node(pstate),
     is_delayed_(d),
     is_expanded_(e),
@@ -557,7 +557,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Unary_Expression::Unary_Expression(ParserState pstate, Type t, Expression_Obj o)
+  Unary_Expression::Unary_Expression(SourceSpan pstate, Type t, ExpressionObj o)
   : Expression(pstate), optype_(t), operand_(o), hash_(0)
   { }
   Unary_Expression::Unary_Expression(const Unary_Expression* ptr)
@@ -566,7 +566,7 @@ namespace Sass {
     operand_(ptr->operand_),
     hash_(ptr->hash_)
   { }
-  const std::string Unary_Expression::type_name() {
+  const sass::string Unary_Expression::type_name() {
     switch (optype_) {
       case PLUS: return "plus";
       case MINUS: return "minus";
@@ -602,7 +602,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Argument::Argument(ParserState pstate, Expression_Obj val, std::string n, bool rest, bool keyword)
+  Argument::Argument(SourceSpan pstate, ExpressionObj val, sass::string n, bool rest, bool keyword)
   : Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
   {
     if (!name_.empty() && is_rest_argument_) {
@@ -646,7 +646,7 @@ namespace Sass {
   size_t Argument::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()(name());
+      hash_ = std::hash<sass::string>()(name());
       hash_combine(hash_, value()->hash());
     }
     return hash_;
@@ -655,7 +655,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Arguments::Arguments(ParserState pstate)
+  Arguments::Arguments(SourceSpan pstate)
   : Expression(pstate),
     Vectorized<Argument_Obj>(),
     has_named_arguments_(false),
@@ -738,13 +738,13 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Media_Query::Media_Query(ParserState pstate, String_Obj t, size_t s, bool n, bool r)
-  : Expression(pstate), Vectorized<Media_Query_Expression_Obj>(s),
+  Media_Query::Media_Query(SourceSpan pstate, String_Obj t, size_t s, bool n, bool r)
+  : Expression(pstate), Vectorized<Media_Query_ExpressionObj>(s),
     media_type_(t), is_negated_(n), is_restricted_(r)
   { }
   Media_Query::Media_Query(const Media_Query* ptr)
   : Expression(ptr),
-    Vectorized<Media_Query_Expression_Obj>(*ptr),
+    Vectorized<Media_Query_ExpressionObj>(*ptr),
     media_type_(ptr->media_type_),
     is_negated_(ptr->is_negated_),
     is_restricted_(ptr->is_restricted_)
@@ -753,8 +753,8 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Media_Query_Expression::Media_Query_Expression(ParserState pstate,
-                          Expression_Obj f, Expression_Obj v, bool i)
+  Media_Query_Expression::Media_Query_Expression(SourceSpan pstate,
+                          ExpressionObj f, ExpressionObj v, bool i)
   : Expression(pstate), feature_(f), value_(v), is_interpolated_(i)
   { }
   Media_Query_Expression::Media_Query_Expression(const Media_Query_Expression* ptr)
@@ -767,7 +767,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  At_Root_Query::At_Root_Query(ParserState pstate, Expression_Obj f, Expression_Obj v, bool i)
+  At_Root_Query::At_Root_Query(SourceSpan pstate, ExpressionObj f, ExpressionObj v, bool i)
   : Expression(pstate), feature_(f), value_(v)
   { }
   At_Root_Query::At_Root_Query(const At_Root_Query* ptr)
@@ -776,11 +776,11 @@ namespace Sass {
     value_(ptr->value_)
   { }
 
-  bool At_Root_Query::exclude(std::string str)
+  bool At_Root_Query::exclude(sass::string str)
   {
     bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;
     List* l = static_cast<List*>(value().ptr());
-    std::string v;
+    sass::string v;
 
     if (with)
     {
@@ -807,18 +807,18 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  At_Root_Block::At_Root_Block(ParserState pstate, Block_Obj b, At_Root_Query_Obj e)
-  : Has_Block(pstate, b), expression_(e)
+  AtRootRule::AtRootRule(SourceSpan pstate, Block_Obj b, At_Root_Query_Obj e)
+  : ParentStatement(pstate, b), expression_(e)
   { statement_type(ATROOT); }
-  At_Root_Block::At_Root_Block(const At_Root_Block* ptr)
-  : Has_Block(ptr), expression_(ptr->expression_)
+  AtRootRule::AtRootRule(const AtRootRule* ptr)
+  : ParentStatement(ptr), expression_(ptr->expression_)
   { statement_type(ATROOT); }
 
-  bool At_Root_Block::bubbles() {
+  bool AtRootRule::bubbles() {
     return true;
   }
 
-  bool At_Root_Block::exclude_node(Statement_Obj s) {
+  bool AtRootRule::exclude_node(Statement_Obj s) {
     if (expression() == nullptr)
     {
       return s->statement_type() == Statement::RULESET;
@@ -826,9 +826,9 @@ namespace Sass {
 
     if (s->statement_type() == Statement::DIRECTIVE)
     {
-      if (Directive_Obj dir = Cast<Directive>(s))
+      if (AtRuleObj dir = Cast<AtRule>(s))
       {
-        std::string keyword(dir->keyword());
+        sass::string keyword(dir->keyword());
         if (keyword.length() > 0) keyword.erase(0, 1);
         return expression()->exclude(keyword);
       }
@@ -845,7 +845,7 @@ namespace Sass {
     {
       return expression()->exclude("supports");
     }
-    if (Directive_Obj dir = Cast<Directive>(s))
+    if (AtRuleObj dir = Cast<AtRule>(s))
     {
       if (dir->is_keyframes()) return expression()->exclude("keyframes");
     }
@@ -855,7 +855,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Parameter::Parameter(ParserState pstate, std::string n, Expression_Obj def, bool rest)
+  Parameter::Parameter(SourceSpan pstate, sass::string n, ExpressionObj def, bool rest)
   : AST_Node(pstate), name_(n), default_value_(def), is_rest_parameter_(rest)
   { }
   Parameter::Parameter(const Parameter* ptr)
@@ -868,7 +868,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Parameters::Parameters(ParserState pstate)
+  Parameters::Parameters(SourceSpan pstate)
   : AST_Node(pstate),
     Vectorized<Parameter_Obj>(),
     has_optional_parameters_(false),
@@ -911,25 +911,25 @@ namespace Sass {
   // If you forget to add a class here you will get
   // undefined reference to `vtable for Sass::Class'
 
-  IMPLEMENT_AST_OPERATORS(Ruleset);
+  IMPLEMENT_AST_OPERATORS(StyleRule);
   IMPLEMENT_AST_OPERATORS(MediaRule);
   IMPLEMENT_AST_OPERATORS(CssMediaRule);
   IMPLEMENT_AST_OPERATORS(CssMediaQuery);
   IMPLEMENT_AST_OPERATORS(Import);
   IMPLEMENT_AST_OPERATORS(Import_Stub);
-  IMPLEMENT_AST_OPERATORS(Directive);
-  IMPLEMENT_AST_OPERATORS(At_Root_Block);
-  IMPLEMENT_AST_OPERATORS(While);
-  IMPLEMENT_AST_OPERATORS(Each);
-  IMPLEMENT_AST_OPERATORS(For);
+  IMPLEMENT_AST_OPERATORS(AtRule);
+  IMPLEMENT_AST_OPERATORS(AtRootRule);
+  IMPLEMENT_AST_OPERATORS(WhileRule);
+  IMPLEMENT_AST_OPERATORS(EachRule);
+  IMPLEMENT_AST_OPERATORS(ForRule);
   IMPLEMENT_AST_OPERATORS(If);
   IMPLEMENT_AST_OPERATORS(Mixin_Call);
   IMPLEMENT_AST_OPERATORS(ExtendRule);
   IMPLEMENT_AST_OPERATORS(Media_Query);
   IMPLEMENT_AST_OPERATORS(Media_Query_Expression);
-  IMPLEMENT_AST_OPERATORS(Debug);
-  IMPLEMENT_AST_OPERATORS(Error);
-  IMPLEMENT_AST_OPERATORS(Warning);
+  IMPLEMENT_AST_OPERATORS(DebugRule);
+  IMPLEMENT_AST_OPERATORS(ErrorRule);
+  IMPLEMENT_AST_OPERATORS(WarningRule);
   IMPLEMENT_AST_OPERATORS(Assignment);
   IMPLEMENT_AST_OPERATORS(Return);
   IMPLEMENT_AST_OPERATORS(At_Root_Query);