Rename Supports_Operator to SupportsOperator

Author: mgreter

src/ast_fwd_decl.cpp

@@ -23,7 +23,7 @@ namespace Sass {
   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)

src/ast_fwd_decl.hpp

@@ -85,7 +85,7 @@ namespace Sass {
 
   class Media_Query;
   class Media_Query_Expression;
-  class Supports_Condition;
+  class SupportsCondition;
   class Supports_Operator;
   class Supports_Negation;
   class Supports_Declaration;
@@ -182,7 +182,7 @@ 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(SupportsCondition);
   IMPL_MEM_OBJ(Supports_Operator);
   IMPL_MEM_OBJ(Supports_Negation);
   IMPL_MEM_OBJ(Supports_Declaration);
@@ -255,7 +255,7 @@ namespace Sass {
   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)

src/ast_supports.cpp

@@ -9,7 +9,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  SupportsRule::SupportsRule(SourceSpan pstate, Supports_Condition_Obj condition, Block_Obj block)
+  SupportsRule::SupportsRule(SourceSpan pstate, SupportsConditionObj condition, Block_Obj block)
   : ParentStatement(pstate, block), condition_(condition)
   { statement_type(SUPPORTS); }
   SupportsRule::SupportsRule(const SupportsRule* ptr)
@@ -20,28 +20,28 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Condition::Supports_Condition(SourceSpan 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(SourceSpan pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o)
-  : Supports_Condition(pstate), left_(l), right_(r), operand_(o)
+  Supports_Operator::Supports_Operator(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),
+  : SupportsCondition(ptr),
     left_(ptr->left_),
     right_(ptr->right_),
     operand_(ptr->operand_)
   { }
 
-  bool Supports_Operator::needs_parens(Supports_Condition_Obj cond) const
+  bool Supports_Operator::needs_parens(SupportsConditionObj cond) const
   {
     if (Supports_Operator_Obj op = Cast<Supports_Operator>(cond)) {
       return op->operand() != operand();
@@ -52,14 +52,14 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Negation::Supports_Negation(SourceSpan pstate, Supports_Condition_Obj c)
-  : Supports_Condition(pstate), condition_(c)
+  Supports_Negation::Supports_Negation(SourceSpan pstate, SupportsConditionObj c)
+  : SupportsCondition(pstate), condition_(c)
   { }
   Supports_Negation::Supports_Negation(const Supports_Negation* ptr)
-  : Supports_Condition(ptr), condition_(ptr->condition_)
+  : SupportsCondition(ptr), condition_(ptr->condition_)
   { }
 
-  bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const
+  bool Supports_Negation::needs_parens(SupportsConditionObj cond) const
   {
     return Cast<Supports_Negation>(cond) ||
            Cast<Supports_Operator>(cond);
@@ -69,15 +69,15 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Supports_Declaration::Supports_Declaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v)
-  : Supports_Condition(pstate), feature_(f), value_(v)
+  : SupportsCondition(pstate), feature_(f), value_(v)
   { }
   Supports_Declaration::Supports_Declaration(const Supports_Declaration* ptr)
-  : Supports_Condition(ptr),
+  : SupportsCondition(ptr),
     feature_(ptr->feature_),
     value_(ptr->value_)
   { }
 
-  bool Supports_Declaration::needs_parens(Supports_Condition_Obj cond) const
+  bool Supports_Declaration::needs_parens(SupportsConditionObj cond) const
   {
     return false;
   }
@@ -86,14 +86,14 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Supports_Interpolation::Supports_Interpolation(SourceSpan pstate, ExpressionObj v)
-  : Supports_Condition(pstate), value_(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;
   }
@@ -102,7 +102,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   IMPLEMENT_AST_OPERATORS(SupportsRule);
-  IMPLEMENT_AST_OPERATORS(Supports_Condition);
+  IMPLEMENT_AST_OPERATORS(SupportsCondition);
   IMPLEMENT_AST_OPERATORS(Supports_Operator);
   IMPLEMENT_AST_OPERATORS(Supports_Negation);
   IMPLEMENT_AST_OPERATORS(Supports_Declaration);

src/ast_supports.hpp

@@ -40,9 +40,9 @@ namespace Sass {
   // `@supports` rule.
   ////////////////////
   class SupportsRule : public ParentStatement {
-    ADD_PROPERTY(Supports_Condition_Obj, condition)
+    ADD_PROPERTY(SupportsConditionObj, condition)
   public:
-    SupportsRule(SourceSpan pstate, Supports_Condition_Obj condition, Block_Obj block = {});
+    SupportsRule(SourceSpan pstate, SupportsConditionObj condition, Block_Obj block = {});
     bool bubbles() override;
     ATTACH_AST_OPERATIONS(SupportsRule)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -51,67 +51,67 @@ namespace Sass {
   //////////////////////////////////////////////////////
   // The abstract superclass of all Supports conditions.
   //////////////////////////////////////////////////////
-  class Supports_Condition : public Expression {
+  class SupportsCondition : public Expression {
   public:
-    Supports_Condition(SourceSpan 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 Supports_Operator : 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(SourceSpan pstate, Supports_Condition_Obj l, Supports_Condition_Obj r, Operand o);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
+    Supports_Operator(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj r, Operand o);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
     ATTACH_AST_OPERATIONS(Supports_Operator)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   //////////////////////////////////////////
   // A negation condition (`not CONDITION`).
   //////////////////////////////////////////
-  class Supports_Negation : public Supports_Condition {
+  class Supports_Negation : public SupportsCondition {
   private:
-    ADD_PROPERTY(Supports_Condition_Obj, condition);
+    ADD_PROPERTY(SupportsConditionObj, condition);
   public:
-    Supports_Negation(SourceSpan pstate, Supports_Condition_Obj c);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
+    Supports_Negation(SourceSpan pstate, SupportsConditionObj c);
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
     ATTACH_AST_OPERATIONS(Supports_Negation)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   /////////////////////////////////////////////////////
   // A declaration condition (e.g. `(feature: value)`).
   /////////////////////////////////////////////////////
-  class Supports_Declaration : public Supports_Condition {
+  class Supports_Declaration : public SupportsCondition {
   private:
     ADD_PROPERTY(ExpressionObj, feature);
     ADD_PROPERTY(ExpressionObj, value);
   public:
     Supports_Declaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
     ATTACH_AST_OPERATIONS(Supports_Declaration)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////////////////////
   // An interpolation condition (e.g. `#{$var}`).
   ///////////////////////////////////////////////
-  class Supports_Interpolation : public Supports_Condition {
+  class Supports_Interpolation : public SupportsCondition {
   private:
     ADD_PROPERTY(ExpressionObj, value);
   public:
     Supports_Interpolation(SourceSpan pstate, ExpressionObj v);
-    virtual bool needs_parens(Supports_Condition_Obj cond) const override;
+    virtual bool needs_parens(SupportsConditionObj cond) const override;
     ATTACH_AST_OPERATIONS(Supports_Interpolation)
     ATTACH_CRTP_PERFORM_METHODS()
   };

src/eval.cpp

@@ -1319,8 +1319,8 @@ namespace Sass {
     Expression* right = c->right()->perform(this);
     Supports_Operator* cc = SASS_MEMORY_NEW(Supports_Operator,
                                  c->pstate(),
-                                 Cast<Supports_Condition>(left),
-                                 Cast<Supports_Condition>(right),
+                                 Cast<SupportsCondition>(left),
+                                 Cast<SupportsCondition>(right),
                                  c->operand());
     return cc;
   }
@@ -1330,7 +1330,7 @@ namespace Sass {
     Expression* condition = c->condition()->perform(this);
     Supports_Negation* cc = SASS_MEMORY_NEW(Supports_Negation,
                                  c->pstate(),
-                                 Cast<Supports_Condition>(condition));
+                                 Cast<SupportsCondition>(condition));
     return cc;
   }
 

src/expand.cpp

@@ -233,7 +233,7 @@ namespace Sass {
     ExpressionObj condition = f->condition()->perform(&eval);
     SupportsRuleObj ff = SASS_MEMORY_NEW(SupportsRule,
                                        f->pstate(),
-                                       Cast<Supports_Condition>(condition),
+                                       Cast<SupportsCondition>(condition),
                                        operator()(f->block()));
     return ff.detach();
   }

src/operation.hpp

@@ -25,7 +25,7 @@ namespace Sass {
     virtual Statement* perform(Operation<Statement*>* op) = 0; \
     virtual Expression* perform(Operation<Expression*>* op) = 0; \
     virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) = 0; \
-    virtual Supports_Condition* perform(Operation<Supports_Condition*>* op) = 0; \
+    virtual SupportsCondition* perform(Operation<SupportsCondition*>* op) = 0; \
 
   // you must add operators to every class
   // ensures `this` of actual instance type
@@ -40,7 +40,7 @@ namespace Sass {
     virtual Statement* perform(Operation<Statement*>* op) override { return (*op)(this); } \
     virtual Expression* perform(Operation<Expression*>* op) override { return (*op)(this); } \
     virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) override { return (*op)(this); } \
-    virtual Supports_Condition* perform(Operation<Supports_Condition*>* op) override { return (*op)(this); } \
+    virtual SupportsCondition* perform(Operation<SupportsCondition*>* op) override { return (*op)(this); } \
 
   template<typename T>
   class Operation {
@@ -94,7 +94,7 @@ namespace Sass {
     virtual T operator()(String_Schema* x)          = 0;
     virtual T operator()(String_Quoted* x)          = 0;
     virtual T operator()(String_Constant* x)        = 0;
-    virtual T operator()(Supports_Condition* x)     = 0;
+    virtual T operator()(SupportsCondition* x)     = 0;
     virtual T operator()(Supports_Operator* x)      = 0;
     virtual T operator()(Supports_Negation* x)      = 0;
     virtual T operator()(Supports_Declaration* x)   = 0;
@@ -180,7 +180,7 @@ namespace Sass {
     T operator()(String_Schema* x)          { return static_cast<D*>(this)->fallback(x); }
     T operator()(String_Constant* x)        { return static_cast<D*>(this)->fallback(x); }
     T operator()(String_Quoted* x)          { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Condition* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsCondition* x)     { return static_cast<D*>(this)->fallback(x); }
     T operator()(Supports_Operator* x)      { return static_cast<D*>(this)->fallback(x); }
     T operator()(Supports_Negation* x)      { return static_cast<D*>(this)->fallback(x); }
     T operator()(Supports_Declaration* x)   { return static_cast<D*>(this)->fallback(x); }

src/output.cpp

@@ -203,7 +203,7 @@ namespace Sass {
   {
     if (f->is_invisible()) return;
 
-    Supports_Condition_Obj c = f->condition();
+    SupportsConditionObj c = f->condition();
     Block_Obj b              = f->block();
 
     // Filter out feature blocks that aren't printable (process its children though)