Rename Supports_Operator to SupportsOperation

Author: mgreter

src/ast_fwd_decl.hpp

@@ -86,7 +86,7 @@ namespace Sass {
   class Media_Query;
   class Media_Query_Expression;
   class SupportsCondition;
-  class Supports_Operator;
+  class SupportsOperation;
   class Supports_Negation;
   class Supports_Declaration;
   class Supports_Interpolation;
@@ -183,7 +183,7 @@ namespace Sass {
   IMPL_MEM_OBJ(Media_Query);
   IMPL_MEM_OBJ(Media_Query_Expression);
   IMPL_MEM_OBJ(SupportsCondition);
-  IMPL_MEM_OBJ(Supports_Operator);
+  IMPL_MEM_OBJ(SupportsOperation);
   IMPL_MEM_OBJ(Supports_Negation);
   IMPL_MEM_OBJ(Supports_Declaration);
   IMPL_MEM_OBJ(Supports_Interpolation);

src/ast_supports.cpp

@@ -31,19 +31,19 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Operator::Supports_Operator(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj 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)
+  SupportsOperation::SupportsOperation(const SupportsOperation* ptr)
   : SupportsCondition(ptr),
     left_(ptr->left_),
     right_(ptr->right_),
     operand_(ptr->operand_)
   { }
 
-  bool Supports_Operator::needs_parens(SupportsConditionObj 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;
@@ -62,7 +62,7 @@ namespace Sass {
   bool Supports_Negation::needs_parens(SupportsConditionObj cond) const
   {
     return Cast<Supports_Negation>(cond) ||
-           Cast<Supports_Operator>(cond);
+           Cast<SupportsOperation>(cond);
   }
 
   /////////////////////////////////////////////////////////////////////////
@@ -103,7 +103,7 @@ namespace Sass {
 
   IMPLEMENT_AST_OPERATORS(SupportsRule);
   IMPLEMENT_AST_OPERATORS(SupportsCondition);
-  IMPLEMENT_AST_OPERATORS(Supports_Operator);
+  IMPLEMENT_AST_OPERATORS(SupportsOperation);
   IMPLEMENT_AST_OPERATORS(Supports_Negation);
   IMPLEMENT_AST_OPERATORS(Supports_Declaration);
   IMPLEMENT_AST_OPERATORS(Supports_Interpolation);

src/ast_supports.hpp

@@ -62,17 +62,17 @@ namespace Sass {
   ////////////////////////////////////////////////////////////
   // An operator condition (e.g. `CONDITION1 and CONDITION2`).
   ////////////////////////////////////////////////////////////
-  class Supports_Operator : public SupportsCondition {
+  class SupportsOperation : public SupportsCondition {
   public:
     enum Operand { AND, OR };
   private:
     ADD_PROPERTY(SupportsConditionObj, left);
     ADD_PROPERTY(SupportsConditionObj, right);
     ADD_PROPERTY(Operand, operand);
   public:
-    Supports_Operator(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj r, Operand o);
+    SupportsOperation(SourceSpan pstate, SupportsConditionObj l, SupportsConditionObj r, Operand o);
     virtual bool needs_parens(SupportsConditionObj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Operator)
+    ATTACH_AST_OPERATIONS(SupportsOperation)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 

src/debugger.hpp

@@ -544,9 +544,9 @@ inline void debug_ast(AST_Node* node, sass::string ind, Env* env)
     std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->condition(), ind + " =@ ");
     debug_ast(block->block(), ind + " <>");
-  } else if (Cast<Supports_Operator>(node)) {
-    Supports_Operator* block = Cast<Supports_Operator>(node);
-    std::cerr << ind << "Supports_Operator " << block;
+  } else if (Cast<SupportsOperation>(node)) {
+    SupportsOperation* block = Cast<SupportsOperation>(node);
+    std::cerr << ind << "SupportsOperation " << block;
     std::cerr << " (" << pstate_source_position(node) << ")"
     << std::endl;
     debug_ast(block->left(), ind + " left) ");

src/eval.cpp

@@ -1313,11 +1313,11 @@ namespace Sass {
     return str;
   }
 
-  Expression* Eval::operator()(Supports_Operator* c)
+  Expression* Eval::operator()(SupportsOperation* c)
   {
     Expression* left = c->left()->perform(this);
     Expression* right = c->right()->perform(this);
-    Supports_Operator* cc = SASS_MEMORY_NEW(Supports_Operator,
+    SupportsOperation* cc = SASS_MEMORY_NEW(SupportsOperation,
                                  c->pstate(),
                                  Cast<SupportsCondition>(left),
                                  Cast<SupportsCondition>(right),

src/eval.hpp

@@ -67,7 +67,7 @@ namespace Sass {
     Media_Query* operator()(Media_Query*);
     Expression* operator()(Media_Query_Expression*);
     Expression* operator()(At_Root_Query*);
-    Expression* operator()(Supports_Operator*);
+    Expression* operator()(SupportsOperation*);
     Expression* operator()(Supports_Negation*);
     Expression* operator()(Supports_Declaration*);
     Expression* operator()(Supports_Interpolation*);

src/inspect.cpp

@@ -757,18 +757,18 @@ namespace Sass {
     append_token(w->message(), w);
   }
 
-  void Inspect::operator()(Supports_Operator* so)
+  void Inspect::operator()(SupportsOperation* so)
   {
 
     if (so->needs_parens(so->left())) append_string("(");
     so->left()->perform(this);
     if (so->needs_parens(so->left())) append_string(")");
 
-    if (so->operand() == Supports_Operator::AND) {
+    if (so->operand() == SupportsOperation::AND) {
       append_mandatory_space();
       append_token("and", so);
       append_mandatory_space();
-    } else if (so->operand() == Supports_Operator::OR) {
+    } else if (so->operand() == SupportsOperation::OR) {
       append_mandatory_space();
       append_token("or", so);
       append_mandatory_space();

src/inspect.hpp

@@ -62,7 +62,7 @@ namespace Sass {
     virtual void operator()(String_Quoted*);
     virtual void operator()(Custom_Error*);
     virtual void operator()(Custom_Warning*);
-    virtual void operator()(Supports_Operator*);
+    virtual void operator()(SupportsOperation*);
     virtual void operator()(Supports_Negation*);
     virtual void operator()(Supports_Declaration*);
     virtual void operator()(Supports_Interpolation*);

src/operation.hpp

@@ -95,7 +95,7 @@ namespace Sass {
     virtual T operator()(String_Quoted* x)          = 0;
     virtual T operator()(String_Constant* x)        = 0;
     virtual T operator()(SupportsCondition* x)     = 0;
-    virtual T operator()(Supports_Operator* x)      = 0;
+    virtual T operator()(SupportsOperation* x)      = 0;
     virtual T operator()(Supports_Negation* x)      = 0;
     virtual T operator()(Supports_Declaration* x)   = 0;
     virtual T operator()(Supports_Interpolation* x) = 0;
@@ -181,7 +181,7 @@ namespace Sass {
     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()(SupportsCondition* x)     { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Operator* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsOperation* 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); }
     T operator()(Supports_Interpolation* x) { return static_cast<D*>(this)->fallback(x); }

src/parser.cpp

@@ -2329,15 +2329,15 @@ namespace Sass {
     if (cond.isNull()) return {};
 
     while (true) {
-      Supports_Operator::Operand op = Supports_Operator::OR;
-      if (lex < kwd_and >()) { op = Supports_Operator::AND; }
+      SupportsOperation::Operand op = SupportsOperation::OR;
+      if (lex < kwd_and >()) { op = SupportsOperation::AND; }
       else if(!lex < kwd_or >()) { break; }
 
       lex < css_whitespace >();
       SupportsConditionObj right = parse_supports_condition_in_parens(/*parens_required=*/true);
 
       // SupportsCondition* cc = SASS_MEMORY_NEW(SupportsCondition, *static_cast<SupportsCondition*>(cond));
-      cond = SASS_MEMORY_NEW(Supports_Operator, pstate, cond, right, op);
+      cond = SASS_MEMORY_NEW(SupportsOperation, pstate, cond, right, op);
     }
     return cond;
   }