Rename Supports_Declaration to SupportsDeclaration

Author: mgreter

src/ast_fwd_decl.hpp

@@ -88,7 +88,7 @@ namespace Sass {
   class SupportsCondition;
   class SupportsOperation;
   class SupportsNegation;
-  class Supports_Declaration;
+  class SupportsDeclaration;
   class Supports_Interpolation;
 
   class At_Root_Query;
@@ -185,7 +185,7 @@ namespace Sass {
   IMPL_MEM_OBJ(SupportsCondition);
   IMPL_MEM_OBJ(SupportsOperation);
   IMPL_MEM_OBJ(SupportsNegation);
-  IMPL_MEM_OBJ(Supports_Declaration);
+  IMPL_MEM_OBJ(SupportsDeclaration);
   IMPL_MEM_OBJ(Supports_Interpolation);
   IMPL_MEM_OBJ(At_Root_Query);
   IMPL_MEM_OBJ(Null);

src/ast_supports.cpp

@@ -68,16 +68,16 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Declaration::Supports_Declaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v)
+  SupportsDeclaration::SupportsDeclaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v)
   : SupportsCondition(pstate), feature_(f), value_(v)
   { }
-  Supports_Declaration::Supports_Declaration(const Supports_Declaration* ptr)
+  SupportsDeclaration::SupportsDeclaration(const SupportsDeclaration* ptr)
   : SupportsCondition(ptr),
     feature_(ptr->feature_),
     value_(ptr->value_)
   { }
 
-  bool Supports_Declaration::needs_parens(SupportsConditionObj cond) const
+  bool SupportsDeclaration::needs_parens(SupportsConditionObj cond) const
   {
     return false;
   }
@@ -105,7 +105,7 @@ namespace Sass {
   IMPLEMENT_AST_OPERATORS(SupportsCondition);
   IMPLEMENT_AST_OPERATORS(SupportsOperation);
   IMPLEMENT_AST_OPERATORS(SupportsNegation);
-  IMPLEMENT_AST_OPERATORS(Supports_Declaration);
+  IMPLEMENT_AST_OPERATORS(SupportsDeclaration);
   IMPLEMENT_AST_OPERATORS(Supports_Interpolation);
 
   /////////////////////////////////////////////////////////////////////////

src/ast_supports.hpp

@@ -92,14 +92,14 @@ namespace Sass {
   /////////////////////////////////////////////////////
   // A declaration condition (e.g. `(feature: value)`).
   /////////////////////////////////////////////////////
-  class Supports_Declaration : public SupportsCondition {
+  class SupportsDeclaration : public SupportsCondition {
   private:
     ADD_PROPERTY(ExpressionObj, feature);
     ADD_PROPERTY(ExpressionObj, value);
   public:
-    Supports_Declaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v);
+    SupportsDeclaration(SourceSpan pstate, ExpressionObj f, ExpressionObj v);
     virtual bool needs_parens(SupportsConditionObj cond) const override;
-    ATTACH_AST_OPERATIONS(Supports_Declaration)
+    ATTACH_AST_OPERATIONS(SupportsDeclaration)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 

src/debugger.hpp

@@ -564,9 +564,9 @@ inline void debug_ast(AST_Node* node, sass::string ind, Env* env)
     << std::endl;
     debug_ast(block->feature(), ind + " feature) ");
     debug_ast(block->value(), ind + " value) ");
-  } else if (Cast<Supports_Declaration>(node)) {
-    Supports_Declaration* block = Cast<Supports_Declaration>(node);
-    std::cerr << ind << "Supports_Declaration " << block;
+  } else if (Cast<SupportsDeclaration>(node)) {
+    SupportsDeclaration* block = Cast<SupportsDeclaration>(node);
+    std::cerr << ind << "SupportsDeclaration " << block;
     std::cerr << " (" << pstate_source_position(node) << ")"
     << std::endl;
     debug_ast(block->feature(), ind + " feature) ");

src/eval.cpp

@@ -1334,11 +1334,11 @@ namespace Sass {
     return cc;
   }
 
-  Expression* Eval::operator()(Supports_Declaration* c)
+  Expression* Eval::operator()(SupportsDeclaration* c)
   {
     Expression* feature = c->feature()->perform(this);
     Expression* value = c->value()->perform(this);
-    Supports_Declaration* cc = SASS_MEMORY_NEW(Supports_Declaration,
+    SupportsDeclaration* cc = SASS_MEMORY_NEW(SupportsDeclaration,
                               c->pstate(),
                               feature,
                               value);

src/eval.hpp

@@ -69,7 +69,7 @@ namespace Sass {
     Expression* operator()(At_Root_Query*);
     Expression* operator()(SupportsOperation*);
     Expression* operator()(SupportsNegation*);
-    Expression* operator()(Supports_Declaration*);
+    Expression* operator()(SupportsDeclaration*);
     Expression* operator()(Supports_Interpolation*);
     Expression* operator()(Null*);
     Expression* operator()(Argument*);

src/inspect.cpp

@@ -788,7 +788,7 @@ namespace Sass {
     if (sn->needs_parens(sn->condition())) append_string(")");
   }
 
-  void Inspect::operator()(Supports_Declaration* sd)
+  void Inspect::operator()(SupportsDeclaration* sd)
   {
     append_string("(");
     sd->feature()->perform(this);

src/inspect.hpp

@@ -64,7 +64,7 @@ namespace Sass {
     virtual void operator()(Custom_Warning*);
     virtual void operator()(SupportsOperation*);
     virtual void operator()(SupportsNegation*);
-    virtual void operator()(Supports_Declaration*);
+    virtual void operator()(SupportsDeclaration*);
     virtual void operator()(Supports_Interpolation*);
     virtual void operator()(MediaRule*);
     virtual void operator()(CssMediaRule*);

src/operation.hpp

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

src/parser.cpp

@@ -2364,7 +2364,7 @@ namespace Sass {
       expression = parse_list(DELAYED);
     }
     if (!feature || !expression) error("@supports condition expected declaration");
-    cond = SASS_MEMORY_NEW(Supports_Declaration,
+    cond = SASS_MEMORY_NEW(SupportsDeclaration,
                      feature->pstate(),
                      feature,
                      expression);