[WIP] [DNM] Backport dart sass parser 13

Author: mgreter

src/ast.cpp

@@ -154,7 +154,7 @@ namespace Sass {
   { }
   Block::Block(const Block* ptr)
   : Statement(ptr),
-    Vectorized<Statement_Obj>(*ptr),
+    Vectorized<Statement_Obj>(ptr),
     is_root_(ptr->is_root_)
   { }
 
@@ -166,7 +166,7 @@ namespace Sass {
 
   bool Block::isInvisible() const
   {
-    for (auto& item : elements()) {
+    for (auto& item : this->elements()) {
       if (!item->is_invisible()) return false;
     }
     return true;
@@ -198,22 +198,16 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Ruleset::Ruleset(ParserState pstate, SelectorListObj s, Block_Obj b)
-  : Has_Block(pstate, b), selector_(s), interpolation_(), is_root_(false)
+  StyleRule::StyleRule(ParserState pstate, Interpolation* s, Block_Obj b)
+    : Has_Block(pstate, b), interpolation_(s)
   { statement_type(RULESET); }
 
-  Ruleset::Ruleset(ParserState pstate, Interpolation* s, Block_Obj b)
-    : Has_Block(pstate, b), selector_(), interpolation_(s), is_root_(false)
-  { statement_type(RULESET); }
-
-  Ruleset::Ruleset(const Ruleset* ptr)
+  StyleRule::StyleRule(const StyleRule* ptr)
   : Has_Block(ptr),
-    selector_(ptr->selector_),
-    interpolation_(ptr->interpolation_),
-    is_root_(ptr->is_root_)
+    interpolation_(ptr->interpolation_)
   { statement_type(RULESET); }
 
-  bool Ruleset::is_invisible() const {
+  bool CssStyleRule::is_invisible() const {
     bool sel_invisible = true;
     bool els_invisible = true;
     if (const SelectorList * sl = Cast<SelectorList>(selector())) {
@@ -692,17 +686,11 @@ namespace Sass {
 
   Expression::Expression(ParserState pstate, bool d, bool e, bool i, Type ct)
   : AST_Node(pstate),
-    is_delayed_(d),
-    is_expanded_(e),
-    is_interpolant_(i),
     concrete_type_(ct)
   { }
 
   Expression::Expression(const Expression* ptr)
   : AST_Node(ptr),
-    is_delayed_(ptr->is_delayed_),
-    is_expanded_(ptr->is_expanded_),
-    is_interpolant_(ptr->is_interpolant_),
     concrete_type_(ptr->concrete_type_)
   { }
 
@@ -722,34 +710,17 @@ namespace Sass {
     expression_(ptr->expression())
   {}
 
-  size_t ParenthesizedExpression::hash() const
-  {
-    if (expression()) {
-      return expression()->hash();
-    }
-    return 0;
-  }
-
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
   Unary_Expression::Unary_Expression(ParserState pstate, Type t, Expression_Obj o)
-  : Expression(pstate), optype_(t), operand_(o), hash_(0)
+  : Expression(pstate), optype_(t), operand_(o)
   { }
   Unary_Expression::Unary_Expression(const Unary_Expression* ptr)
   : Expression(ptr),
     optype_(ptr->optype_),
-    operand_(ptr->operand_),
-    hash_(ptr->hash_)
+    operand_(ptr->operand_)
   { }
-  size_t Unary_Expression::hash() const
-  {
-    if (hash_ == 0) {
-      hash_ = std::hash<size_t>()(optype_);
-      hash_combine(hash_, operand()->hash());
-    };
-    return hash_;
-  }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
@@ -768,12 +739,6 @@ namespace Sass {
   {
   }
 
-  void Argument::set_delayed(bool delayed)
-  {
-    if (value_) value_->set_delayed(delayed);
-    is_delayed(delayed);
-  }
-
   size_t Argument::hash() const
   {
     if (hash_ == 0) {
@@ -788,62 +753,58 @@ namespace Sass {
 
   Arguments::Arguments(ParserState pstate)
   : Expression(pstate),
-    Vectorized<Argument_Obj>(),
-    has_named_arguments_(false),
-    has_rest_argument_(false),
-    has_keyword_argument_(false)
+    Vectorized<Argument_Obj>()
   { }
   Arguments::Arguments(const Arguments* ptr)
   : Expression(ptr),
-    Vectorized<Argument_Obj>(*ptr),
-    has_named_arguments_(ptr->has_named_arguments_),
-    has_rest_argument_(ptr->has_rest_argument_),
-    has_keyword_argument_(ptr->has_keyword_argument_)
+    Vectorized<Argument_Obj>(*ptr)
   { }
 
-  void Arguments::set_delayed(bool delayed)
+  ArgumentObj Arguments::get_rest_argument()
   {
-    for (Argument_Obj arg : elements()) {
-      if (arg) arg->set_delayed(delayed);
+    for (Argument* arg : elements()) {
+      if (arg->is_rest_argument()) {
+        return arg;
+      }
     }
-    is_delayed(delayed);
+    return ArgumentObj();
   }
 
-  Argument_Obj Arguments::get_rest_argument()
+  ArgumentObj Arguments::get_keyword_argument()
   {
-    if (this->has_rest_argument()) {
-      for (Argument_Obj arg : this->elements()) {
-        if (arg->is_rest_argument()) {
-          return arg;
-        }
+    for (Argument* arg : elements()) {
+      if (arg->is_keyword_argument()) {
+        return arg;
       }
     }
-    return {};
+    return ArgumentObj();
   }
 
-  Argument_Obj Arguments::get_keyword_argument()
-  {
-    if (this->has_keyword_argument()) {
-      for (Argument_Obj arg : this->elements()) {
-        if (arg->is_keyword_argument()) {
-          return arg;
-        }
+  bool Arguments::hasRestArgument() const {
+    for (const Argument* arg : elements()) {
+      if (arg->is_rest_argument()) {
+        return true;
       }
     }
-    return {};
+    return false;
   }
 
-  void Arguments::adjust_after_pushing(Argument_Obj a)
-  {
-    if (!a->name().empty()) {
-      has_named_arguments(true);
-    }
-    else if (a->is_rest_argument()) {
-      has_rest_argument(true);
+  bool Arguments::hasNamedArgument() const {
+    for (const Argument* arg : elements()) {
+      if (!arg->name().empty()) {
+        return true;
+      }
     }
-    else if (a->is_keyword_argument()) {
-      has_keyword_argument(true);
+    return false;
+  }
+
+  bool Arguments::hasKeywordArgument() const {
+    for (const Argument* arg : elements()) {
+      if (arg->is_keyword_argument()) {
+        return true;
+      }
     }
+    return false;
   }
 
   /////////////////////////////////////////////////////////////////////////
@@ -965,23 +926,13 @@ namespace Sass {
     has_rest_parameter_(ptr->has_rest_parameter_)
   { }
 
-  void Parameters::adjust_after_pushing(Parameter_Obj p)
-  {
-    if (p->default_value()) {
-      has_optional_parameters(true);
-    }
-    else if (p->is_rest_parameter()) {
-      has_rest_parameter(true);
-    }
-  }
-
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
   // If you forget to add a class here you will get
   // undefined reference to `vtable for Sass::Class'
 
-  IMPLEMENT_AST_OPERATORS(Ruleset);
+  IMPLEMENT_AST_OPERATORS(StyleRule);
   IMPLEMENT_AST_OPERATORS(MediaRule);
   IMPLEMENT_AST_OPERATORS(Import);
   IMPLEMENT_AST_OPERATORS(Import_Stub);