sassc 2.3.0 → 2.4.0

data/ext/libsass/src/ast_def_macros.hpp

@@ -70,18 +70,18 @@ private:
 #ifdef DEBUG_SHARED_PTR
 
 #define ATTACH_ABSTRACT_AST_OPERATIONS(klass) \
-  virtual klass* copy(std::string, size_t) const = 0; \
-  virtual klass* clone(std::string, size_t) const = 0; \
+  virtual klass* copy(sass::string, size_t) const = 0; \
+  virtual klass* clone(sass::string, size_t) const = 0; \
 
 #define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \
   klass(const klass* ptr); \
-  virtual klass* copy(std::string, size_t) const override = 0; \
-  virtual klass* clone(std::string, size_t) const override = 0; \
+  virtual klass* copy(sass::string, size_t) const override = 0; \
+  virtual klass* clone(sass::string, size_t) const override = 0; \
 
 #define ATTACH_AST_OPERATIONS(klass) \
   klass(const klass* ptr); \
-  virtual klass* copy(std::string, size_t) const override; \
-  virtual klass* clone(std::string, size_t) const override; \
+  virtual klass* copy(sass::string, size_t) const override; \
+  virtual klass* clone(sass::string, size_t) const override; \
 
 #else
 
@@ -112,12 +112,12 @@ private:
 #ifdef DEBUG_SHARED_PTR
 
   #define IMPLEMENT_AST_OPERATORS(klass) \
