Rename Supports_Negation to SupportsNegation

Author: mgreter

src/ast_fwd_decl.hpp

@@ -87,7 +87,7 @@ namespace Sass {
   class Media_Query_Expression;
   class SupportsCondition;
   class SupportsOperation;
-  class Supports_Negation;
+  class SupportsNegation;
   class Supports_Declaration;
   class Supports_Interpolation;
 
@@ -184,7 +184,7 @@ namespace Sass {
   IMPL_MEM_OBJ(Media_Query_Expression);
   IMPL_MEM_OBJ(SupportsCondition);
   IMPL_MEM_OBJ(SupportsOperation);
-  IMPL_MEM_OBJ(Supports_Negation);
+  IMPL_MEM_OBJ(SupportsNegation);
   IMPL_MEM_OBJ(Supports_Declaration);
   IMPL_MEM_OBJ(Supports_Interpolation);
   IMPL_MEM_OBJ(At_Root_Query);

src/ast_supports.cpp

@@ -46,22 +46,22 @@ namespace Sass {
     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(SourceSpan pstate, SupportsConditionObj c)
+  SupportsNegation::SupportsNegation(SourceSpan pstate, SupportsConditionObj c)
   : SupportsCondition(pstate), condition_(c)
   { }
-  Supports_Negation::Supports_Negation(const Supports_Negation* ptr)
+  SupportsNegation::SupportsNegation(const SupportsNegation* ptr)
   : SupportsCondition(ptr), condition_(ptr->condition_)
   { }
 
-  bool Supports_Negation::needs_parens(SupportsConditionObj cond) const
+  bool SupportsNegation::needs_parens(SupportsConditionObj cond) const
   {
-    return Cast<Supports_Negation>(cond) ||
+    return Cast<SupportsNegation>(cond) ||
            Cast<SupportsOperation>(cond);
   }
 
@@ -104,7 +104,7 @@ namespace Sass {
   IMPLEMENT_AST_OPERATORS(SupportsRule);
   IMPLEMENT_AST_OPERATORS(SupportsCondition);
   IMPLEMENT_AST_OPERATORS(SupportsOperation);
-  IMPLEMENT_AST_OPERATORS(Supports_Negation);
+  IMPLEMENT_AST_OPERATORS(SupportsNegation);
   IMPLEMENT_AST_OPERATORS(Supports_Declaration);
   IMPLEMENT_AST_OPERATORS(Supports_Interpolation);
 

src/ast_supports.hpp

@@ -79,13 +79,13 @@ namespace Sass {
   //////////////////////////////////////////
   // A negation condition (`not CONDITION`).
   //////////////////////////////////////////
-  class Supports_Negation : public SupportsCondition {
+  class SupportsNegation : public SupportsCondition {
   private:
     ADD_PROPERTY(SupportsConditionObj, condition);
   public:
-    Supports_Negation(SourceSpan pstate, SupportsConditionObj c);
+    SupportsNegation(SourceSpan pstate, SupportsConditionObj c);
     virtual bool needs_parens(SupportsConditionObj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Negation)
+    ATTACH_AST_OPERATIONS(SupportsNegation)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 

src/debugger.hpp

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

src/eval.cpp

@@ -1325,10 +1325,10 @@ namespace Sass {
     return cc;
   }
 
-  Expression* Eval::operator()(Supports_Negation* c)
+  Expression* Eval::operator()(SupportsNegation* c)
   {
     Expression* condition = c->condition()->perform(this);
-    Supports_Negation* cc = SASS_MEMORY_NEW(Supports_Negation,
+    SupportsNegation* cc = SASS_MEMORY_NEW(SupportsNegation,
                                  c->pstate(),
                                  Cast<SupportsCondition>(condition));
     return cc;

src/eval.hpp

@@ -68,7 +68,7 @@ namespace Sass {
     Expression* operator()(Media_Query_Expression*);
     Expression* operator()(At_Root_Query*);
     Expression* operator()(SupportsOperation*);
-    Expression* operator()(Supports_Negation*);
+    Expression* operator()(SupportsNegation*);
     Expression* operator()(Supports_Declaration*);
     Expression* operator()(Supports_Interpolation*);
     Expression* operator()(Null*);

src/inspect.cpp

@@ -779,7 +779,7 @@ namespace Sass {
     if (so->needs_parens(so->right())) append_string(")");
   }
 
-  void Inspect::operator()(Supports_Negation* sn)
+  void Inspect::operator()(SupportsNegation* sn)
   {
     append_token("not", sn);
     append_mandatory_space();

src/inspect.hpp

@@ -63,7 +63,7 @@ namespace Sass {
     virtual void operator()(Custom_Error*);
     virtual void operator()(Custom_Warning*);
     virtual void operator()(SupportsOperation*);
-    virtual void operator()(Supports_Negation*);
+    virtual void operator()(SupportsNegation*);
     virtual void operator()(Supports_Declaration*);
     virtual void operator()(Supports_Interpolation*);
     virtual void operator()(MediaRule*);

src/operation.hpp

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

src/parser.cpp

@@ -2320,7 +2320,7 @@ namespace Sass {
   {
     if (!lex < kwd_not >()) return {};
     SupportsConditionObj cond = parse_supports_condition_in_parens(/*parens_required=*/true);
-    return SASS_MEMORY_NEW(Supports_Negation, pstate, cond);
+    return SASS_MEMORY_NEW(SupportsNegation, pstate, cond);
   }
 
   SupportsConditionObj Parser::parse_supports_operator(bool top_level)