Further performance improvements (0.88)

Author: mgreter

Makefile.conf

@@ -8,10 +8,12 @@ HPPFILES = \
 	ast.hpp \
 	ast2c.hpp \
 	ast_css.hpp \
+	ast_base.hpp \
 	ast_def_macros.hpp \
 	ast_fwd_decl.hpp \
 	ast_helpers.hpp \
 	ast_selectors.hpp \
+	ast_containers.hpp \
 	ast_supports.hpp \
 	ast_values.hpp \
 	backtrace.hpp \
@@ -176,7 +178,6 @@ SOURCES = \
 	source_state.cpp \
 	source_span.cpp \
 	error_handling.cpp \
-	MurmurHash2.cpp \
 	memory/allocator.cpp \
 	memory/shared_ptr.cpp \
 	LUrlParser/LUrlParser.cpp \

include/sass/base.h

@@ -68,7 +68,6 @@ enum Sass_Output_Style {
   SASS_STYLE_COMPRESSED,
   // only used internaly
   SASS_STYLE_INSPECT,
-  SASS_STYLE_TO_SASS,
   SASS_STYLE_TO_CSS
 };
 

src/MurmurHash2.cpp

@@ -10,7 +10,7 @@
 
 namespace Sass {
 
-  // static Null sass_null(SourceSpan::fake("null"));
+  // static Null sass_null(SourceSpan("null"));
 
   uint8_t sass_op_to_precedence(enum Sass_OP op) {
     switch (op) {
@@ -137,15 +137,14 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Statement::Statement(const SourceSpan& pstate, size_t t)
-  : AST_Node(pstate), tabs_(t), group_end_(false)
+  : AST_Node(pstate), tabs_(t)
   { }
   Statement::Statement(SourceSpan&& pstate, size_t t)
-    : AST_Node(std::move(pstate)), tabs_(t), group_end_(false)
+    : AST_Node(std::move(pstate)), tabs_(t)
   { }
   Statement::Statement(const Statement* ptr)
   : AST_Node(ptr),
-    tabs_(ptr->tabs_),
-    group_end_(ptr->group_end_)
+    tabs_(ptr->tabs_)
   { }
 
   bool Statement::bubbles() const
@@ -168,19 +167,19 @@ namespace Sass {
 
   Block::Block(const SourceSpan& pstate, size_t s, bool r)
   : Statement(pstate),
-    Vectorized<Statement>(s),
+    VectorizedBase<Statement>(s),
     idxs_(0), is_root_(r)
   { }
 
   Block::Block(const SourceSpan& pstate, const sass::vector<StatementObj>& vec, bool r) :
     Statement(pstate),
-    Vectorized<Statement>(vec),
+    VectorizedBase<Statement>(vec),
     idxs_(0), is_root_(r)
   { }
 
   Block::Block(const SourceSpan& pstate, sass::vector<StatementObj>&& vec, bool r) :
     Statement(pstate),
-    Vectorized<Statement>(std::move(vec)),
+    VectorizedBase<Statement>(std::move(vec)),
     idxs_(0), is_root_(r)
   { }
 
@@ -250,7 +249,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Bubble::Bubble(const SourceSpan& pstate, Statement_Obj n, Statement_Obj g, size_t t)
-  : Statement(pstate, t), node_(n), group_end_(g == nullptr)
+  : Statement(pstate, t), node_(n)
   { }
 
   bool Bubble::bubbles() const
@@ -363,7 +362,7 @@ namespace Sass {
   ImportRule::ImportRule(
     const SourceSpan& pstate) :
     Statement(pstate),
-    Vectorized()
+    VectorizedBase()
   {}
 
   /////////////////////////////////////////////////////////////////////////
@@ -499,24 +498,43 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Expression::Expression(const SourceSpan& pstate, bool d, bool e, bool i, Type ct)
-  : SassNode(pstate),
-    concrete_type_(ct)
+  Interpolant::Interpolant(const SourceSpan& pstate)
+    : AST_Node(pstate)
   { }
 
-  Expression::Expression(SourceSpan&& pstate, bool d, bool e, bool i, Type ct)
-    : SassNode(std::move(pstate)),
-    concrete_type_(ct)
+  bool Interpolant::operator==(const Interpolant & rhs) const
+  {
+    if (const Expression* ex = Cast<Expression>(&rhs)) {
+      return *this == *ex;
+    }
+    else if (const ItplString* str = Cast<ItplString>(&rhs)) {
+      return *this == *str;
+    }
+    return false;
+  }
+
+  Interpolant::Interpolant(SourceSpan&& pstate)
+    : AST_Node(std::move(pstate))
   { }
 
-  Expression::Expression(const Expression* ptr)
-  : SassNode(ptr),
-    concrete_type_(ptr->concrete_type_)
+  Interpolant::Interpolant(const Interpolant* ptr)
+    : AST_Node(ptr)
   { }
 
-  SassNode::SassNode(const SassNode* ptr) :
-    AST_Node(ptr)
-  {};
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  Expression::Expression(const SourceSpan& pstate, bool d, bool e, bool i)
+  : Interpolant(pstate)
+  { }
+
+  Expression::Expression(SourceSpan&& pstate, bool d, bool e, bool i)
+    : Interpolant(std::move(pstate))
+  { }
+
+  Expression::Expression(const Expression* ptr)
+  : Interpolant(ptr)
+  { }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
@@ -552,14 +570,6 @@ namespace Sass {
   {
   }
 
-  size_t Argument::hash() const
-  {
-    if (hash_ == 0) {
-      hash_start(hash_, name().hash());
-      hash_combine(hash_, value()->hash());
-    }
-    return hash_;
-  }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
@@ -604,15 +614,9 @@ namespace Sass {
   }
 
   // Returns whether [this] excludes [node].
-  bool AtRootQuery::excludes(Statement* node) const
+  bool AtRootQuery::excludes(CssParentNode* node) const
   {
     if (all()) return !include();
-    if (!Cast<CssMediaRule>(node)) {
-      if (!Cast<CssParentNode>(node)) {
-        std::cerr << "has non CssParentNode\n";
-        debug_ast(node);
-      }
-    }
     if (rule() && Cast<CssStyleRule>(node)) return !include();
     return excludesName(_nameFor(node));
   }
@@ -726,7 +730,7 @@ namespace Sass {
     const EnvKeyFlatMap<ExpressionObj>& named,
     Expression* restArg,
     Expression* kwdRest) :
-    SassNode(pstate),
+    AST_Node(pstate),
     positional_(positional),
     named_(named),
     restArg_(restArg),
@@ -775,7 +779,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  ArgumentResults2::ArgumentResults2(
+  ArgumentResults::ArgumentResults(
     const sass::vector<ValueObj>& positional,
     const EnvKeyFlatMap<ValueObj>& named,
     Sass_Separator separator) :
@@ -785,8 +789,8 @@ namespace Sass {
   {
   }
 
-  ArgumentResults2::ArgumentResults2(
-    sass::vector<ValueObj> && positional,
+  ArgumentResults::ArgumentResults(
+    sass::vector<ValueObj>&& positional,
     EnvKeyFlatMap<ValueObj>&& named,
     Sass_Separator separator) :
     positional_(std::move(positional)),
@@ -795,23 +799,23 @@ namespace Sass {
   {
   }
 
-  ArgumentResults2::ArgumentResults2(
-    const ArgumentResults2& other) :
+  ArgumentResults::ArgumentResults(
+    const ArgumentResults& other) :
     positional_(other.positional_),
     named_(other.named_),
     separator_(other.separator_)
   {
   }
 
-  ArgumentResults2::ArgumentResults2(
-    ArgumentResults2&& other) noexcept :
+  ArgumentResults::ArgumentResults(
+    ArgumentResults&& other) noexcept :
     positional_(std::move(other.positional_)),
     named_(std::move(other.named_)),
     separator_(other.separator_)
   {
   }
 
-  ArgumentResults2& ArgumentResults2::operator=(ArgumentResults2&& other) noexcept {
+  ArgumentResults& ArgumentResults::operator=(ArgumentResults&& other) noexcept {
     positional_ = std::move(other.positional_);
     named_ = std::move(other.named_);
     separator_ = other.separator_;
@@ -822,7 +826,7 @@ namespace Sass {
     const SourceSpan& pstate,
     const sass::vector<ArgumentObj>& arguments,
     const sass::string& restArg) :
-    SassNode(pstate),
+    AST_Node(pstate),
     arguments_(arguments),
     restArg_(restArg)
   {
@@ -860,8 +864,8 @@ namespace Sass {
     while (i < std::min(positional, iL)) {
       if (names.count(arguments_[i]->name()) == 1) {
         throw Exception::InvalidSyntax(arguments_[i]->pstate(), traces,
-          "Argument " + arguments_[i]->name().orig() + " name was passed both by position and by "
-          "name.");
+          "Argument " + arguments_[i]->name().orig() +
+          " name was passed both by position and by name.");
       }
       i++;
     }
@@ -899,7 +903,7 @@ namespace Sass {
       // sass::sstream strm;
       // strm << "No " << pluralize("argument", unknownNames.size());
       // strm << " named " << toSentence(unknownNames, "or");
-      throw Exception::InvalidSyntax(SourceSpan::fake("[pstate77]"), traces,
+      throw Exception::InvalidSyntax(SourceSpan("[pstate77]"), traces,
         "No argument named " + toSentence(unknownNames, "or") + ".");
     }
 
@@ -929,15 +933,6 @@ namespace Sass {
     return true;
   }
 
-  sass::string ArgumentDeclaration::toString2() const
-  {
-    sass::vector<sass::string> results;
-    for (Argument* argument : arguments_) { // XXXXXXXXXXXYYYYYYY
-      results.emplace_back(argument->name().orig());
-    }
-    return Util::join_strings(results, ", ");
-  }
-
   CallableDeclaration::CallableDeclaration(
     const SourceSpan& pstate,
     const EnvKey& name,
@@ -1051,7 +1046,7 @@ namespace Sass {
     const sass::string& name,
     ArgumentDeclaration* parameters,
     Sass_Function_Entry function) :
-    Callable(SourceSpan::fake("[external]")),
+    Callable(SourceSpan("[external]")),
     name_(name),
     declaration_(parameters),
     function_(function)