sassc 2.3.0 → 2.4.0

data/ext/libsass/src/ast_selectors.hpp

@@ -15,25 +15,25 @@ namespace Sass {
   bool compoundIsSuperselector(
     const CompoundSelectorObj& compound1,
     const CompoundSelectorObj& compound2,
-    const std::vector<SelectorComponentObj>& parents);
+    const sass::vector<SelectorComponentObj>& parents);
 
   bool complexIsParentSuperselector(
-    const std::vector<SelectorComponentObj>& complex1,
-    const std::vector<SelectorComponentObj>& complex2);
+    const sass::vector<SelectorComponentObj>& complex1,
+    const sass::vector<SelectorComponentObj>& complex2);
 
-    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>> weaveParents(
-    std::vector<SelectorComponentObj> parents1,
-    std::vector<SelectorComponentObj> parents2);
+  sass::vector<sass::vector<SelectorComponentObj>> weaveParents(
+    sass::vector<SelectorComponentObj> parents1,
+    sass::vector<SelectorComponentObj> parents2);
 
-  std::vector<SimpleSelectorObj> unifyCompound(
-    const std::vector<SimpleSelectorObj>& compound1,
-    const std::vector<SimpleSelectorObj>& compound2);
+  sass::vector<SimpleSelectorObj> unifyCompound(
+    const sass::vector<SimpleSelectorObj>& compound1,
+    const sass::vector<SimpleSelectorObj>& compound2);
 
-  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);
 
   /////////////////////////////////////////
   // Abstract base class for CSS selectors.
