sassc 2.3.0 → 2.4.0

data/ext/libsass/src/ast_sel_unify.cpp

@@ -13,14 +13,14 @@ namespace Sass {
   // ##########################################################################
   // ToDo: fine-tune API to avoid unnecessary wrapper allocations
   // ##########################################################################
-  std::vector<std::vector<SelectorComponentObj>> unifyComplex(
-    const std::vector<std::vector<SelectorComponentObj>>& complexes)
+  sass::vector<sass::vector<SelectorComponentObj>> unifyComplex(
+    const sass::vector<sass::vector<SelectorComponentObj>>& complexes)
   {
 
     SASS_ASSERT(!complexes.empty(), "Can't unify empty list");
     if (complexes.size() == 1) return complexes;
 
-    CompoundSelectorObj unifiedBase = SASS_MEMORY_NEW(CompoundSelector, ParserState("[phony]"));
+    CompoundSelectorObj unifiedBase = SASS_MEMORY_NEW(CompoundSelector, SourceSpan("[phony]"));
     for (auto complex : complexes) {
       SelectorComponentObj base = complex.back();
       if (CompoundSelector * comp = base->getCompound()) {
@@ -39,9 +39,9 @@ namespace Sass {
       }
     }
 
-    std::vector<std::vector<SelectorComponentObj>> complexesWithoutBases;
+    sass::vector<sass::vector<SelectorComponentObj>> complexesWithoutBases;
     for (size_t i = 0; i < complexes.size(); i += 1) {
-      std::vector<SelectorComponentObj> sel = complexes[i];
+      sass::vector<SelectorComponentObj> sel = complexes[i];
       sel.pop_back(); // remove last item (base) from the list
       complexesWithoutBases.push_back(std::move(sel));
     }
@@ -120,13 +120,13 @@ namespace Sass {
   // ##########################################################################
   // This is implemented in `selector/type.dart` as `PseudoSelector::unify`
   // ##########################################################################
-  CompoundSelector* Type_Selector::unifyWith(CompoundSelector* rhs)
+  CompoundSelector* TypeSelector::unifyWith(CompoundSelector* rhs)
   {
     if (rhs->empty()) {
       rhs->append(this);
       return rhs;
     }
-    Type_Selector* type = Cast<Type_Selector>(rhs->at(0));
+    TypeSelector* type = Cast<TypeSelector>(rhs->at(0));
     if (type != nullptr) {
       SimpleSelector* unified = unifyWith(type);
       if (unified == nullptr) {
@@ -143,10 +143,10 @@ namespace Sass {
   // ##########################################################################
   // This is implemented in `selector/id.dart` as `PseudoSelector::unify`
   // ##########################################################################
-  CompoundSelector* Id_Selector::unifyWith(CompoundSelector* rhs)
+  CompoundSelector* IDSelector::unifyWith(CompoundSelector* rhs)
   {
     for (const SimpleSelector* sel : rhs->elements()) {
-      if (const Id_Selector* id_sel = Cast<Id_Selector>(sel)) {
+      if (const IDSelector* id_sel = Cast<IDSelector>(sel)) {
         if (id_sel->name() != name()) return nullptr;
       }
     }
@@ -156,7 +156,7 @@ namespace Sass {
   // ##########################################################################
   // This is implemented in `selector/pseudo.dart` as `PseudoSelector::unify`
   // ##########################################################################
-  CompoundSelector* Pseudo_Selector::unifyWith(CompoundSelector* compound)
+  CompoundSelector* PseudoSelector::unifyWith(CompoundSelector* compound)
   {
 
     if (compound->length() == 1 && compound->first()->is_universal()) {
@@ -174,7 +174,7 @@ namespace Sass {
     bool addedThis = false;
     for (auto simple : compound->elements()) {
       // Make sure pseudo selectors always come last.
-      if (Pseudo_Selector_Obj pseudo = simple->getPseudoSelector()) {
+      if (PseudoSelectorObj pseudo = simple->getPseudoSelector()) {
         if (pseudo->isElement()) {
           // A given compound selector may only contain one pseudo element. If
           // [compound] has a different one than [this], unification fails.
@@ -197,7 +197,7 @@ namespace Sass {
     return result.detach();
 
   }
-  // EO Pseudo_Selector::unifyWith(CompoundSelector*
+  // EO PseudoSelector::unifyWith(CompoundSelector*
 
   // ##########################################################################
   // This is implemented in `extend/functions.dart` as `unifyUniversalAndElement`
@@ -206,7 +206,7 @@ namespace Sass {
   // or [TypeSelector]s. If no such selector can be produced, returns `null`.
   // Note: libsass handles universal selector directly within the type selector
   // ##########################################################################
-  SimpleSelector* Type_Selector::unifyWith(const SimpleSelector* rhs)
+  SimpleSelector* TypeSelector::unifyWith(const SimpleSelector* rhs)
   {
     bool rhs_ns = false;
     if (!(is_ns_eq(*rhs) || rhs->is_universal_ns())) {
@@ -229,7 +229,7 @@ namespace Sass {
     if (rhs_name) name(rhs->name());
     return this;
   }
-  // EO Type_Selector::unifyWith(const SimpleSelector*)
+  // EO TypeSelector::unifyWith(const SimpleSelector*)
 
   // ##########################################################################
   // Unify two complex selectors. Internally calls `unifyComplex`
@@ -238,9 +238,9 @@ namespace Sass {
   SelectorList* ComplexSelector::unifyWith(ComplexSelector* rhs)
   {
     SelectorListObj list = SASS_MEMORY_NEW(SelectorList, pstate());
-    std::vector<std::vector<SelectorComponentObj>> rv =
+    sass::vector<sass::vector<SelectorComponentObj>> rv =
        unifyComplex({ elements(), rhs->elements() });
-    for (std::vector<SelectorComponentObj> items : rv) {
+    for (sass::vector<SelectorComponentObj> items : rv) {
       ComplexSelectorObj sel = SASS_MEMORY_NEW(ComplexSelector, pstate());
       sel->elements() = std::move(items);
       list->append(sel);

data/ext/libsass/src/ast_sel_weave.cpp

@@ -24,8 +24,8 @@ namespace Sass {
   // ##########################################################################
   bool isUnique(const SimpleSelector* simple)
   {
-    if (Cast<Id_Selector>(simple)) return true;
-    if (const Pseudo_Selector * pseudo = Cast<Pseudo_Selector>(simple)) {
+    if (Cast<IDSelector>(simple)) return true;
+    if (const PseudoSelector * pseudo = Cast<PseudoSelector>(simple)) {
       if (pseudo->is_pseudo_element()) return true;
     }
     return false;
@@ -38,11 +38,11 @@ namespace Sass {
   // selectors contain the same unique simple selector, such as an ID.
   // ##########################################################################
   bool mustUnify(
-    const std::vector<SelectorComponentObj>& complex1,
-    const std::vector<SelectorComponentObj>& complex2)
+    const sass::vector<SelectorComponentObj>& complex1,
+    const sass::vector<SelectorComponentObj>& complex2)
   {
 
-    std::vector<const SimpleSelector*> uniqueSelectors1;
+    sass::vector<const SimpleSelector*> uniqueSelectors1;
     for (const SelectorComponent* component : complex1) {
       if (const CompoundSelector * compound = component->getCompound()) {
         for (const SimpleSelector* sel : compound->elements()) {
@@ -76,9 +76,9 @@ namespace Sass {
   // Helper function used by `weaveParents`
   // ##########################################################################
   bool cmpGroups(
-    const std::vector<SelectorComponentObj>& group1,
-    const std::vector<SelectorComponentObj>& group2,
-    std::vector<SelectorComponentObj>& select)
+    const sass::vector<SelectorComponentObj>& group1,
+    const sass::vector<SelectorComponentObj>& group2,
+    sass::vector<SelectorComponentObj>& select)
   {
 
     if (group1.size() == group2.size() && std::equal(group1.begin(), group1.end(), group2.begin(), PtrObjEqualityFn<SelectorComponent>)) {
@@ -109,7 +109,7 @@ namespace Sass {
       return false;
     }
 
-    std::vector<std::vector<SelectorComponentObj>> unified
+    sass::vector<sass::vector<SelectorComponentObj>> unified
       = unifyComplex({ group1, group2 });
     if (unified.empty()) return false;
     if (unified.size() > 1) return false;
@@ -131,8 +131,8 @@ namespace Sass {
   // Helper function used by `weaveParents`
   // ##########################################################################
   bool cmpChunkForEmptySequence(
-    const std::vector<std::vector<SelectorComponentObj>>& seq,
-    const std::vector<SelectorComponentObj>& group)
+    const sass::vector<sass::vector<SelectorComponentObj>>& seq,
+    const sass::vector<SelectorComponentObj>& group)
   {
     return seq.empty();
   }
@@ -142,8 +142,8 @@ namespace Sass {
   // Helper function used by `weaveParents`
   // ##########################################################################
   bool cmpChunkForParentSuperselector(
-    const std::vector< std::vector<SelectorComponentObj>>& seq,
-    const std::vector<SelectorComponentObj>& group)
+    const sass::vector<sass::vector<SelectorComponentObj>>& seq,
+    const sass::vector<SelectorComponentObj>& group)
   {
     return seq.empty() || complexIsParentSuperselector(seq.front(), group);
   }
@@ -159,18 +159,18 @@ namespace Sass {
   // (1 2 A B C)]`. The queues would then contain `(D E)` and `(3 4 5)`.
   // ##########################################################################
   template <class T>
-  std::vector<std::vector<T>> getChunks(
-    std::vector<T>& queue1, std::vector<T>& queue2,
-    const T& group, bool(*done)(const std::vector<T>&, const T&)
+  sass::vector<sass::vector<T>> getChunks(
+    sass::vector<T>& queue1, sass::vector<T>& queue2,
+    const T& group, bool(*done)(const sass::vector<T>&, const T&)
   ) {
 
-    std::vector<T> chunk1;
+    sass::vector<T> chunk1;
     while (!done(queue1, group)) {
       chunk1.push_back(queue1.front());
       queue1.erase(queue1.begin());
     }
 
-    std::vector<T> chunk2;
+    sass::vector<T> chunk2;
     while (!done(queue2, group)) {
       chunk2.push_back(queue2.front());
       queue2.erase(queue2.begin());
@@ -180,7 +180,7 @@ namespace Sass {
     else if (chunk1.empty()) return { chunk2 };
     else if (chunk2.empty()) return { chunk1 };
 
-    std::vector<T> choice1(chunk1), choice2(chunk2);
+    sass::vector<T> choice1(chunk1), choice2(chunk2);
     std::move(std::begin(chunk2), std::end(chunk2),
       std::inserter(choice1, std::end(choice1)));
     std::move(std::begin(chunk1), std::end(chunk1),
@@ -193,7 +193,7 @@ namespace Sass {
   // If the first element of [queue] has a `::root` 
   // selector, removes and returns that element.
   // ##########################################################################
-  CompoundSelectorObj getFirstIfRoot(std::vector<SelectorComponentObj>& queue) {
+  CompoundSelectorObj getFirstIfRoot(sass::vector<SelectorComponentObj>& queue) {
     if (queue.empty()) return {};
     SelectorComponent* first = queue.front();
     if (CompoundSelector* sel = Cast<CompoundSelector>(first)) {
@@ -210,12 +210,12 @@ namespace Sass {
   // contains two adjacent [ComplexSelector]s. For example,
   // `(A B > C D + E ~ > G)` is grouped into `[(A) (B > C) (D + E ~ > G)]`.
   // ##########################################################################
-  std::vector<std::vector<SelectorComponentObj>> groupSelectors(
-    const std::vector<SelectorComponentObj>& components)
+  sass::vector<sass::vector<SelectorComponentObj>> groupSelectors(
+    const sass::vector<SelectorComponentObj>& components)
   {
     bool lastWasCompound = false;
-    std::vector<SelectorComponentObj> group;
-    std::vector<std::vector<SelectorComponentObj>> groups;
+    sass::vector<SelectorComponentObj> group;
+    sass::vector<sass::vector<SelectorComponentObj>> groups;
     for (size_t i = 0; i < components.size(); i += 1) {
       if (CompoundSelector* compound = components[i]->getCompound()) {
         if (lastWasCompound) {
@@ -244,19 +244,19 @@ namespace Sass {
   // If the combinators can't be merged, returns `null`.
   // ##########################################################################
   bool mergeInitialCombinators(
-    std::vector<SelectorComponentObj>& components1,
-    std::vector<SelectorComponentObj>& components2,
-    std::vector<SelectorComponentObj>& result)
+    sass::vector<SelectorComponentObj>& components1,
+    sass::vector<SelectorComponentObj>& components2,
+    sass::vector<SelectorComponentObj>& result)
   {
 
-    std::vector<SelectorComponentObj> combinators1;
+    sass::vector<SelectorComponentObj> combinators1;
     while (!components1.empty() && Cast<SelectorCombinator>(components1.front())) {
       SelectorCombinatorObj front = Cast<SelectorCombinator>(components1.front());
       components1.erase(components1.begin());
       combinators1.push_back(front);
     }
 
-    std::vector<SelectorComponentObj> combinators2;
+    sass::vector<SelectorComponentObj> combinators2;
     while (!components2.empty() && Cast<SelectorCombinator>(components2.front())) {
       SelectorCombinatorObj front = Cast<SelectorCombinator>(components2.front());
       components2.erase(components2.begin());
@@ -265,7 +265,7 @@ namespace Sass {
 
     // If neither sequence of combinators is a subsequence
     // of the other, they cannot be merged successfully.
-    std::vector<SelectorComponentObj> LCS = lcs<SelectorComponentObj>(combinators1, combinators2);
+    sass::vector<SelectorComponentObj> LCS = lcs<SelectorComponentObj>(combinators1, combinators2);
 
     if (ListEquality(LCS, combinators1, PtrObjEqualityFn<SelectorComponent>)) {
       result = combinators2;
@@ -288,9 +288,9 @@ namespace Sass {
   // empty list. If the sequences can't be merged, returns `null`.
   // ##########################################################################
   bool mergeFinalCombinators(
-    std::vector<SelectorComponentObj>& components1,
-    std::vector<SelectorComponentObj>& components2,
-    std::vector<std::vector<std::vector<SelectorComponentObj>>>& result)
+    sass::vector<SelectorComponentObj>& components1,
+    sass::vector<SelectorComponentObj>& components2,
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>>& result)
   {
 
     if (components1.empty() || !Cast<SelectorCombinator>(components1.back())) {
@@ -299,14 +299,14 @@ namespace Sass {
       }
     }
     
-    std::vector<SelectorComponentObj> combinators1;
+    sass::vector<SelectorComponentObj> combinators1;
     while (!components1.empty() && Cast<SelectorCombinator>(components1.back())) {
       SelectorCombinatorObj back = Cast<SelectorCombinator>(components1.back());
       components1.erase(components1.end() - 1);
       combinators1.push_back(back);
     }
 
-    std::vector<SelectorComponentObj> combinators2;
+    sass::vector<SelectorComponentObj> combinators2;
     while (!components2.empty() && Cast<SelectorCombinator>(components2.back())) {
       SelectorCombinatorObj back = Cast<SelectorCombinator>(components2.back());
       components2.erase(components2.end() - 1);
@@ -356,7 +356,7 @@ namespace Sass {
           result.push_back({ { compound1, combinator1 } });
         }
         else {
-          std::vector<std::vector<SelectorComponentObj>> choices;
+          sass::vector<sass::vector<SelectorComponentObj>> choices;
           choices.push_back({ compound1, combinator1, compound2, combinator2 });
           choices.push_back({ compound2, combinator2, compound1, combinator1 });
           if (CompoundSelector* unified = compound1->unifyWith(compound2)) {
@@ -378,7 +378,7 @@ namespace Sass {
         }
         else {
           CompoundSelectorObj unified = compound1->unifyWith(compound2);
-          std::vector<std::vector<SelectorComponentObj>> items;
+          sass::vector<sass::vector<SelectorComponentObj>> items;
           
           if (!unified.isNull()) {
             items.push_back({
@@ -463,10 +463,10 @@ namespace Sass {
   // exponential output for very little gain. The selector `.D (.A .B)`
   // is represented as the list `[[.D], [.A, .B]]`.
   // ##########################################################################
-  std::vector<std::vector<SelectorComponentObj>> weave(
-    const std::vector<std::vector<SelectorComponentObj>>& complexes) {
+  sass::vector<sass::vector<SelectorComponentObj>> weave(
+    const sass::vector<sass::vector<SelectorComponentObj>>& complexes) {
 
-    std::vector<std::vector<SelectorComponentObj>> prefixes;
+    sass::vector<sass::vector<SelectorComponentObj>> prefixes;
 
     prefixes.push_back(complexes.at(0));
 
@@ -475,7 +475,7 @@ namespace Sass {
       if (complexes[i].empty()) {
         continue;
       }
-      const std::vector<SelectorComponentObj>& complex = complexes[i];
+      const sass::vector<SelectorComponentObj>& complex = complexes[i];
       SelectorComponent* target = complex.back();
       if (complex.size() == 1) {
         for (auto& prefix : prefixes) {
@@ -484,13 +484,13 @@ namespace Sass {
         continue;
       }
 
-      std::vector<SelectorComponentObj> parents(complex);
+      sass::vector<SelectorComponentObj> parents(complex);
 
       parents.pop_back();
 
-      std::vector<std::vector<SelectorComponentObj>> newPrefixes;
-      for (std::vector<SelectorComponentObj> prefix : prefixes) {
-        std::vector<std::vector<SelectorComponentObj>>
+      sass::vector<sass::vector<SelectorComponentObj>> newPrefixes;
+      for (sass::vector<SelectorComponentObj> prefix : prefixes) {
+        sass::vector<sass::vector<SelectorComponentObj>>
           parentPrefixes = weaveParents(prefix, parents);
         if (parentPrefixes.empty()) continue;
         for (auto& parentPrefix : parentPrefixes) {
@@ -519,13 +519,13 @@ namespace Sass {
   // elements matched by `A X` and all elements matched by `B X`. Some `AB_i`
   // are elided to reduce the size of the output.
   // ##########################################################################
-  std::vector<std::vector<SelectorComponentObj>> weaveParents(
-    std::vector<SelectorComponentObj> queue1,
-    std::vector<SelectorComponentObj> queue2)
+  sass::vector<sass::vector<SelectorComponentObj>> weaveParents(
+    sass::vector<SelectorComponentObj> queue1,
+    sass::vector<SelectorComponentObj> queue2)
   {
 
-    std::vector<SelectorComponentObj> leads;
-    std::vector<std::vector<std::vector<SelectorComponentObj>>> trails;
+    sass::vector<SelectorComponentObj> leads;
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>> trails;
     if (!mergeInitialCombinators(queue1, queue2, leads)) return {};
     if (!mergeFinalCombinators(queue1, queue2, trails)) return {};
     // list comes out in reverse order for performance
@@ -550,27 +550,27 @@ namespace Sass {
     }
 
     // group into sub-lists so no sub-list contains two adjacent ComplexSelectors.
-    std::vector<std::vector<SelectorComponentObj>> groups1 = groupSelectors(queue1);
-    std::vector<std::vector<SelectorComponentObj>> groups2 = groupSelectors(queue2);
+    sass::vector<sass::vector<SelectorComponentObj>> groups1 = groupSelectors(queue1);
+    sass::vector<sass::vector<SelectorComponentObj>> groups2 = groupSelectors(queue2);
 
     // The main array to store our choices that will be permutated
-    std::vector<std::vector<std::vector<SelectorComponentObj>>> choices;
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>> choices;
 
     // append initial combinators
     choices.push_back({ leads });
 
-    std::vector<std::vector<SelectorComponentObj>> LCS =
-      lcs<std::vector<SelectorComponentObj>>(groups1, groups2, cmpGroups);
+    sass::vector<sass::vector<SelectorComponentObj>> LCS =
+      lcs<sass::vector<SelectorComponentObj>>(groups1, groups2, cmpGroups);
 
     for (auto group : LCS) {
 
       // Create junks from groups1 and groups2
-      std::vector<std::vector<std::vector<SelectorComponentObj>>>
-        chunks = getChunks<std::vector<SelectorComponentObj>>(
+      sass::vector<sass::vector<sass::vector<SelectorComponentObj>>>
+        chunks = getChunks<sass::vector<SelectorComponentObj>>(
           groups1, groups2, group, cmpChunkForParentSuperselector);
 
       // Create expanded array by flattening chunks2 inner
-      std::vector<std::vector<SelectorComponentObj>>
+      sass::vector<sass::vector<SelectorComponentObj>>
         expanded = flattenInner(chunks);
 
       // Prepare data structures
@@ -586,8 +586,8 @@ namespace Sass {
     }
 
     // Create junks from groups1 and groups2
-    std::vector<std::vector<std::vector<SelectorComponentObj>>>
-      chunks = getChunks<std::vector<SelectorComponentObj>>(
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>>
+      chunks = getChunks<sass::vector<SelectorComponentObj>>(
         groups1, groups2, {}, cmpChunkForEmptySequence);
 
     // Append chunks with inner arrays flattened
@@ -599,10 +599,10 @@ namespace Sass {
 
     // move all non empty items to the front, then erase the trailing ones
     choices.erase(std::remove_if(choices.begin(), choices.end(), checkForEmptyChild
-      <std::vector<std::vector<SelectorComponentObj>>>), choices.end());
+      <sass::vector<sass::vector<SelectorComponentObj>>>), choices.end());
 
     // permutate all possible paths through selectors
-    std::vector<std::vector<SelectorComponentObj>>
+    sass::vector<sass::vector<SelectorComponentObj>>
       results = flattenInner(permutate(choices));
 
     return results;

data/ext/libsass/src/ast_selectors.cpp

@@ -11,7 +11,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Selector::Selector(ParserState pstate)
+  Selector::Selector(SourceSpan pstate)
   : Expression(pstate),
     hash_(0)
   { concrete_type(SELECTOR); }
@@ -30,7 +30,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Selector_Schema::Selector_Schema(ParserState pstate, String_Obj c)
+  Selector_Schema::Selector_Schema(SourceSpan pstate, String_Obj c)
   : AST_Node(pstate),
     contents_(c),
     connect_parent_(true),
@@ -69,12 +69,12 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  SimpleSelector::SimpleSelector(ParserState pstate, std::string n)
+  SimpleSelector::SimpleSelector(SourceSpan pstate, sass::string n)
   : Selector(pstate), ns_(""), name_(n), has_ns_(false)
   {
     size_t pos = n.find('|');
     // found some namespace
-    if (pos != std::string::npos) {
+    if (pos != sass::string::npos) {
       has_ns_ = true;
       ns_ = n.substr(0, pos);
       name_ = n.substr(pos + 1);
@@ -87,7 +87,7 @@ namespace Sass {
     has_ns_(ptr->has_ns_)
   { }
 
-  std::string SimpleSelector::ns_name() const
+  sass::string SimpleSelector::ns_name() const
   {
     if (!has_ns_) return name_;
     else return ns_ + "|" + name_;
@@ -174,31 +174,31 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Placeholder_Selector::Placeholder_Selector(ParserState pstate, std::string n)
+  PlaceholderSelector::PlaceholderSelector(SourceSpan pstate, sass::string n)
   : SimpleSelector(pstate, n)
   { simple_type(PLACEHOLDER_SEL); }
-  Placeholder_Selector::Placeholder_Selector(const Placeholder_Selector* ptr)
+  PlaceholderSelector::PlaceholderSelector(const PlaceholderSelector* ptr)
   : SimpleSelector(ptr)
   { simple_type(PLACEHOLDER_SEL); }
-  unsigned long Placeholder_Selector::specificity() const
+  unsigned long PlaceholderSelector::specificity() const
   {
     return Constants::Specificity_Base;
   }
-  bool Placeholder_Selector::has_placeholder() {
+  bool PlaceholderSelector::has_placeholder() {
     return true;
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Type_Selector::Type_Selector(ParserState pstate, std::string n)
+  TypeSelector::TypeSelector(SourceSpan pstate, sass::string n)
   : SimpleSelector(pstate, n)
   { simple_type(TYPE_SEL); }
-  Type_Selector::Type_Selector(const Type_Selector* ptr)
+  TypeSelector::TypeSelector(const TypeSelector* ptr)
   : SimpleSelector(ptr)
   { simple_type(TYPE_SEL); }
 
-  unsigned long Type_Selector::specificity() const
+  unsigned long TypeSelector::specificity() const
   {
     if (name() == "*") return 0;
     else return Constants::Specificity_Element;
@@ -207,14 +207,14 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Class_Selector::Class_Selector(ParserState pstate, std::string n)
+  ClassSelector::ClassSelector(SourceSpan pstate, sass::string n)
   : SimpleSelector(pstate, n)
   { simple_type(CLASS_SEL); }
-  Class_Selector::Class_Selector(const Class_Selector* ptr)
+  ClassSelector::ClassSelector(const ClassSelector* ptr)
   : SimpleSelector(ptr)
   { simple_type(CLASS_SEL); }
 
-  unsigned long Class_Selector::specificity() const
+  unsigned long ClassSelector::specificity() const
   {
     return Constants::Specificity_Class;
   }
@@ -222,14 +222,14 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Id_Selector::Id_Selector(ParserState pstate, std::string n)
+  IDSelector::IDSelector(SourceSpan pstate, sass::string n)
   : SimpleSelector(pstate, n)
   { simple_type(ID_SEL); }
-  Id_Selector::Id_Selector(const Id_Selector* ptr)
+  IDSelector::IDSelector(const IDSelector* ptr)
   : SimpleSelector(ptr)
   { simple_type(ID_SEL); }
 
-  unsigned long Id_Selector::specificity() const
+  unsigned long IDSelector::specificity() const
   {
     return Constants::Specificity_ID;
   }
@@ -237,27 +237,27 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Attribute_Selector::Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v, char o)
+  AttributeSelector::AttributeSelector(SourceSpan pstate, sass::string n, sass::string m, String_Obj v, char o)
   : SimpleSelector(pstate, n), matcher_(m), value_(v), modifier_(o)
   { simple_type(ATTRIBUTE_SEL); }
-  Attribute_Selector::Attribute_Selector(const Attribute_Selector* ptr)
+  AttributeSelector::AttributeSelector(const AttributeSelector* ptr)
   : SimpleSelector(ptr),
     matcher_(ptr->matcher_),
     value_(ptr->value_),
     modifier_(ptr->modifier_)
   { simple_type(ATTRIBUTE_SEL); }
 
-  size_t Attribute_Selector::hash() const
+  size_t AttributeSelector::hash() const
   {
     if (hash_ == 0) {
       hash_combine(hash_, SimpleSelector::hash());
-      hash_combine(hash_, std::hash<std::string>()(matcher()));
+      hash_combine(hash_, std::hash<sass::string>()(matcher()));
       if (value_) hash_combine(hash_, value_->hash());
     }
     return hash_;
   }
 
-  unsigned long Attribute_Selector::specificity() const
+  unsigned long AttributeSelector::specificity() const
   {
     return Constants::Specificity_Attr;
   }
@@ -265,7 +265,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Pseudo_Selector::Pseudo_Selector(ParserState pstate, std::string name, bool element)
+  PseudoSelector::PseudoSelector(SourceSpan pstate, sass::string name, bool element)
   : SimpleSelector(pstate, name),
     normalized_(Util::unvendor(name)),
     argument_({}),
@@ -273,7 +273,7 @@ namespace Sass {
     isSyntacticClass_(!element),
     isClass_(!element && !isFakePseudoElement(normalized_))
   { simple_type(PSEUDO_SEL); }
-  Pseudo_Selector::Pseudo_Selector(const Pseudo_Selector* ptr)
+  PseudoSelector::PseudoSelector(const PseudoSelector* ptr)
   : SimpleSelector(ptr),
     normalized_(ptr->normalized()),
     argument_(ptr->argument()),
@@ -290,12 +290,12 @@ namespace Sass {
   // in CSS levels 1 and 2 (namely, :first-line, :first-letter, :before and
   // :after). This compatibility is not allowed for the new pseudo-elements
   // introduced in this specification.
-  bool Pseudo_Selector::is_pseudo_element() const
+  bool PseudoSelector::is_pseudo_element() const
   {
     return isElement();
   }
 
-  size_t Pseudo_Selector::hash() const
+  size_t PseudoSelector::hash() const
   {
     if (hash_ == 0) {
       hash_combine(hash_, SimpleSelector::hash());
@@ -305,34 +305,34 @@ namespace Sass {
     return hash_;
   }
 
-  unsigned long Pseudo_Selector::specificity() const
+  unsigned long PseudoSelector::specificity() const
   {
     if (is_pseudo_element())
       return Constants::Specificity_Element;
     return Constants::Specificity_Pseudo;
   }
 
-  Pseudo_Selector_Obj Pseudo_Selector::withSelector(SelectorListObj selector)
+  PseudoSelectorObj PseudoSelector::withSelector(SelectorListObj selector)
   {
-    Pseudo_Selector_Obj pseudo = SASS_MEMORY_COPY(this);
+    PseudoSelectorObj pseudo = SASS_MEMORY_COPY(this);
     pseudo->selector(selector);
     return pseudo;
   }
 
-  bool Pseudo_Selector::empty() const
+  bool PseudoSelector::empty() const
   {
     // Only considered empty if selector is
     // available but has no items in it.
     return selector() && selector()->empty();
   }
 
-  void Pseudo_Selector::cloneChildren()
+  void PseudoSelector::cloneChildren()
   {
     if (selector().isNull()) selector({});
     else selector(SASS_MEMORY_CLONE(selector()));
   }
 
-  bool Pseudo_Selector::has_real_parent_ref() const {
+  bool PseudoSelector::has_real_parent_ref() const {
     if (!selector()) return false;
     return selector()->has_real_parent_ref();
   }
@@ -340,7 +340,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  SelectorList::SelectorList(ParserState pstate, size_t s)
+  SelectorList::SelectorList(SourceSpan pstate, size_t s)
   : Selector(pstate),
     Vectorized<ComplexSelectorObj>(s),
     is_optional_(false)
@@ -391,7 +391,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  ComplexSelector::ComplexSelector(ParserState pstate)
+  ComplexSelector::ComplexSelector(SourceSpan pstate)
   : Selector(pstate),
     Vectorized<SelectorComponentObj>(),
     chroots_(false),
@@ -469,7 +469,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  SelectorComponent::SelectorComponent(ParserState pstate, bool postLineBreak)
+  SelectorComponent::SelectorComponent(SourceSpan pstate, bool postLineBreak)
   : Selector(pstate),
     hasPostLineBreak_(postLineBreak)
   {
@@ -500,7 +500,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  SelectorCombinator::SelectorCombinator(ParserState pstate, SelectorCombinator::Combinator combinator, bool postLineBreak)
+  SelectorCombinator::SelectorCombinator(SourceSpan pstate, SelectorCombinator::Combinator combinator, bool postLineBreak)
     : SelectorComponent(pstate, postLineBreak),
     combinator_(combinator)
   {
@@ -522,7 +522,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  CompoundSelector::CompoundSelector(ParserState pstate, bool postLineBreak)
+  CompoundSelector::CompoundSelector(SourceSpan pstate, bool postLineBreak)
     : SelectorComponent(pstate, postLineBreak),
       Vectorized<SimpleSelectorObj>(),
       hasRealParent_(false),
@@ -549,7 +549,7 @@ namespace Sass {
   {
     if (hasRealParent()) return true;
     // ToDo: dart sass has another check?
-    // if (Cast<Type_Selector>(front)) {
+    // if (Cast<TypeSelector>(front)) {
     //  if (front->ns() != "") return false;
     // }
     for (const SimpleSelector* s : elements()) {
@@ -590,7 +590,7 @@ namespace Sass {
     return true;
   }
 
-  bool CompoundSelector::isSuperselectorOf(const CompoundSelector* sub, std::string wrapped) const
+  bool CompoundSelector::isSuperselectorOf(const CompoundSelector* sub, sass::string wrapped) const
   {
     CompoundSelector* rhs2 = const_cast<CompoundSelector*>(sub);
     CompoundSelector* lhs2 = const_cast<CompoundSelector*>(this);
@@ -600,15 +600,15 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  MediaRule::MediaRule(ParserState pstate, Block_Obj block) :
-    Has_Block(pstate, block),
+  MediaRule::MediaRule(SourceSpan pstate, Block_Obj block) :
+    ParentStatement(pstate, block),
     schema_({})
   {
     statement_type(MEDIA);
   }
 
   MediaRule::MediaRule(const MediaRule* ptr) :
-    Has_Block(ptr),
+    ParentStatement(ptr),
     schema_(ptr->schema_)
   {
     statement_type(MEDIA);
@@ -617,21 +617,21 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  CssMediaRule::CssMediaRule(ParserState pstate, Block_Obj block) :
-    Has_Block(pstate, block),
+  CssMediaRule::CssMediaRule(SourceSpan pstate, Block_Obj block) :
+    ParentStatement(pstate, block),
     Vectorized()
   {
     statement_type(MEDIA);
   }
 
   CssMediaRule::CssMediaRule(const CssMediaRule* ptr) :
-    Has_Block(ptr),
+    ParentStatement(ptr),
     Vectorized(*ptr)
   {
     statement_type(MEDIA);
   }
 
-  CssMediaQuery::CssMediaQuery(ParserState pstate) :
+  CssMediaQuery::CssMediaQuery(SourceSpan pstate) :
     AST_Node(pstate),
     modifier_(""),
     type_(""),
@@ -653,26 +653,26 @@ namespace Sass {
   CssMediaQuery_Obj CssMediaQuery::merge(CssMediaQuery_Obj& other)
   {
 
-    std::string ourType = this->type();
+    sass::string ourType = this->type();
     Util::ascii_str_tolower(&ourType);
 
-    std::string theirType = other->type();
+    sass::string theirType = other->type();
     Util::ascii_str_tolower(&theirType);
 
-    std::string ourModifier = this->modifier();
+    sass::string ourModifier = this->modifier();
     Util::ascii_str_tolower(&ourModifier);
 
-    std::string theirModifier = other->modifier();
+    sass::string theirModifier = other->modifier();
     Util::ascii_str_tolower(&theirModifier);
 
-    std::string type;
-    std::string modifier;
-    std::vector<std::string> features;
+    sass::string type;
+    sass::string modifier;
+    sass::vector<sass::string> features;
 
     if (ourType.empty() && theirType.empty()) {
       CssMediaQuery_Obj query = SASS_MEMORY_NEW(CssMediaQuery, pstate());
-      std::vector<std::string> f1(this->features());
-      std::vector<std::string> f2(other->features());
+      sass::vector<sass::string> f1(this->features());
+      sass::vector<sass::string> f2(other->features());
       features.insert(features.end(), f1.begin(), f1.end());
       features.insert(features.end(), f2.begin(), f2.end());
       query->features(features);
@@ -681,9 +681,9 @@ namespace Sass {
 
     if ((ourModifier == "not") != (theirModifier == "not")) {
       if (ourType == theirType) {
-        std::vector<std::string> negativeFeatures =
+        sass::vector<sass::string> negativeFeatures =
           ourModifier == "not" ? this->features() : other->features();
-        std::vector<std::string> positiveFeatures =
+        sass::vector<sass::string> positiveFeatures =
           ourModifier == "not" ? other->features() : this->features();
 
         // If the negative features are a subset of the positive features, the
@@ -747,16 +747,16 @@ namespace Sass {
         // Omit the type if either input query did, since that indicates that they
         // aren't targeting a browser that requires "all and".
         type = (other->matchesAllTypes() && ourType.empty()) ? "" : theirType;
-        std::vector<std::string> f1(this->features());
-        std::vector<std::string> f2(other->features());
+        sass::vector<sass::string> f1(this->features());
+        sass::vector<sass::string> f2(other->features());
         features.insert(features.end(), f1.begin(), f1.end());
         features.insert(features.end(), f2.begin(), f2.end());
       }
       else if (other->matchesAllTypes()) {
         modifier = ourModifier;
         type = ourType;
-        std::vector<std::string> f1(this->features());
-        std::vector<std::string> f2(other->features());
+        sass::vector<sass::string> f1(this->features());
+        sass::vector<sass::string> f2(other->features());
         features.insert(features.end(), f1.begin(), f1.end());
         features.insert(features.end(), f2.begin(), f2.end());
       }
@@ -766,8 +766,8 @@ namespace Sass {
       else {
         modifier = ourModifier.empty() ? theirModifier : ourModifier;
         type = ourType;
-        std::vector<std::string> f1(this->features());
-        std::vector<std::string> f2(other->features());
+        sass::vector<sass::string> f1(this->features());
+        sass::vector<sass::string> f2(other->features());
         features.insert(features.end(), f1.begin(), f1.end());
         features.insert(features.end(), f2.begin(), f2.end());
       }
@@ -850,15 +850,15 @@ namespace Sass {
   // ToDo: this might be done easier with new selector format
   /////////////////////////////////////////////////////////////////////////
 
-  std::vector<ComplexSelectorObj>
+  sass::vector<ComplexSelectorObj>
     CompoundSelector::resolve_parent_refs(SelectorStack pstack, Backtraces& traces, bool implicit_parent)
   {
 
     auto parent = pstack.back();
-    std::vector<ComplexSelectorObj> rv;
+    sass::vector<ComplexSelectorObj> rv;
 
     for (SimpleSelectorObj simple : elements()) {
-      if (Pseudo_Selector * pseudo = Cast<Pseudo_Selector>(simple)) {
+      if (PseudoSelector * pseudo = Cast<PseudoSelector>(simple)) {
         if (SelectorList* sel = Cast<SelectorList>(pseudo->selector())) {
           if (parent) {
             pseudo->selector(sel->resolve_parent_refs(
@@ -887,7 +887,7 @@ namespace Sass {
               SimpleSelectorObj back = tail->last();
               SimpleSelectorObj front = first();
               auto simple_back = Cast<SimpleSelector>(back);
-              auto simple_front = Cast<Type_Selector>(front);
+              auto simple_front = Cast<TypeSelector>(front);
               if (simple_front && simple_back) {
                 simple_back = SASS_MEMORY_COPY(simple_back);
                 auto name = simple_back->name();
@@ -940,11 +940,21 @@ namespace Sass {
 
   }
 
-  /* better return std::vector? only - is empty container anyway? */
+  bool cmpSimpleSelectors(SimpleSelector* a, SimpleSelector* b)
+  {
+    return (a->getSortOrder() < b->getSortOrder());
+  }
+
+  void CompoundSelector::sortChildren()
+  {
+    std::sort(begin(), end(), cmpSimpleSelectors);
+  }
+
+  /* better return sass::vector? only - is empty container anyway? */
   SelectorList* ComplexSelector::resolve_parent_refs(SelectorStack pstack, Backtraces& traces, bool implicit_parent)
   {
 
-    std::vector<std::vector<ComplexSelectorObj>> vars;
+    sass::vector<sass::vector<ComplexSelectorObj>> vars;
 
     auto parent = pstack.back();
 
@@ -977,7 +987,7 @@ namespace Sass {
     }
 
     // Need complex selectors to preserve linefeeds
-    std::vector<std::vector<ComplexSelectorObj>> res = permutateAlt(vars);
+    sass::vector<sass::vector<ComplexSelectorObj>> res = permutateAlt(vars);
 
     // std::reverse(std::begin(res), std::end(res));
 
@@ -1019,12 +1029,12 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   IMPLEMENT_AST_OPERATORS(Selector_Schema);
-  IMPLEMENT_AST_OPERATORS(Placeholder_Selector);
-  IMPLEMENT_AST_OPERATORS(Attribute_Selector);
-  IMPLEMENT_AST_OPERATORS(Type_Selector);
-  IMPLEMENT_AST_OPERATORS(Class_Selector);
-  IMPLEMENT_AST_OPERATORS(Id_Selector);
-  IMPLEMENT_AST_OPERATORS(Pseudo_Selector);
+  IMPLEMENT_AST_OPERATORS(PlaceholderSelector);
+  IMPLEMENT_AST_OPERATORS(AttributeSelector);
+  IMPLEMENT_AST_OPERATORS(TypeSelector);
+  IMPLEMENT_AST_OPERATORS(ClassSelector);
+  IMPLEMENT_AST_OPERATORS(IDSelector);
+  IMPLEMENT_AST_OPERATORS(PseudoSelector);
   IMPLEMENT_AST_OPERATORS(SelectorCombinator);
   IMPLEMENT_AST_OPERATORS(CompoundSelector);
   IMPLEMENT_AST_OPERATORS(ComplexSelector);