Rename Has_Block to ParentStatement

Author: mgreter

src/ast.cpp

@@ -147,14 +147,14 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Has_Block::Has_Block(ParserState pstate, Block_Obj b)
+  ParentStatement::ParentStatement(ParserState pstate, Block_Obj b)
   : Statement(pstate), block_(b)
   { }
-  Has_Block::Has_Block(const Has_Block* ptr)
+  ParentStatement::ParentStatement(const ParentStatement* ptr)
   : Statement(ptr), block_(ptr->block_)
   { }
 
-  bool Has_Block::has_content()
+  bool ParentStatement::has_content()
   {
     return (block_ && block_->has_content()) || Statement::has_content();
   }
@@ -163,10 +163,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Ruleset::Ruleset(ParserState pstate, SelectorListObj s, Block_Obj b)
-  : Has_Block(pstate, b), selector_(s), schema_(), is_root_(false)
+  : ParentStatement(pstate, b), selector_(s), schema_(), is_root_(false)
   { statement_type(RULESET); }
   Ruleset::Ruleset(const Ruleset* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     selector_(ptr->selector_),
     schema_(ptr->schema_),
     is_root_(ptr->is_root_)
@@ -201,10 +201,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Trace::Trace(ParserState pstate, sass::string n, Block_Obj b, char type)
-  : Has_Block(pstate, b), type_(type), name_(n)
+  : ParentStatement(pstate, b), type_(type), name_(n)
   { }
   Trace::Trace(const Trace* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     type_(ptr->type_),
     name_(ptr->name_)
   { }
@@ -213,10 +213,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Directive::Directive(ParserState pstate, sass::string kwd, SelectorListObj sel, Block_Obj b, Expression_Obj val)
-  : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
+  : ParentStatement(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
   { statement_type(DIRECTIVE); }
   Directive::Directive(const Directive* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     keyword_(ptr->keyword_),
     selector_(ptr->selector_),
     value_(ptr->value_) // set value manually if needed
@@ -241,20 +241,20 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Keyframe_Rule::Keyframe_Rule(ParserState pstate, Block_Obj b)
-  : Has_Block(pstate, b), name_()
+  : ParentStatement(pstate, b), name_()
   { statement_type(KEYFRAMERULE); }
   Keyframe_Rule::Keyframe_Rule(const Keyframe_Rule* ptr)
-  : Has_Block(ptr), name_(ptr->name_)
+  : ParentStatement(ptr), name_(ptr->name_)
   { statement_type(KEYFRAMERULE); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
   Declaration::Declaration(ParserState pstate, String_Obj prop, Expression_Obj val, bool i, bool c, Block_Obj b)
-  : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)
+  : ParentStatement(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)
   { statement_type(DECLARATION); }
   Declaration::Declaration(const Declaration* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     property_(ptr->property_),
     value_(ptr->value_),
     is_important_(ptr->is_important_),
@@ -365,29 +365,29 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   If::If(ParserState pstate, Expression_Obj pred, Block_Obj con, Block_Obj alt)
-  : Has_Block(pstate, con), predicate_(pred), alternative_(alt)
+  : ParentStatement(pstate, con), predicate_(pred), alternative_(alt)
   { statement_type(IF); }
   If::If(const If* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     predicate_(ptr->predicate_),
     alternative_(ptr->alternative_)
   { statement_type(IF); }
 
   bool If::has_content()
   {
-    return Has_Block::has_content() || (alternative_ && alternative_->has_content());
+    return ParentStatement::has_content() || (alternative_ && alternative_->has_content());
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
   For::For(ParserState pstate,
       sass::string var, Expression_Obj lo, Expression_Obj hi, Block_Obj b, bool inc)
-  : Has_Block(pstate, b),
+  : ParentStatement(pstate, b),
     variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)
   { statement_type(FOR); }
   For::For(const For* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     variable_(ptr->variable_),
     lower_bound_(ptr->lower_bound_),
     upper_bound_(ptr->upper_bound_),
@@ -398,20 +398,20 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Each::Each(ParserState pstate, sass::vector<sass::string> vars, Expression_Obj lst, Block_Obj b)
-  : Has_Block(pstate, b), variables_(vars), list_(lst)
+  : ParentStatement(pstate, b), variables_(vars), list_(lst)
   { statement_type(EACH); }
   Each::Each(const Each* ptr)
-  : Has_Block(ptr), variables_(ptr->variables_), list_(ptr->list_)
+  : ParentStatement(ptr), variables_(ptr->variables_), list_(ptr->list_)
   { statement_type(EACH); }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
   While::While(ParserState pstate, Expression_Obj pred, Block_Obj b)
-  : Has_Block(pstate, b), predicate_(pred)
+  : ParentStatement(pstate, b), predicate_(pred)
   { statement_type(WHILE); }
   While::While(const While* ptr)
-  : Has_Block(ptr), predicate_(ptr->predicate_)
+  : ParentStatement(ptr), predicate_(ptr->predicate_)
   { statement_type(WHILE); }
 
   /////////////////////////////////////////////////////////////////////////
@@ -446,7 +446,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Definition::Definition(const Definition* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     name_(ptr->name_),
     parameters_(ptr->parameters_),
     environment_(ptr->environment_),
@@ -463,7 +463,7 @@ namespace Sass {
               Parameters_Obj params,
               Block_Obj b,
               Type t)
-  : Has_Block(pstate, b),
+  : ParentStatement(pstate, b),
     name_(n),
     parameters_(params),
     environment_(0),
@@ -481,7 +481,7 @@ namespace Sass {
               Parameters_Obj params,
               Native_Function func_ptr,
               bool overload_stub)
-  : Has_Block(pstate, {}),
+  : ParentStatement(pstate, {}),
     name_(n),
     parameters_(params),
     environment_(0),
@@ -498,7 +498,7 @@ namespace Sass {
               sass::string n,
               Parameters_Obj params,
               Sass_Function_Entry c_func)
-  : Has_Block(pstate, {}),
+  : ParentStatement(pstate, {}),
     name_(n),
     parameters_(params),
     environment_(0),
@@ -514,10 +514,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Mixin_Call::Mixin_Call(ParserState pstate, sass::string n, Arguments_Obj args, Parameters_Obj b_params, Block_Obj b)
-  : Has_Block(pstate, b), name_(n), arguments_(args), block_parameters_(b_params)
+  : ParentStatement(pstate, b), name_(n), arguments_(args), block_parameters_(b_params)
   { }
   Mixin_Call::Mixin_Call(const Mixin_Call* ptr)
-  : Has_Block(ptr),
+  : ParentStatement(ptr),
     name_(ptr->name_),
     arguments_(ptr->arguments_),
     block_parameters_(ptr->block_parameters_)
@@ -808,10 +808,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   At_Root_Block::At_Root_Block(ParserState pstate, Block_Obj b, At_Root_Query_Obj e)
-  : Has_Block(pstate, b), expression_(e)
+  : ParentStatement(pstate, b), expression_(e)
   { statement_type(ATROOT); }
   At_Root_Block::At_Root_Block(const At_Root_Block* ptr)
-  : Has_Block(ptr), expression_(ptr->expression_)
+  : ParentStatement(ptr), expression_(ptr->expression_)
   { statement_type(ATROOT); }
 
   bool At_Root_Block::bubbles() {

src/ast.hpp

@@ -515,21 +515,21 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   // Abstract base class for statements that contain blocks of statements.
   ////////////////////////////////////////////////////////////////////////
-  class Has_Block : public Statement {
+  class ParentStatement : public Statement {
     ADD_PROPERTY(Block_Obj, block)
   public:
-    Has_Block(ParserState pstate, Block_Obj b);
-    Has_Block(const Has_Block* ptr); // copy constructor
-    virtual ~Has_Block() = 0; // virtual destructor
+    ParentStatement(ParserState pstate, Block_Obj b);
+    ParentStatement(const ParentStatement* ptr); // copy constructor
+    virtual ~ParentStatement() = 0; // virtual destructor
     virtual bool has_content() override;
   };
-  inline Has_Block::~Has_Block() { }
+  inline ParentStatement::~ParentStatement() { }
 
   /////////////////////////////////////////////////////////////////////////////
   // Rulesets (i.e., sets of styles headed by a selector and containing a block
   // of style declarations.
   /////////////////////////////////////////////////////////////////////////////
-  class Ruleset final : public Has_Block {
+  class Ruleset final : public ParentStatement {
     ADD_PROPERTY(SelectorListObj, selector)
     ADD_PROPERTY(Selector_Schema_Obj, schema)
     ADD_PROPERTY(bool, is_root);
@@ -556,7 +556,7 @@ namespace Sass {
   /////////////////
   // Trace.
   /////////////////
-  class Trace final : public Has_Block {
+  class Trace final : public ParentStatement {
     ADD_CONSTREF(char, type)
     ADD_CONSTREF(sass::string, name)
   public:
@@ -569,7 +569,7 @@ namespace Sass {
   // At-rules -- arbitrary directives beginning with "@" that may have an
   // optional statement block.
   ///////////////////////////////////////////////////////////////////////
-  class Directive final : public Has_Block {
+  class Directive final : public ParentStatement {
     ADD_CONSTREF(sass::string, keyword)
     ADD_PROPERTY(SelectorListObj, selector)
     ADD_PROPERTY(Expression_Obj, value)
@@ -585,7 +585,7 @@ namespace Sass {
   ///////////////////////////////////////////////////////////////////////
   // Keyframe-rules -- the child blocks of "@keyframes" nodes.
   ///////////////////////////////////////////////////////////////////////
-  class Keyframe_Rule final : public Has_Block {
+  class Keyframe_Rule final : public ParentStatement {
     // according to css spec, this should be <keyframes-name>
     // <keyframes-name> = <custom-ident> | <string>
     ADD_PROPERTY(SelectorListObj, name)
@@ -598,7 +598,7 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   // Declarations -- style rules consisting of a property name and values.
   ////////////////////////////////////////////////////////////////////////
-  class Declaration final : public Has_Block {
+  class Declaration final : public ParentStatement {
     ADD_PROPERTY(String_Obj, property)
     ADD_PROPERTY(Expression_Obj, value)
     ADD_PROPERTY(bool, is_important)
@@ -703,7 +703,7 @@ namespace Sass {
   ////////////////////////////////////
   // The Sass `@if` control directive.
   ////////////////////////////////////
-  class If final : public Has_Block {
+  class If final : public ParentStatement {
     ADD_PROPERTY(Expression_Obj, predicate)
     ADD_PROPERTY(Block_Obj, alternative)
   public:
@@ -716,7 +716,7 @@ namespace Sass {
   /////////////////////////////////////
   // The Sass `@for` control directive.
   /////////////////////////////////////
-  class For final : public Has_Block {
+  class For final : public ParentStatement {
     ADD_CONSTREF(sass::string, variable)
     ADD_PROPERTY(Expression_Obj, lower_bound)
     ADD_PROPERTY(Expression_Obj, upper_bound)
@@ -730,7 +730,7 @@ namespace Sass {
   //////////////////////////////////////
   // The Sass `@each` control directive.
   //////////////////////////////////////
-  class Each final : public Has_Block {
+  class Each final : public ParentStatement {
     ADD_PROPERTY(sass::vector<sass::string>, variables)
     ADD_PROPERTY(Expression_Obj, list)
   public:
@@ -742,7 +742,7 @@ namespace Sass {
   ///////////////////////////////////////
   // The Sass `@while` control directive.
   ///////////////////////////////////////
-  class While final : public Has_Block {
+  class While final : public ParentStatement {
     ADD_PROPERTY(Expression_Obj, predicate)
   public:
     While(ParserState pstate, Expression_Obj pred, Block_Obj b);
@@ -765,7 +765,7 @@ namespace Sass {
   // Definitions for both mixins and functions. The two cases are distinguished
   // by a type tag.
   /////////////////////////////////////////////////////////////////////////////
-  class Definition final : public Has_Block {
+  class Definition final : public ParentStatement {
   public:
     enum Type { MIXIN, FUNCTION };
     ADD_CONSTREF(sass::string, name)
@@ -801,7 +801,7 @@ namespace Sass {
   //////////////////////////////////////
   // Mixin calls (i.e., `@include ...`).
   //////////////////////////////////////
-  class Mixin_Call final : public Has_Block {
+  class Mixin_Call final : public ParentStatement {
     ADD_CONSTREF(sass::string, name)
     ADD_PROPERTY(Arguments_Obj, arguments)
     ADD_PROPERTY(Parameters_Obj, block_parameters)
@@ -882,7 +882,7 @@ namespace Sass {
 
   // A Media Ruleset before it has been evaluated
   // Could be already final or an interpolation
-  class MediaRule final : public Has_Block {
+  class MediaRule final : public ParentStatement {
     ADD_PROPERTY(List_Obj, schema)
   public:
     MediaRule(ParserState pstate, Block_Obj block = {});
@@ -895,7 +895,7 @@ namespace Sass {
 
   // A Media Ruleset after it has been evaluated
   // Representing the static or resulting css
-  class CssMediaRule final : public Has_Block,
+  class CssMediaRule final : public ParentStatement,
     public Vectorized<CssMediaQuery_Obj> {
   public:
     CssMediaRule(ParserState pstate, Block_Obj b);
@@ -1011,7 +1011,7 @@ namespace Sass {
   ///////////
   // At-root.
   ///////////
-  class At_Root_Block final : public Has_Block {
+  class At_Root_Block final : public ParentStatement {
     ADD_PROPERTY(At_Root_Query_Obj, expression)
   public:
     At_Root_Block(ParserState pstate, Block_Obj b = {}, At_Root_Query_Obj e = {});

src/ast_fwd_decl.cpp

@@ -16,7 +16,7 @@ namespace Sass {
   IMPLEMENT_BASE_CAST(AST_Node)
   IMPLEMENT_BASE_CAST(Expression)
   IMPLEMENT_BASE_CAST(Statement)
-  IMPLEMENT_BASE_CAST(Has_Block)
+  IMPLEMENT_BASE_CAST(ParentStatement)
   IMPLEMENT_BASE_CAST(PreValue)
   IMPLEMENT_BASE_CAST(Value)
   IMPLEMENT_BASE_CAST(Color)

src/ast_fwd_decl.hpp

@@ -15,7 +15,7 @@ namespace Sass {
 
   class AST_Node;
 
-  class Has_Block;
+  class ParentStatement;
 
   class SimpleSelector;
 
@@ -150,7 +150,7 @@ namespace Sass {
   IMPL_MEM_OBJ(Debug);
   IMPL_MEM_OBJ(Comment);
   IMPL_MEM_OBJ(PreValue);
-  IMPL_MEM_OBJ(Has_Block);
+  IMPL_MEM_OBJ(ParentStatement);
   IMPL_MEM_OBJ(If);
   IMPL_MEM_OBJ(For);
   IMPL_MEM_OBJ(Each);
@@ -248,7 +248,7 @@ namespace Sass {
   DECLARE_BASE_CAST(AST_Node)
   DECLARE_BASE_CAST(Expression)
   DECLARE_BASE_CAST(Statement)
-  DECLARE_BASE_CAST(Has_Block)
+  DECLARE_BASE_CAST(ParentStatement)
   DECLARE_BASE_CAST(PreValue)
   DECLARE_BASE_CAST(Value)
   DECLARE_BASE_CAST(List)