Rename Supports_Block to SupportsRule

mgreter · mgreter · commit 0aff8d5bd4f9 · 2019-11-03T01:52:01.000+01:00
diff --git a/src/ast_fwd_decl.hpp b/src/ast_fwd_decl.hpp
@@ -35,7 +35,7 @@ namespace Sass {
   class CssMediaRule;
   class CssMediaQuery;
 
-  class Supports_Block;
+  class SupportsRule;
   class Directive;
 
   class Keyframe_Rule;
@@ -137,7 +137,7 @@ namespace Sass {
   IMPL_MEM_OBJ(MediaRule);
   IMPL_MEM_OBJ(CssMediaRule);
   IMPL_MEM_OBJ(CssMediaQuery);
-  IMPL_MEM_OBJ(Supports_Block);
+  IMPL_MEM_OBJ(SupportsRule);
   IMPL_MEM_OBJ(Directive);
   IMPL_MEM_OBJ(Keyframe_Rule);
   IMPL_MEM_OBJ(At_Root_Block);
diff --git a/src/ast_supports.cpp b/src/ast_supports.cpp
@@ -9,13 +9,13 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Supports_Block::Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block)
+  SupportsRule::SupportsRule(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block)
   : ParentStatement(pstate, block), condition_(condition)
   { statement_type(SUPPORTS); }
-  Supports_Block::Supports_Block(const Supports_Block* ptr)
+  SupportsRule::SupportsRule(const SupportsRule* ptr)
   : ParentStatement(ptr), condition_(ptr->condition_)
   { statement_type(SUPPORTS); }
-  bool Supports_Block::bubbles() { return true; }
+  bool SupportsRule::bubbles() { return true; }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
@@ -101,7 +101,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  IMPLEMENT_AST_OPERATORS(Supports_Block);
+  IMPLEMENT_AST_OPERATORS(SupportsRule);
   IMPLEMENT_AST_OPERATORS(Supports_Condition);
   IMPLEMENT_AST_OPERATORS(Supports_Operator);
   IMPLEMENT_AST_OPERATORS(Supports_Negation);
diff --git a/src/ast_supports.hpp b/src/ast_supports.hpp
@@ -39,12 +39,12 @@ namespace Sass {
   ////////////////////
   // `@supports` rule.
   ////////////////////
-  class Supports_Block : public ParentStatement {
+  class SupportsRule : public ParentStatement {
     ADD_PROPERTY(Supports_Condition_Obj, condition)
   public:
-    Supports_Block(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block = {});
+    SupportsRule(ParserState pstate, Supports_Condition_Obj condition, Block_Obj block = {});
     bool bubbles() override;
-    ATTACH_AST_OPERATIONS(Supports_Block)
+    ATTACH_AST_OPERATIONS(SupportsRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
diff --git a/src/check_nesting.cpp b/src/check_nesting.cpp
@@ -388,6 +388,6 @@ namespace Sass {
            Cast<Import>(n) ||
       Cast<MediaRule>(n) ||
       Cast<CssMediaRule>(n) ||
-      Cast<Supports_Block>(n);
+      Cast<SupportsRule>(n);
   }
 }
diff --git a/src/cssize.cpp b/src/cssize.cpp
@@ -238,7 +238,7 @@ namespace Sass {
     return debubble(mm->block(), mm);
   }
 
-  Statement* Cssize::operator()(Supports_Block* m)
+  Statement* Cssize::operator()(SupportsRule* m)
   {
     if (!m->block()->length())
     { return m; }
@@ -248,7 +248,7 @@ namespace Sass {
 
     p_stack.push_back(m);
 
-    Supports_Block_Obj mm = SASS_MEMORY_NEW(Supports_Block,
+    SupportsRuleObj mm = SASS_MEMORY_NEW(SupportsRule,
                                        m->pstate(),
                                        m->condition(),
                                        operator()(m->block()));
@@ -329,7 +329,7 @@ namespace Sass {
     return bubble;
   }
 
-  Statement* Cssize::bubble(Supports_Block* m)
+  Statement* Cssize::bubble(SupportsRule* m)
   {
     StyleRuleObj parent = Cast<StyleRule>(SASS_MEMORY_COPY(this->parent()));
 
@@ -343,7 +343,7 @@ namespace Sass {
 
     Block* wrapper_block = SASS_MEMORY_NEW(Block, m->block()->pstate());
     wrapper_block->append(new_rule);
-    Supports_Block* mm = SASS_MEMORY_NEW(Supports_Block,
+    SupportsRule* mm = SASS_MEMORY_NEW(SupportsRule,
                                        m->pstate(),
                                        m->condition(),
                                        wrapper_block);
diff --git a/src/cssize.hpp b/src/cssize.hpp
@@ -24,7 +24,7 @@ namespace Sass {
     Statement* operator()(StyleRule*);
     // Statement* operator()(Bubble*);
     Statement* operator()(CssMediaRule*);
-    Statement* operator()(Supports_Block*);
+    Statement* operator()(SupportsRule*);
     Statement* operator()(At_Root_Block*);
     Statement* operator()(Directive*);
     Statement* operator()(Keyframe_Rule*);
@@ -52,7 +52,7 @@ namespace Sass {
     Statement* bubble(Directive*);
     Statement* bubble(At_Root_Block*);
     Statement* bubble(CssMediaRule*);
-    Statement* bubble(Supports_Block*);
+    Statement* bubble(SupportsRule*);
 
     Block* debubble(Block* children, Statement* parent = 0);
     Block* flatten(const Block*);
diff --git a/src/debugger.hpp b/src/debugger.hpp
@@ -537,9 +537,9 @@ inline void debug_ast(AST_Node* node, sass::string ind, Env* env)
     std::cerr << " [" << (query->type()) << "] ";
     std::cerr << " " << debug_vec(query->features());
     std::cerr << std::endl;
-  } else if (Cast<Supports_Block>(node)) {
-    Supports_Block* block = Cast<Supports_Block>(node);
-    std::cerr << ind << "Supports_Block " << block;
+  } else if (Cast<SupportsRule>(node)) {
+    SupportsRule* block = Cast<SupportsRule>(node);
+    std::cerr << ind << "SupportsRule " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " " << block->tabs() << std::endl;
     debug_ast(block->condition(), ind + " =@ ");
diff --git a/src/expand.cpp b/src/expand.cpp
@@ -228,10 +228,10 @@ namespace Sass {
     return rr;
   }
 
-  Statement* Expand::operator()(Supports_Block* f)
+  Statement* Expand::operator()(SupportsRule* f)
   {
     ExpressionObj condition = f->condition()->perform(&eval);
-    Supports_Block_Obj ff = SASS_MEMORY_NEW(Supports_Block,
+    SupportsRuleObj ff = SASS_MEMORY_NEW(SupportsRule,
                                        f->pstate(),
                                        Cast<Supports_Condition>(condition),
                                        operator()(f->block()));
diff --git a/src/expand.hpp b/src/expand.hpp
@@ -68,7 +68,7 @@ namespace Sass {
     // Css StyleRule is already static
     // Statement* operator()(CssMediaRule*);
 
-    Statement* operator()(Supports_Block*);
+    Statement* operator()(SupportsRule*);
     Statement* operator()(At_Root_Block*);
     Statement* operator()(Directive*);
     Statement* operator()(Declaration*);
diff --git a/src/inspect.cpp b/src/inspect.cpp
@@ -124,7 +124,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Supports_Block* feature_block)
+  void Inspect::operator()(SupportsRule* feature_block)
   {
     append_indentation();
     append_token("@supports", feature_block);
diff --git a/src/inspect.hpp b/src/inspect.hpp
@@ -22,7 +22,7 @@ namespace Sass {
     virtual void operator()(Block*);
     virtual void operator()(StyleRule*);
     virtual void operator()(Bubble*);
-    virtual void operator()(Supports_Block*);
+    virtual void operator()(SupportsRule*);
     virtual void operator()(At_Root_Block*);
     virtual void operator()(Directive*);
     virtual void operator()(Keyframe_Rule*);
diff --git a/src/operation.hpp b/src/operation.hpp
@@ -51,7 +51,7 @@ namespace Sass {
     virtual T operator()(StyleRule* x)                = 0;
     virtual T operator()(Bubble* x)                 = 0;
     virtual T operator()(Trace* x)                  = 0;
-    virtual T operator()(Supports_Block* x)         = 0;
+    virtual T operator()(SupportsRule* x)         = 0;
     virtual T operator()(MediaRule* x) = 0;
     virtual T operator()(CssMediaRule* x) = 0;
     virtual T operator()(CssMediaQuery* x) = 0;
@@ -137,7 +137,7 @@ namespace Sass {
     T operator()(StyleRule* x)                { return static_cast<D*>(this)->fallback(x); }
     T operator()(Bubble* x)                 { return static_cast<D*>(this)->fallback(x); }
     T operator()(Trace* x)                  { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Supports_Block* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(SupportsRule* x)         { return static_cast<D*>(this)->fallback(x); }
     T operator()(MediaRule* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(CssMediaRule* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(CssMediaQuery* x) { return static_cast<D*>(this)->fallback(x); }
diff --git a/src/output.cpp b/src/output.cpp
@@ -199,7 +199,7 @@ namespace Sass {
     append_scope_closer();
   }
 
-  void Output::operator()(Supports_Block* f)
+  void Output::operator()(SupportsRule* f)
   {
     if (f->is_invisible()) return;
 
diff --git a/src/output.hpp b/src/output.hpp
@@ -28,7 +28,7 @@ namespace Sass {
 
     virtual void operator()(Map*);
     virtual void operator()(StyleRule*);
-    virtual void operator()(Supports_Block*);
+    virtual void operator()(SupportsRule*);
     virtual void operator()(CssMediaRule*);
     virtual void operator()(Directive*);
     virtual void operator()(Keyframe_Rule*);
diff --git a/src/parser.cpp b/src/parser.cpp
@@ -2292,11 +2292,11 @@ namespace Sass {
 
   // lexed after `kwd_supports_directive`
   // these are very similar to media blocks
-  Supports_Block_Obj Parser::parse_supports_directive()
+  SupportsRuleObj Parser::parse_supports_directive()
   {
     Supports_Condition_Obj cond = parse_supports_condition(/*top_level=*/true);
     // create the ast node object for the support queries
-    Supports_Block_Obj query = SASS_MEMORY_NEW(Supports_Block, pstate, cond);
+    SupportsRuleObj query = SASS_MEMORY_NEW(SupportsRule, pstate, cond);
     // additional block is mandatory
     // parse inner block
     query->block(parse_block());
diff --git a/src/parser.hpp b/src/parser.hpp
@@ -314,7 +314,7 @@ namespace Sass {
     List_Obj parse_media_queries();
     Media_Query_Obj parse_media_query();
     Media_Query_ExpressionObj parse_media_expression();
-    Supports_Block_Obj parse_supports_directive();
+    SupportsRuleObj parse_supports_directive();
     Supports_Condition_Obj parse_supports_condition(bool top_level);
     Supports_Condition_Obj parse_supports_negation();
     Supports_Condition_Obj parse_supports_operator(bool top_level);
diff --git a/src/remove_placeholders.cpp b/src/remove_placeholders.cpp
@@ -73,7 +73,7 @@ namespace Sass {
       }
     }
 
-    void Remove_Placeholders::operator()(Supports_Block* m)
+    void Remove_Placeholders::operator()(SupportsRule* m)
     {
       if (m->block()) operator()(m->block());
     }
diff --git a/src/remove_placeholders.hpp b/src/remove_placeholders.hpp
@@ -23,7 +23,7 @@ namespace Sass {
     void operator()(Block*);
     void operator()(StyleRule*);
     void operator()(CssMediaRule*);
-    void operator()(Supports_Block*);
+    void operator()(SupportsRule*);
     void operator()(Directive*);
 
     // ignore missed types
diff --git a/src/util.cpp b/src/util.cpp
@@ -595,7 +595,7 @@ namespace Sass {
       return true;
     }
 
-    bool isPrintable(Supports_Block* f, Sass_Output_Style style) {
+    bool isPrintable(SupportsRule* f, Sass_Output_Style style) {
       if (f == NULL) {
         return false;
       }
@@ -646,7 +646,7 @@ namespace Sass {
             return true;
           }
         }
-        else if (Supports_Block* f = Cast<Supports_Block>(stm)) {
+        else if (SupportsRule* f = Cast<SupportsRule>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
@@ -699,7 +699,7 @@ namespace Sass {
             return true;
           }
         }
-        else if (Supports_Block* f = Cast<Supports_Block>(stm)) {
+        else if (SupportsRule* f = Cast<SupportsRule>(stm)) {
           if (isPrintable(f, style)) {
             return true;
           }
diff --git a/src/util.hpp b/src/util.hpp
@@ -92,7 +92,7 @@ namespace Sass {
   namespace Util {
 
     bool isPrintable(StyleRule* r, Sass_Output_Style style = NESTED);
-    bool isPrintable(Supports_Block* r, Sass_Output_Style style = NESTED);
+    bool isPrintable(SupportsRule* r, Sass_Output_Style style = NESTED);
     bool isPrintable(CssMediaRule* r, Sass_Output_Style style = NESTED);
     bool isPrintable(Comment* b, Sass_Output_Style style = NESTED);
     bool isPrintable(Block_Obj b, Sass_Output_Style style = NESTED);

Original file line number	Diff line number	Diff line change
`@@ -388,6 +388,6 @@ namespace Sass {`
`388`	`388`	`Cast<Import>(n) \|\|`
`389`	`389`	`Cast<MediaRule>(n) \|\|`
`390`	`390`	`Cast<CssMediaRule>(n) \|\|`
`391`		`- Cast<Supports_Block>(n);`
	`391`	`+ Cast<SupportsRule>(n);`
`392`	`392`	`}`
`393`	`393`	`}`
Original file line number	Diff line number	Diff line change
`@@ -228,10 +228,10 @@ namespace Sass {`
`228`	`228`	`return rr;`
`229`	`229`	`}`
`230`	`230`
`231`		`- Statement* Expand::operator()(Supports_Block* f)`
	`231`	`+ Statement* Expand::operator()(SupportsRule* f)`
`232`	`232`	`{`
`233`	`233`	`ExpressionObj condition = f->condition()->perform(&eval);`
`234`		`- Supports_Block_Obj ff = SASS_MEMORY_NEW(Supports_Block,`
	`234`	`+ SupportsRuleObj ff = SASS_MEMORY_NEW(SupportsRule,`
`235`	`235`	`f->pstate(),`
`236`	`236`	`Cast<Supports_Condition>(condition),`
`237`	`237`	`operator()(f->block()));`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ namespace Sass {`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`- void Inspect::operator()(Supports_Block* feature_block)`
	`127`	`+ void Inspect::operator()(SupportsRule* feature_block)`
`128`	`128`	`{`
`129`	`129`	`append_indentation();`
`130`	`130`	`append_token("@supports", feature_block);`