@@ -42,7 +42,7 @@ namespace Sass {
   protected:
     mutable size_t hash_;
   public:
-    Selector(ParserState pstate);
+    Selector(SourceSpan pstate);
     virtual ~Selector() = 0;
     size_t hash() const override = 0;
     virtual bool has_real_parent_ref() const;
@@ -68,7 +68,7 @@ namespace Sass {
     // store computed hash
     mutable size_t hash_;
   public:
-    Selector_Schema(ParserState pstate, String_Obj c);
+    Selector_Schema(SourceSpan pstate, String_Obj c);
 
     bool has_real_parent_ref() const;
     // selector schema is not yet a final selector, so we do not
@@ -93,13 +93,15 @@ namespace Sass {
       PLACEHOLDER_SEL,
     };
   public:
-    HASH_CONSTREF(std::string, ns)
-    HASH_CONSTREF(std::string, name)
+    HASH_CONSTREF(sass::string, ns)
+    HASH_CONSTREF(sass::string, name)
     ADD_PROPERTY(Simple_Type, simple_type)
     HASH_PROPERTY(bool, has_ns)
   public:
-    SimpleSelector(ParserState pstate, std::string n = "");
-    virtual std::string ns_name() const;
+    SimpleSelector(SourceSpan pstate, sass::string n = "");
+    // ordering within parent (peudos go last)
+    virtual int getSortOrder() const = 0;
+    virtual sass::string ns_name() const;
     size_t hash() const override;
     virtual bool empty() const;
     // namespace compare functions
@@ -117,9 +119,9 @@ namespace Sass {
     virtual CompoundSelector* unifyWith(CompoundSelector*);
 
     /* helper function for syntax sugar */
-    virtual Id_Selector* getIdSelector() { return NULL; }
-    virtual Type_Selector* getTypeSelector() { return NULL; }
-    virtual Pseudo_Selector* getPseudoSelector() { return NULL; }
+    virtual IDSelector* getIdSelector() { return NULL; }
+    virtual TypeSelector* getTypeSelector() { return NULL; }
+    virtual PseudoSelector* getPseudoSelector() { return NULL; }
 
     ComplexSelectorObj wrapInComplex();
     CompoundSelectorObj wrapInCompound();
@@ -144,77 +146,82 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   // Placeholder selectors (e.g., "%foo") for use in extend-only selectors.
   /////////////////////////////////////////////////////////////////////////
-  class Placeholder_Selector final : public SimpleSelector {
+  class PlaceholderSelector final : public SimpleSelector {
   public:
-    Placeholder_Selector(ParserState pstate, std::string n);
+    PlaceholderSelector(SourceSpan pstate, sass::string n);
+    int getSortOrder() const override final { return 0; }
     bool isInvisible() const override { return true; }
     virtual unsigned long specificity() const override;
     virtual bool has_placeholder() override;
     bool operator==(const SimpleSelector& rhs) const override;
-    ATTACH_CMP_OPERATIONS(Placeholder_Selector)
-    ATTACH_AST_OPERATIONS(Placeholder_Selector)
+    ATTACH_CMP_OPERATIONS(PlaceholderSelector)
+    ATTACH_AST_OPERATIONS(PlaceholderSelector)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   /////////////////////////////////////////////////////////////////////
   // Type selectors (and the universal selector) -- e.g., div, span, *.
   /////////////////////////////////////////////////////////////////////
-  class Type_Selector final : public SimpleSelector {
+  class TypeSelector final : public SimpleSelector {
   public:
-    Type_Selector(ParserState pstate, std::string n);
+    TypeSelector(SourceSpan pstate, sass::string n);
+    int getSortOrder() const override final { return 1; }
     virtual unsigned long specificity() const override;
     SimpleSelector* unifyWith(const SimpleSelector*);
     CompoundSelector* unifyWith(CompoundSelector*) override;
-    Type_Selector* getTypeSelector() override { return this; }
+    TypeSelector* getTypeSelector() override { return this; }
     bool operator==(const SimpleSelector& rhs) const final override;
-    ATTACH_CMP_OPERATIONS(Type_Selector)
-    ATTACH_AST_OPERATIONS(Type_Selector)
+    ATTACH_CMP_OPERATIONS(TypeSelector)
+    ATTACH_AST_OPERATIONS(TypeSelector)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ////////////////////////////////////////////////
   // Class selectors  -- i.e., .foo.
   ////////////////////////////////////////////////
-  class Class_Selector final : public SimpleSelector {
+  class ClassSelector final : public SimpleSelector {
   public:
-    Class_Selector(ParserState pstate, std::string n);
+    ClassSelector(SourceSpan pstate, sass::string n);
+    int getSortOrder() const override final { return 3; }
     virtual unsigned long specificity() const override;
     bool operator==(const SimpleSelector& rhs) const final override;
-    ATTACH_CMP_OPERATIONS(Class_Selector)
-    ATTACH_AST_OPERATIONS(Class_Selector)
+    ATTACH_CMP_OPERATIONS(ClassSelector)
+    ATTACH_AST_OPERATIONS(ClassSelector)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ////////////////////////////////////////////////
   // ID selectors -- i.e., #foo.
   ////////////////////////////////////////////////
-  class Id_Selector final : public SimpleSelector {
+  class IDSelector final : public SimpleSelector {
   public:
-    Id_Selector(ParserState pstate, std::string n);
+    IDSelector(SourceSpan pstate, sass::string n);
+    int getSortOrder() const override final { return 2; }
     virtual unsigned long specificity() const override;
     CompoundSelector* unifyWith(CompoundSelector*) override;
-    Id_Selector* getIdSelector() final override { return this; }
+    IDSelector* getIdSelector() final override { return this; }
     bool operator==(const SimpleSelector& rhs) const final override;
-    ATTACH_CMP_OPERATIONS(Id_Selector)
-    ATTACH_AST_OPERATIONS(Id_Selector)
+    ATTACH_CMP_OPERATIONS(IDSelector)
+    ATTACH_AST_OPERATIONS(IDSelector)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////////////////////////
   // Attribute selectors -- e.g., [src*=".jpg"], etc.
   ///////////////////////////////////////////////////
-  class Attribute_Selector final : public SimpleSelector {
-    ADD_CONSTREF(std::string, matcher)
+  class AttributeSelector final : public SimpleSelector {
+    ADD_CONSTREF(sass::string, matcher)
     // this cannot be changed to obj atm!!!!!!????!!!!!!!
     ADD_PROPERTY(String_Obj, value) // might be interpolated
     ADD_PROPERTY(char, modifier);
   public:
-    Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v, char o = 0);
+    AttributeSelector(SourceSpan pstate, sass::string n, sass::string m, String_Obj v, char o = 0);
+    int getSortOrder() const override final { return 4; }
     size_t hash() const override;
     virtual unsigned long specificity() const override;
     bool operator==(const SimpleSelector& rhs) const final override;
-    ATTACH_CMP_OPERATIONS(Attribute_Selector)
-    ATTACH_AST_OPERATIONS(Attribute_Selector)
+    ATTACH_CMP_OPERATIONS(AttributeSelector)
+    ATTACH_AST_OPERATIONS(AttributeSelector)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
@@ -222,14 +229,15 @@ namespace Sass {
   // Pseudo selectors -- e.g., :first-child, :nth-of-type(...), etc.
   //////////////////////////////////////////////////////////////////
   // Pseudo Selector cannot have any namespace?
-  class Pseudo_Selector final : public SimpleSelector {
-    ADD_PROPERTY(std::string, normalized)
+  class PseudoSelector final : public SimpleSelector {
+    ADD_PROPERTY(sass::string, normalized)
     ADD_PROPERTY(String_Obj, argument)
     ADD_PROPERTY(SelectorListObj, selector)
     ADD_PROPERTY(bool, isSyntacticClass)
     ADD_PROPERTY(bool, isClass)
   public:
-    Pseudo_Selector(ParserState pstate, std::string n, bool element = false);
+    PseudoSelector(SourceSpan pstate, sass::string n, bool element = false);
+    int getSortOrder() const override final { return 5; }
     virtual bool is_pseudo_element() const override;
     size_t hash() const override;
 
@@ -246,13 +254,13 @@ namespace Sass {
     bool isSyntacticElement() const { return !isSyntacticClass(); }
 
     virtual unsigned long specificity() const override;
-    Pseudo_Selector_Obj withSelector(SelectorListObj selector);
+    PseudoSelectorObj withSelector(SelectorListObj selector);
 
     CompoundSelector* unifyWith(CompoundSelector*) override;
-    Pseudo_Selector* getPseudoSelector() final override { return this; }
+    PseudoSelector* getPseudoSelector() final override { return this; }
     bool operator==(const SimpleSelector& rhs) const final override;
-    ATTACH_CMP_OPERATIONS(Pseudo_Selector)
-    ATTACH_AST_OPERATIONS(Pseudo_Selector)
+    ATTACH_CMP_OPERATIONS(PseudoSelector)
+    ATTACH_AST_OPERATIONS(PseudoSelector)
     void cloneChildren() override;
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -269,7 +277,7 @@ namespace Sass {
     // line break before list separator
     ADD_PROPERTY(bool, hasPreLineFeed)
   public:
-    ComplexSelector(ParserState pstate);
+    ComplexSelector(SourceSpan pstate);
 
     // Returns true if the first components
     // is a compound selector and fullfills
@@ -310,7 +318,7 @@ namespace Sass {
     // line break after list separator
     ADD_PROPERTY(bool, hasPostLineBreak)
   public:
-    SelectorComponent(ParserState pstate, bool postLineBreak = false);
+    SelectorComponent(SourceSpan pstate, bool postLineBreak = false);
     size_t hash() const override = 0;
     void cloneChildren() override;
 
@@ -357,7 +365,7 @@ namespace Sass {
     HASH_CONSTREF(Combinator, combinator)
 
   public:
-    SelectorCombinator(ParserState pstate, Combinator combinator, bool postLineBreak = false);
+    SelectorCombinator(SourceSpan pstate, Combinator combinator, bool postLineBreak = false);
 
     bool has_real_parent_ref() const override { return false; }
     bool has_placeholder() const override { return false; }
@@ -407,7 +415,7 @@ namespace Sass {
     ADD_PROPERTY(bool, hasRealParent)
     ADD_PROPERTY(bool, extended)
   public:
-    CompoundSelector(ParserState pstate, bool postLineBreak = false);
+    CompoundSelector(SourceSpan pstate, bool postLineBreak = false);
 
     // Returns true if this compound selector
     // fullfills various criteria.
@@ -424,12 +432,12 @@ namespace Sass {
     CompoundSelector* getCompound() final override { return this; }
     const CompoundSelector* getCompound() const final override { return this; }
 
-    bool isSuperselectorOf(const CompoundSelector* sub, std::string wrapped = "") const;
+    bool isSuperselectorOf(const CompoundSelector* sub, sass::string wrapped = "") const;
 
     void cloneChildren() override;
     bool has_real_parent_ref() const override;
     bool has_placeholder() const override;
-    std::vector<ComplexSelectorObj> resolve_parent_refs(SelectorStack pstack, Backtraces& traces, bool implicit_parent = true);
+    sass::vector<ComplexSelectorObj> resolve_parent_refs(SelectorStack pstack, Backtraces& traces, bool implicit_parent = true);
 
     virtual bool isCompound() const override { return true; };
     virtual unsigned long specificity() const override;
@@ -445,6 +453,8 @@ namespace Sass {
     bool operator==(const ComplexSelector& rhs) const;
     bool operator==(const SimpleSelector& rhs) const;
 
+    void sortChildren();
+
     ATTACH_CMP_OPERATIONS(CompoundSelector)
     ATTACH_AST_OPERATIONS(CompoundSelector)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -459,8 +469,8 @@ namespace Sass {
     // ToDo: should be at ExtendRule?
     ADD_PROPERTY(bool, is_optional)
   public:
-    SelectorList(ParserState pstate, size_t s = 0);
-    std::string type() const override { return "list"; }
+    SelectorList(SourceSpan pstate, size_t s = 0);
+    sass::string type() const override { return "list"; }
     size_t hash() const override;
 
     SelectorList* unifyWith(SelectorList*);
@@ -501,8 +511,8 @@ namespace Sass {
     ADD_PROPERTY(SelectorListObj, selector)
     ADD_PROPERTY(Selector_Schema_Obj, schema)
   public:
-    ExtendRule(ParserState pstate, SelectorListObj s);
-    ExtendRule(ParserState pstate, Selector_Schema_Obj s);
+    ExtendRule(SourceSpan pstate, SelectorListObj s);
+    ExtendRule(SourceSpan pstate, Selector_Schema_Obj s);
     ATTACH_AST_OPERATIONS(ExtendRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };

data/ext/libsass/src/ast_supports.cpp

@@ -9,75 +9,75 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Block::Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block)
-  : Has_Block(pstate, block), condition_(condition)
+  SupportsRule::SupportsRule(SourceSpan pstate, SupportsConditionObj condition, Block_Obj block)
+  : ParentStatement(pstate, block), condition_(condition)
   { statement_type(SUPPORTS); }
-  Supports_Block::Supports_Block(const Supports_Block* ptr)
-  : Has_Block(ptr), condition_(ptr->condition_)
+  SupportsRule::SupportsRule(const SupportsRule* ptr)
+  : ParentStatement(ptr), condition_(ptr->condition_)
   { statement_type(SUPPORTS); }
-  bool Supports_Block::bubbles() { return true; }
+  bool SupportsRule::bubbles() { return true; }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Condition::Supports_Condition(ParserState pstate)
+  SupportsCondition::SupportsCondition(SourceSpan pstate)
   : Expression(pstate)
   { }
 
-  Supports_Condition::Supports_Condition(const Supports_Condition* ptr)
+  SupportsCondition::SupportsCondition(const SupportsCondition* ptr)
   : Expression(ptr)
   { }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Operator::Supports_Operator(ParserState pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o)
-  : Supports_Condition(pstate), left_(l), right_(r), operand_(o)
+  SupportsOperation::SupportsOperation(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj r, Operand o)
+  : SupportsCondition(pstate), left_(l), right_(r), operand_(o)
   { }
-  Supports_Operator::Supports_Operator(const Supports_Operator* ptr)
-  : Supports_Condition(ptr),
+  SupportsOperation::SupportsOperation(const SupportsOperation* ptr)
+  : SupportsCondition(ptr),
     left_(ptr->left_),
     right_(ptr->right_),
     operand_(ptr->operand_)
   { }
 
-  bool Supports_Operator::needs_parens(Supports_Condition_Obj cond) const
+  bool SupportsOperation::needs_parens(SupportsConditionObj cond) const
   {
-    if (Supports_Operator_Obj op = Cast<Supports_Operator>(cond)) {
+    if (SupportsOperationObj op = Cast<SupportsOperation>(cond)) {
       return op->operand() != operand();
     }
-    return Cast<Supports_Negation>(cond) != NULL;
+    return Cast<SupportsNegation>(cond) != NULL;
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Negation::Supports_Negation(ParserState pstate, Supports_Condition_Obj c)
-  : Supports_Condition(pstate), condition_(c)
+  SupportsNegation::SupportsNegation(SourceSpan pstate, SupportsConditionObj c)
+  : SupportsCondition(pstate), condition_(c)
   { }
-  Supports_Negation::Supports_Negation(const Supports_Negation* ptr)
-  : Supports_Condition(ptr), condition_(ptr->condition_)
+  SupportsNegation::SupportsNegation(const SupportsNegation* ptr)
+  : SupportsCondition(ptr), condition_(ptr->condition_)
   { }
 
-  bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const
+  bool SupportsNegation::needs_parens(SupportsConditionObj cond) const
   {
-    return Cast<Supports_Negation>(cond) ||
-           Cast<Supports_Operator>(cond);
+    return Cast<SupportsNegation>(cond) ||
+           Cast<SupportsOperation>(cond);
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Declaration::Supports_Declaration(ParserState pstate, Expression_Obj f, Expression_Obj v)
-  : Supports_Condition(pstate), feature_(f), value_(v)
+  SupportsDeclaration::SupportsDeclaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v)
+  : SupportsCondition(pstate), feature_(f), value_(v)
   { }
-  Supports_Declaration::Supports_Declaration(const Supports_Declaration* ptr)
-  : Supports_Condition(ptr),
+  SupportsDeclaration::SupportsDeclaration(const SupportsDeclaration* ptr)
+  : SupportsCondition(ptr),
     feature_(ptr->feature_),
     value_(ptr->value_)
   { }
 
-  bool Supports_Declaration::needs_parens(Supports_Condition_Obj cond) const
+  bool SupportsDeclaration::needs_parens(SupportsConditionObj cond) const
   {
     return false;
   }
@@ -85,15 +85,15 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Interpolation::Supports_Interpolation(ParserState pstate, Expression_Obj v)
-  : Supports_Condition(pstate), value_(v)
+  Supports_Interpolation::Supports_Interpolation(SourceSpan pstate, ExpressionObj v)
+  : SupportsCondition(pstate), value_(v)
   { }
   Supports_Interpolation::Supports_Interpolation(const Supports_Interpolation* ptr)
-  : Supports_Condition(ptr),
+  : SupportsCondition(ptr),
     value_(ptr->value_)
   { }
 
-  bool Supports_Interpolation::needs_parens(Supports_Condition_Obj cond) const
+  bool Supports_Interpolation::needs_parens(SupportsConditionObj cond) const
   {
     return false;
   }
@@ -101,11 +101,11 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  IMPLEMENT_AST_OPERATORS(Supports_Block);
-  IMPLEMENT_AST_OPERATORS(Supports_Condition);
-  IMPLEMENT_AST_OPERATORS(Supports_Operator);
-  IMPLEMENT_AST_OPERATORS(Supports_Negation);
-  IMPLEMENT_AST_OPERATORS(Supports_Declaration);
+  IMPLEMENT_AST_OPERATORS(SupportsRule);
+  IMPLEMENT_AST_OPERATORS(SupportsCondition);
+  IMPLEMENT_AST_OPERATORS(SupportsOperation);
+  IMPLEMENT_AST_OPERATORS(SupportsNegation);
+  IMPLEMENT_AST_OPERATORS(SupportsDeclaration);
   IMPLEMENT_AST_OPERATORS(Supports_Interpolation);
 
   /////////////////////////////////////////////////////////////////////////

data/ext/libsass/src/ast_supports.hpp

@@ -39,79 +39,79 @@ namespace Sass {
   ////////////////////
   // `@supports` rule.
   ////////////////////
-  class Supports_Block : public Has_Block {
-    ADD_PROPERTY(Supports_Condition_Obj, condition)
+  class SupportsRule : public ParentStatement {
+    ADD_PROPERTY(SupportsConditionObj, condition)
   public:
-    Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block = {});
+    SupportsRule(SourceSpan pstate, SupportsConditionObj condition, Block_Obj block = {});
     bool bubbles() override;
-    ATTACH_AST_OPERATIONS(Supports_Block)
+    ATTACH_AST_OPERATIONS(SupportsRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   //////////////////////////////////////////////////////
   // The abstract superclass of all Supports conditions.
   //////////////////////////////////////////////////////
-  class Supports_Condition : public Expression {
+  class SupportsCondition : public Expression {
   public:
-    Supports_Condition(ParserState pstate);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const { return false; }
-    ATTACH_AST_OPERATIONS(Supports_Condition)
+    SupportsCondition(SourceSpan pstate);
+    virtual bool needs_parens(SupportsConditionObj cond) const { return false; }
+    ATTACH_AST_OPERATIONS(SupportsCondition)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ////////////////////////////////////////////////////////////
   // An operator condition (e.g. `CONDITION1 and CONDITION2`).
   ////////////////////////////////////////////////////////////
-  class Supports_Operator : public Supports_Condition {
+  class SupportsOperation : public SupportsCondition {
   public:
     enum Operand { AND, OR };
   private:
-    ADD_PROPERTY(Supports_Condition_Obj, left);
-    ADD_PROPERTY(Supports_Condition_Obj, right);
+    ADD_PROPERTY(SupportsConditionObj, left);
+    ADD_PROPERTY(SupportsConditionObj, right);
     ADD_PROPERTY(Operand, operand);
   public:
-    Supports_Operator(ParserState pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Operator)
+    SupportsOperation(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj r, Operand o);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
+    ATTACH_AST_OPERATIONS(SupportsOperation)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   //////////////////////////////////////////
   // A negation condition (`not CONDITION`).
   //////////////////////////////////////////
-  class Supports_Negation : public Supports_Condition {
+  class SupportsNegation : public SupportsCondition {
   private:
-    ADD_PROPERTY(Supports_Condition_Obj, condition);
+    ADD_PROPERTY(SupportsConditionObj, condition);
   public:
-    Supports_Negation(ParserState pstate, Supports_Condition_Obj c);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Negation)
+    SupportsNegation(SourceSpan pstate, SupportsConditionObj c);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
+    ATTACH_AST_OPERATIONS(SupportsNegation)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   /////////////////////////////////////////////////////
   // A declaration condition (e.g. `(feature: value)`).
   /////////////////////////////////////////////////////
-  class Supports_Declaration : public Supports_Condition {
+  class SupportsDeclaration : public SupportsCondition {
   private:
-    ADD_PROPERTY(Expression_Obj, feature);
-    ADD_PROPERTY(Expression_Obj, value);
+    ADD_PROPERTY(ExpressionObj, feature);
+    ADD_PROPERTY(ExpressionObj, value);
   public:
-    Supports_Declaration(ParserState pstate, Expression_Obj f, Expression_Obj v);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Declaration)
+    SupportsDeclaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
+    ATTACH_AST_OPERATIONS(SupportsDeclaration)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////////////////////
   // An interpolation condition (e.g. `#{$var}`).
   ///////////////////////////////////////////////
-  class Supports_Interpolation : public Supports_Condition {
+  class Supports_Interpolation : public SupportsCondition {
   private:
-    ADD_PROPERTY(Expression_Obj, value);
+    ADD_PROPERTY(ExpressionObj, value);
   public:
-    Supports_Interpolation(ParserState pstate, Expression_Obj v);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
+    Supports_Interpolation(SourceSpan pstate, ExpressionObj v);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
     ATTACH_AST_OPERATIONS(Supports_Interpolation)
     ATTACH_CRTP_PERFORM_METHODS()
   };