-    klass* klass::copy(std::string file, size_t line) const { \
-      klass* cpy = new klass(this); \
+    klass* klass::copy(sass::string file, size_t line) const { \
+      klass* cpy = SASS_MEMORY_NEW(klass, this); \
       cpy->trace(file, line); \
       return cpy; \
     } \
-    klass* klass::clone(std::string file, size_t line) const { \
+    klass* klass::clone(sass::string file, size_t line) const { \
       klass* cpy = copy(file, line); \
       cpy->cloneChildren(); \
       return cpy; \
@@ -127,7 +127,7 @@ private:
 
   #define IMPLEMENT_AST_OPERATORS(klass) \
     klass* klass::copy() const { \
-      return new klass(this); \
+      return SASS_MEMORY_NEW(klass, this); \
     } \
     klass* klass::clone() const { \
       klass* cpy = copy(); \

data/ext/libsass/src/ast_fwd_decl.cpp

@@ -16,14 +16,14 @@ namespace Sass {
   IMPLEMENT_BASE_CAST(AST_Node)
   IMPLEMENT_BASE_CAST(Expression)
   IMPLEMENT_BASE_CAST(Statement)
-  IMPLEMENT_BASE_CAST(Has_Block)
+  IMPLEMENT_BASE_CAST(ParentStatement)
   IMPLEMENT_BASE_CAST(PreValue)
   IMPLEMENT_BASE_CAST(Value)
   IMPLEMENT_BASE_CAST(Color)
   IMPLEMENT_BASE_CAST(List)
   IMPLEMENT_BASE_CAST(String)
   IMPLEMENT_BASE_CAST(String_Constant)
-  IMPLEMENT_BASE_CAST(Supports_Condition)
+  IMPLEMENT_BASE_CAST(SupportsCondition)
   IMPLEMENT_BASE_CAST(Selector)
   IMPLEMENT_BASE_CAST(SelectorComponent)
   IMPLEMENT_BASE_CAST(SimpleSelector)

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -4,18 +4,22 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
+#include "memory.hpp"
 #include "sass/functions.h"
-#include "memory/SharedPtr.hpp"
 
 /////////////////////////////////////////////
 // Forward declarations for the AST visitors.
 /////////////////////////////////////////////
 namespace Sass {
 
+  class SourceData;
+  class SourceFile;
+  class SynthFile;
+  class ItplFile;
+
   class AST_Node;
 
-  class Has_Block;
+  class ParentStatement;
 
   class SimpleSelector;
 
@@ -27,7 +31,7 @@ namespace Sass {
   class Statement;
   class Value;
   class Declaration;
-  class Ruleset;
+  class StyleRule;
   class Bubble;
   class Trace;
 
@@ -35,25 +39,25 @@ namespace Sass {
   class CssMediaRule;
   class CssMediaQuery;
 
-  class Supports_Block;
-  class Directive;
+  class SupportsRule;
+  class AtRule;
 
   class Keyframe_Rule;
-  class At_Root_Block;
+  class AtRootRule;
   class Assignment;
 
   class Import;
   class Import_Stub;
-  class Warning;
+  class WarningRule;
 
-  class Error;
-  class Debug;
+  class ErrorRule;
+  class DebugRule;
   class Comment;
 
   class If;
-  class For;
-  class Each;
-  class While;
+  class ForRule;
+  class EachRule;
+  class WhileRule;
   class Return;
   class Content;
   class ExtendRule;
@@ -85,10 +89,10 @@ namespace Sass {
 
   class Media_Query;
   class Media_Query_Expression;
-  class Supports_Condition;
-  class Supports_Operator;
-  class Supports_Negation;
-  class Supports_Declaration;
+  class SupportsCondition;
+  class SupportsOperation;
+  class SupportsNegation;
+  class SupportsDeclaration;
   class Supports_Interpolation;
   
   class At_Root_Query;
@@ -100,13 +104,13 @@ namespace Sass {
 
 
   class Selector_Schema;
-  class Placeholder_Selector;
-  class Type_Selector;
-  class Class_Selector;
-  class Id_Selector;
-  class Attribute_Selector;
+  class PlaceholderSelector;
+  class TypeSelector;
+  class ClassSelector;
+  class IDSelector;
+  class AttributeSelector;
 
-  class Pseudo_Selector;
+  class PseudoSelector;
   
   class SelectorComponent;
   class SelectorCombinator;
@@ -128,33 +132,38 @@ namespace Sass {
     typedef SharedImpl<type> type##Obj; \
     typedef SharedImpl<type> type##_Obj; \
 
+  IMPL_MEM_OBJ(SourceData);
+  IMPL_MEM_OBJ(SourceFile);
+  IMPL_MEM_OBJ(SynthFile);
+  IMPL_MEM_OBJ(ItplFile);
+
   IMPL_MEM_OBJ(AST_Node);
   IMPL_MEM_OBJ(Statement);
   IMPL_MEM_OBJ(Block);
-  IMPL_MEM_OBJ(Ruleset);
+  IMPL_MEM_OBJ(StyleRule);
   IMPL_MEM_OBJ(Bubble);
   IMPL_MEM_OBJ(Trace);
   IMPL_MEM_OBJ(MediaRule);
   IMPL_MEM_OBJ(CssMediaRule);
   IMPL_MEM_OBJ(CssMediaQuery);
-  IMPL_MEM_OBJ(Supports_Block);
-  IMPL_MEM_OBJ(Directive);
+  IMPL_MEM_OBJ(SupportsRule);
+  IMPL_MEM_OBJ(AtRule);
   IMPL_MEM_OBJ(Keyframe_Rule);
-  IMPL_MEM_OBJ(At_Root_Block);
+  IMPL_MEM_OBJ(AtRootRule);
   IMPL_MEM_OBJ(Declaration);
   IMPL_MEM_OBJ(Assignment);
   IMPL_MEM_OBJ(Import);
   IMPL_MEM_OBJ(Import_Stub);
-  IMPL_MEM_OBJ(Warning);
-  IMPL_MEM_OBJ(Error);
-  IMPL_MEM_OBJ(Debug);
+  IMPL_MEM_OBJ(WarningRule);
+  IMPL_MEM_OBJ(ErrorRule);
+  IMPL_MEM_OBJ(DebugRule);
   IMPL_MEM_OBJ(Comment);
   IMPL_MEM_OBJ(PreValue);
-  IMPL_MEM_OBJ(Has_Block);
+  IMPL_MEM_OBJ(ParentStatement);
   IMPL_MEM_OBJ(If);
-  IMPL_MEM_OBJ(For);
-  IMPL_MEM_OBJ(Each);
-  IMPL_MEM_OBJ(While);
+  IMPL_MEM_OBJ(ForRule);
+  IMPL_MEM_OBJ(EachRule);
+  IMPL_MEM_OBJ(WhileRule);
   IMPL_MEM_OBJ(Return);
   IMPL_MEM_OBJ(Content);
   IMPL_MEM_OBJ(ExtendRule);
@@ -182,10 +191,10 @@ namespace Sass {
   IMPL_MEM_OBJ(String_Quoted);
   IMPL_MEM_OBJ(Media_Query);
   IMPL_MEM_OBJ(Media_Query_Expression);
-  IMPL_MEM_OBJ(Supports_Condition);
-  IMPL_MEM_OBJ(Supports_Operator);
-  IMPL_MEM_OBJ(Supports_Negation);
-  IMPL_MEM_OBJ(Supports_Declaration);
+  IMPL_MEM_OBJ(SupportsCondition);
+  IMPL_MEM_OBJ(SupportsOperation);
+  IMPL_MEM_OBJ(SupportsNegation);
+  IMPL_MEM_OBJ(SupportsDeclaration);
   IMPL_MEM_OBJ(Supports_Interpolation);
   IMPL_MEM_OBJ(At_Root_Query);
   IMPL_MEM_OBJ(Null);
@@ -197,12 +206,12 @@ namespace Sass {
   IMPL_MEM_OBJ(Selector);
   IMPL_MEM_OBJ(Selector_Schema);
   IMPL_MEM_OBJ(SimpleSelector);
-  IMPL_MEM_OBJ(Placeholder_Selector);
-  IMPL_MEM_OBJ(Type_Selector);
-  IMPL_MEM_OBJ(Class_Selector);
-  IMPL_MEM_OBJ(Id_Selector);
-  IMPL_MEM_OBJ(Attribute_Selector);
-  IMPL_MEM_OBJ(Pseudo_Selector);
+  IMPL_MEM_OBJ(PlaceholderSelector);
+  IMPL_MEM_OBJ(TypeSelector);
+  IMPL_MEM_OBJ(ClassSelector);
+  IMPL_MEM_OBJ(IDSelector);
+  IMPL_MEM_OBJ(AttributeSelector);
+  IMPL_MEM_OBJ(PseudoSelector);
 
   IMPL_MEM_OBJ(SelectorComponent);
   IMPL_MEM_OBJ(SelectorCombinator);
@@ -214,12 +223,12 @@ namespace Sass {
   // some often used typedefs
   // ###########################################################################
 
-  typedef std::vector<Block*> BlockStack;
-  typedef std::vector<Sass_Callee> CalleeStack;
-  typedef std::vector<AST_Node_Obj> CallStack;
-  typedef std::vector<CssMediaRuleObj> MediaStack;
-  typedef std::vector<SelectorListObj> SelectorStack;
-  typedef std::vector<Sass_Import_Entry> ImporterStack;
+  typedef sass::vector<Block*> BlockStack;
+  typedef sass::vector<Sass_Callee> CalleeStack;
+  typedef sass::vector<AST_Node_Obj> CallStack;
+  typedef sass::vector<CssMediaRuleObj> MediaStack;
+  typedef sass::vector<SelectorListObj> SelectorStack;
+  typedef sass::vector<Sass_Import_Entry> ImporterStack;
 
   // only to switch implementations for testing
   #define environment_map std::map
@@ -248,14 +257,14 @@ namespace Sass {
   DECLARE_BASE_CAST(AST_Node)
   DECLARE_BASE_CAST(Expression)
   DECLARE_BASE_CAST(Statement)
-  DECLARE_BASE_CAST(Has_Block)
+  DECLARE_BASE_CAST(ParentStatement)
   DECLARE_BASE_CAST(PreValue)
   DECLARE_BASE_CAST(Value)
   DECLARE_BASE_CAST(List)
   DECLARE_BASE_CAST(Color)
   DECLARE_BASE_CAST(String)
   DECLARE_BASE_CAST(String_Constant)
-  DECLARE_BASE_CAST(Supports_Condition)
+  DECLARE_BASE_CAST(SupportsCondition)
   DECLARE_BASE_CAST(Selector)
   DECLARE_BASE_CAST(SimpleSelector)
   DECLARE_BASE_CAST(SelectorComponent)

data/ext/libsass/src/ast_helpers.hpp

@@ -228,7 +228,7 @@ namespace Sass {
   // that can be written with pseudo-class syntax (CSS2 vs CSS3):
   // `:before`, `:after`, `:first-line`, or `:first-letter`
   // ##########################################################################
-  inline bool isFakePseudoElement(const std::string& name)
+  inline bool isFakePseudoElement(const sass::string& name)
   {
     return Util::equalsLiteral("after", name)
       || Util::equalsLiteral("before", name)
@@ -241,7 +241,7 @@ namespace Sass {
   // and that are subselectors of their arguments.
   // For example, `.foo` is a superselector of `:matches(.foo)`.
   // ##########################################################################
-  inline bool isSubselectorPseudo(const std::string& norm)
+  inline bool isSubselectorPseudo(const sass::string& norm)
   {
     return Util::equalsLiteral("any", norm)
       || Util::equalsLiteral("matches", norm)
@@ -253,7 +253,7 @@ namespace Sass {
   // ###########################################################################
   // Pseudo-class selectors that take unadorned selectors as arguments.
   // ###########################################################################
-  inline bool isSelectorPseudoClass(const std::string& test)
+  inline bool isSelectorPseudoClass(const sass::string& test)
   {
     return Util::equalsLiteral("not", test)
       || Util::equalsLiteral("matches", test)
@@ -268,7 +268,7 @@ namespace Sass {
   // ###########################################################################
   // Pseudo-element selectors that take unadorned selectors as arguments.
   // ###########################################################################
-  inline bool isSelectorPseudoElement(const std::string& test)
+  inline bool isSelectorPseudoElement(const sass::string& test)
   {
     return Util::equalsLiteral("slotted", test);
   }
@@ -277,7 +277,7 @@ namespace Sass {
   // ###########################################################################
   // Pseudo-element selectors that has binominals
   // ###########################################################################
-  inline bool isSelectorPseudoBinominal(const std::string& test)
+  inline bool isSelectorPseudoBinominal(const sass::string& test)
   {
     return Util::equalsLiteral("nth-child", test)
       || Util::equalsLiteral("nth-last-child", test);

data/ext/libsass/src/ast_sel_cmp.cpp

@@ -299,69 +299,69 @@ namespace Sass {
   /*#########################################################################*/
   /*#########################################################################*/
 
-  bool Id_Selector::operator== (const SimpleSelector& rhs) const
+  bool IDSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Id_Selector>(&rhs);
+    auto sel = Cast<IDSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Type_Selector::operator== (const SimpleSelector& rhs) const
+  bool TypeSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Type_Selector>(&rhs);
+    auto sel = Cast<TypeSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Class_Selector::operator== (const SimpleSelector& rhs) const
+  bool ClassSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Class_Selector>(&rhs);
+    auto sel = Cast<ClassSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Pseudo_Selector::operator== (const SimpleSelector& rhs) const
+  bool PseudoSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Pseudo_Selector>(&rhs);
+    auto sel = Cast<PseudoSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Attribute_Selector::operator== (const SimpleSelector& rhs) const
+  bool AttributeSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Attribute_Selector>(&rhs);
+    auto sel = Cast<AttributeSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Placeholder_Selector::operator== (const SimpleSelector& rhs) const
+  bool PlaceholderSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Placeholder_Selector>(&rhs);
+    auto sel = Cast<PlaceholderSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
   /*#########################################################################*/
   /*#########################################################################*/
 
-  bool Id_Selector::operator== (const Id_Selector& rhs) const
+  bool IDSelector::operator== (const IDSelector& rhs) const
   {
     // ID has no namespacing
     return name() == rhs.name();
   }
 
-  bool Type_Selector::operator== (const Type_Selector& rhs) const
+  bool TypeSelector::operator== (const TypeSelector& rhs) const
   {
     return is_ns_eq(rhs) && name() == rhs.name();
   }
 
-  bool Class_Selector::operator== (const Class_Selector& rhs) const
+  bool ClassSelector::operator== (const ClassSelector& rhs) const
   {
     // Class has no namespacing
     return name() == rhs.name();
   }
 
-  bool Placeholder_Selector::operator== (const Placeholder_Selector& rhs) const
+  bool PlaceholderSelector::operator== (const PlaceholderSelector& rhs) const
   {
     // Placeholder has no namespacing
     return name() == rhs.name();
   }
 
-  bool Attribute_Selector::operator== (const Attribute_Selector& rhs) const
+  bool AttributeSelector::operator== (const AttributeSelector& rhs) const
   {
     // smaller return, equal go on, bigger abort
     if (is_ns_eq(rhs)) {
@@ -375,7 +375,7 @@ namespace Sass {
     else { return false; }
   }
 
-  bool Pseudo_Selector::operator== (const Pseudo_Selector& rhs) const
+  bool PseudoSelector::operator== (const PseudoSelector& rhs) const
   {
     if (is_ns_eq(rhs)) {
       if (name() != rhs.name()) return false;

data/ext/libsass/src/ast_sel_super.cpp

@@ -19,8 +19,8 @@ namespace Sass {
   // [list2] matches, as well as possibly additional elements.
   // ##########################################################################
   bool listIsSuperslector(
-    const std::vector<ComplexSelectorObj>& list1,
-    const std::vector<ComplexSelectorObj>& list2);
+    const sass::vector<ComplexSelectorObj>& list1,
+    const sass::vector<ComplexSelectorObj>& list2);
 
   // ##########################################################################
   // Returns whether [complex1] is a superselector of [complex2].
@@ -28,19 +28,19 @@ namespace Sass {
   // [complex2] matches, as well as possibly additional elements.
   // ##########################################################################
   bool complexIsSuperselector(
-    const std::vector<SelectorComponentObj>& complex1,
-    const std::vector<SelectorComponentObj>& complex2);
+    const sass::vector<SelectorComponentObj>& complex1,
+    const sass::vector<SelectorComponentObj>& complex2);
 
   // ##########################################################################
   // Returns all pseudo selectors in [compound] that have
   // a selector argument, and that have the given [name].
   // ##########################################################################
-  std::vector<Pseudo_Selector_Obj> selectorPseudoNamed(
-    CompoundSelectorObj compound, std::string name)
+  sass::vector<PseudoSelectorObj> selectorPseudoNamed(
+    CompoundSelectorObj compound, sass::string name)
   {
-    std::vector<Pseudo_Selector_Obj> rv;
+    sass::vector<PseudoSelectorObj> rv;
     for (SimpleSelectorObj sel : compound->elements()) {
-      if (Pseudo_Selector_Obj pseudo = Cast<Pseudo_Selector>(sel)) {
+      if (PseudoSelectorObj pseudo = Cast<PseudoSelector>(sel)) {
         if (pseudo->isClass() && pseudo->selector()) {
           if (sel->name() == name) {
             rv.push_back(sel);
@@ -66,7 +66,7 @@ namespace Sass {
       return true;
     }
     // Some selector pseudoclasses can match normal selectors.
-    if (const Pseudo_Selector* pseudo = Cast<Pseudo_Selector>(simple2)) {
+    if (const PseudoSelector* pseudo = Cast<PseudoSelector>(simple2)) {
       if (pseudo->selector() && isSubselectorPseudo(pseudo->normalized())) {
         for (auto complex : pseudo->selector()->elements()) {
           // Make sure we have exacly one items
@@ -109,11 +109,11 @@ namespace Sass {
   // ##########################################################################
   // ##########################################################################
   bool typeIsSuperselectorOfCompound(
-    const Type_Selector_Obj& type,
+    const TypeSelectorObj& type,
     const CompoundSelectorObj& compound)
   {
     for (const SimpleSelectorObj& simple : compound->elements()) {
-      if (const Type_Selector_Obj& rhs = Cast<Type_Selector>(simple)) {
+      if (const TypeSelectorObj& rhs = Cast<TypeSelector>(simple)) {
         if (*type != *rhs) return true;
       }
     }
@@ -124,11 +124,11 @@ namespace Sass {
   // ##########################################################################
   // ##########################################################################
   bool idIsSuperselectorOfCompound(
-    const Id_Selector_Obj& id,
+    const IDSelectorObj& id,
     const CompoundSelectorObj& compound)
   {
     for (const SimpleSelectorObj& simple : compound->elements()) {
-      if (const Id_Selector_Obj& rhs = Cast<Id_Selector>(simple)) {
+      if (const IDSelectorObj& rhs = Cast<IDSelector>(simple)) {
         if (*id != *rhs) return true;
       }
     }
@@ -139,8 +139,8 @@ namespace Sass {
   // ##########################################################################
   // ##########################################################################
   bool pseudoIsSuperselectorOfPseudo(
-    const Pseudo_Selector_Obj& pseudo1,
-    const Pseudo_Selector_Obj& pseudo2,
+    const PseudoSelectorObj& pseudo1,
+    const PseudoSelectorObj& pseudo2,
     const ComplexSelectorObj& parent
   )
   {
@@ -156,22 +156,22 @@ namespace Sass {
   // ##########################################################################
   // ##########################################################################
   bool pseudoNotIsSuperselectorOfCompound(
-    const Pseudo_Selector_Obj& pseudo1,
+    const PseudoSelectorObj& pseudo1,
     const CompoundSelectorObj& compound2,
     const ComplexSelectorObj& parent)
   {
     for (const SimpleSelectorObj& simple2 : compound2->elements()) {
-      if (const Type_Selector_Obj& type2 = Cast<Type_Selector>(simple2)) {
+      if (const TypeSelectorObj& type2 = Cast<TypeSelector>(simple2)) {
         if (const CompoundSelectorObj& compound1 = Cast<CompoundSelector>(parent->last())) {
           if (typeIsSuperselectorOfCompound(type2, compound1)) return true;
         }
       }
-      else if (const Id_Selector_Obj& id2 = Cast<Id_Selector>(simple2)) {
+      else if (const IDSelectorObj& id2 = Cast<IDSelector>(simple2)) {
         if (const CompoundSelectorObj& compound1 = Cast<CompoundSelector>(parent->last())) {
           if (idIsSuperselectorOfCompound(id2, compound1)) return true;
         }
       }
-      else if (const Pseudo_Selector_Obj& pseudo2 = Cast<Pseudo_Selector>(simple2)) {
+      else if (const PseudoSelectorObj& pseudo2 = Cast<PseudoSelector>(simple2)) {
         if (pseudoIsSuperselectorOfPseudo(pseudo1, pseudo2, parent)) return true;
       }
     }
@@ -189,21 +189,21 @@ namespace Sass {
   // parent selectors in the selector argument match [parents].
   // ##########################################################################
   bool selectorPseudoIsSuperselector(
-    const Pseudo_Selector_Obj& pseudo1,
+    const PseudoSelectorObj& pseudo1,
     const CompoundSelectorObj& compound2,
     // ToDo: is this really the most convenient way to do this?
-    std::vector<SelectorComponentObj>::const_iterator parents_from,
-    std::vector<SelectorComponentObj>::const_iterator parents_to)
+    sass::vector<SelectorComponentObj>::const_iterator parents_from,
+    sass::vector<SelectorComponentObj>::const_iterator parents_to)
   {
 
     // ToDo: move normalization function
-    std::string name(Util::unvendor(pseudo1->name()));
+    sass::string name(Util::unvendor(pseudo1->name()));
 
     if (name == "matches" || name == "any") {
-      std::vector<Pseudo_Selector_Obj> pseudos =
+      sass::vector<PseudoSelectorObj> pseudos =
         selectorPseudoNamed(compound2, pseudo1->name());
       SelectorListObj selector1 = pseudo1->selector();
-      for (Pseudo_Selector_Obj pseudo2 : pseudos) {
+      for (PseudoSelectorObj pseudo2 : pseudos) {
         SelectorListObj selector = pseudo2->selector();
         if (selector1->isSuperselectorOf(selector)) {
           return true;
@@ -211,7 +211,7 @@ namespace Sass {
       }
 
       for (ComplexSelectorObj complex1 : selector1->elements()) {
-        std::vector<SelectorComponentObj> parents;
+        sass::vector<SelectorComponentObj> parents;
         for (auto cur = parents_from; cur != parents_to; cur++) {
           parents.push_back(*cur);
         }
@@ -223,10 +223,10 @@ namespace Sass {
 
     }
     else if (name == "has" || name == "host" || name == "host-context" || name == "slotted") {
-      std::vector<Pseudo_Selector_Obj> pseudos =
+      sass::vector<PseudoSelectorObj> pseudos =
         selectorPseudoNamed(compound2, pseudo1->name());
       SelectorListObj selector1 = pseudo1->selector();
-      for (Pseudo_Selector_Obj pseudo2 : pseudos) {
+      for (PseudoSelectorObj pseudo2 : pseudos) {
         SelectorListObj selector = pseudo2->selector();
         if (selector1->isSuperselectorOf(selector)) {
           return true;
@@ -241,16 +241,16 @@ namespace Sass {
       return true;
     }
     else if (name == "current") {
-      std::vector<Pseudo_Selector_Obj> pseudos =
+      sass::vector<PseudoSelectorObj> pseudos =
         selectorPseudoNamed(compound2, "current");
-      for (Pseudo_Selector_Obj pseudo2 : pseudos) {
+      for (PseudoSelectorObj pseudo2 : pseudos) {
         if (ObjEqualityFn(pseudo1, pseudo2)) return true;
       }
 
     }
     else if (name == "nth-child" || name == "nth-last-child") {
       for (auto simple2 : compound2->elements()) {
-        if (Pseudo_Selector_Obj pseudo2 = simple2->getPseudoSelector()) {
+        if (PseudoSelectorObj pseudo2 = simple2->getPseudoSelector()) {
           if (pseudo1->name() != pseudo2->name()) continue;
           if (!ObjEqualityFn(pseudo1->argument(), pseudo2->argument())) continue;
           if (pseudo1->selector()->isSuperselectorOf(pseudo2->selector())) return true;
@@ -276,13 +276,13 @@ namespace Sass {
     const CompoundSelectorObj& compound1,
     const CompoundSelectorObj& compound2,
     // ToDo: is this really the most convenient way to do this?
-    const std::vector<SelectorComponentObj>::const_iterator parents_from,
-    const std::vector<SelectorComponentObj>::const_iterator parents_to)
+    const sass::vector<SelectorComponentObj>::const_iterator parents_from,
+    const sass::vector<SelectorComponentObj>::const_iterator parents_to)
   {
     // Every selector in [compound1.components] must have
     // a matching selector in [compound2.components].
     for (SimpleSelectorObj simple1 : compound1->elements()) {
-      Pseudo_Selector_Obj pseudo1 = Cast<Pseudo_Selector>(simple1);
+      PseudoSelectorObj pseudo1 = Cast<PseudoSelector>(simple1);
       if (pseudo1 && pseudo1->selector()) {
         if (!selectorPseudoIsSuperselector(pseudo1, compound2, parents_from, parents_to)) {
           return false;
@@ -295,7 +295,7 @@ namespace Sass {
     // [compound1] can't be a superselector of a selector
     // with pseudo-elements that [compound2] doesn't share.
     for (SimpleSelectorObj simple2 : compound2->elements()) {
-      Pseudo_Selector_Obj pseudo2 = Cast<Pseudo_Selector>(simple2);
+      PseudoSelectorObj pseudo2 = Cast<PseudoSelector>(simple2);
       if (pseudo2 && pseudo2->isElement()) {
         if (!simpleIsSuperselectorOfCompound(pseudo2, compound1)) {
           return false;
@@ -317,7 +317,7 @@ namespace Sass {
   bool compoundIsSuperselector(
     const CompoundSelectorObj& compound1,
     const CompoundSelectorObj& compound2,
-    const std::vector<SelectorComponentObj>& parents)
+    const sass::vector<SelectorComponentObj>& parents)
   {
     return compoundIsSuperselector(
       compound1, compound2,
@@ -332,8 +332,8 @@ namespace Sass {
   // [complex2] matches, as well as possibly additional elements.
   // ##########################################################################
   bool complexIsSuperselector(
-    const std::vector<SelectorComponentObj>& complex1,
-    const std::vector<SelectorComponentObj>& complex2)
+    const sass::vector<SelectorComponentObj>& complex1,
+    const sass::vector<SelectorComponentObj>& complex2)
   {
 
     // Selectors with trailing operators are neither superselectors nor subselectors.
@@ -368,14 +368,14 @@ namespace Sass {
       CompoundSelectorObj compound2 = Cast<CompoundSelector>(complex2.back());
 
       if (remaining1 == 1) {
-        std::vector<SelectorComponentObj>::const_iterator parents_to = complex2.end();
-        std::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
+        sass::vector<SelectorComponentObj>::const_iterator parents_to = complex2.end();
+        sass::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
         std::advance(parents_from, i2 + 1); // equivalent to dart `.skip(i2 + 1)`
         bool rv = compoundIsSuperselector(compound1, compound2, parents_from, parents_to);
-        std::vector<SelectorComponentObj> pp;
+        sass::vector<SelectorComponentObj> pp;
 
-        std::vector<SelectorComponentObj>::const_iterator end = parents_to;
-        std::vector<SelectorComponentObj>::const_iterator beg = parents_from;
+        sass::vector<SelectorComponentObj>::const_iterator end = parents_to;
+        sass::vector<SelectorComponentObj>::const_iterator beg = parents_from;
         while (beg != end) {
           pp.push_back(*beg);
           beg++;
@@ -393,8 +393,8 @@ namespace Sass {
       for (; afterSuperselector < complex2.size(); afterSuperselector++) {
         SelectorComponentObj component2 = complex2[afterSuperselector - 1];
         if (CompoundSelectorObj compound2 = Cast<CompoundSelector>(component2)) {
-          std::vector<SelectorComponentObj>::const_iterator parents_to = complex2.begin();
-          std::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
+          sass::vector<SelectorComponentObj>::const_iterator parents_to = complex2.begin();
+          sass::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
           // complex2.take(afterSuperselector - 1).skip(i2 + 1)
           std::advance(parents_from, i2 + 1); // equivalent to dart `.skip`
           std::advance(parents_to, afterSuperselector); // equivalent to dart `.take`
@@ -464,8 +464,8 @@ namespace Sass {
   // since `B X` is a superselector of `B A X`.
   // ##########################################################################
   bool complexIsParentSuperselector(
-    const std::vector<SelectorComponentObj>& complex1,
-    const std::vector<SelectorComponentObj>& complex2)
+    const sass::vector<SelectorComponentObj>& complex1,
+    const sass::vector<SelectorComponentObj>& complex2)
   {
     // Try some simple heuristics to see if we can avoid allocations.
     if (complex1.empty() && complex2.empty()) return false;
@@ -473,8 +473,8 @@ namespace Sass {
     if (Cast<SelectorCombinator>(complex2.front())) return false;
     if (complex1.size() > complex2.size()) return false;
     // TODO(nweiz): There's got to be a way to do this without a bunch of extra allocations...
-    std::vector<SelectorComponentObj> cplx1(complex1);
-    std::vector<SelectorComponentObj> cplx2(complex2);
+    sass::vector<SelectorComponentObj> cplx1(complex1);
+    sass::vector<SelectorComponentObj> cplx2(complex2);
     CompoundSelectorObj base = SASS_MEMORY_NEW(CompoundSelector, "[tmp]");
     cplx1.push_back(base); cplx2.push_back(base);
     return complexIsSuperselector(cplx1, cplx2);
@@ -487,7 +487,7 @@ namespace Sass {
   // [complex] matches, as well as possibly additional elements.
   // ##########################################################################
   bool listHasSuperslectorForComplex(
-    std::vector<ComplexSelectorObj> list,
+    sass::vector<ComplexSelectorObj> list,
     ComplexSelectorObj complex)
   {
     // Return true if every [complex] selector on [list2]
@@ -507,8 +507,8 @@ namespace Sass {
   // [list2] matches, as well as possibly additional elements.
   // ##########################################################################
   bool listIsSuperslector(
-    const std::vector<ComplexSelectorObj>& list1,
-    const std::vector<ComplexSelectorObj>& list2)
+    const sass::vector<ComplexSelectorObj>& list1,
+    const sass::vector<ComplexSelectorObj>& list2)
   {
     // Return true if every [complex] selector on [list2]
     // is a super selector of the full selector [list1].