non-RTTI dynamic cast (souffle-lang#2452)

Dynamic cast have a significant performance impact on Souffle AST/RAM
pipelines.

* non-RTTI dynamic cast for the ast::Node hierarchy
* non-RTTI dynamic cast for the ast::analysis::Type hierarchy
* non-RTTI dynamic cast for the ram::Node hierarchy

src/ast/Aggregator.h

@@ -42,8 +42,7 @@ namespace souffle::ast {
  */
 class Aggregator : public Argument {
 public:
-
-    Aggregator(NodeKind kind, Own<Argument> expr = {}, Own<Argument> second = {}, VecOwn<Literal> body = {},
+    Aggregator(NodeKind Kind, Own<Argument> expr = {}, Own<Argument> second = {}, VecOwn<Literal> body = {},
             VecOwn<OrderByElement> orderby = {}, SrcLocation loc = {});
 
     /** Return target expression */
@@ -72,6 +71,8 @@ class Aggregator : public Argument {
 
     const VecOwn<OrderByElement>& getOrderByElements() const;
 
+    static bool classof(const Node*);
+
 protected:
     NodeVec getChildren() const override;
 

src/ast/IntrinsicAggregator.cpp

@@ -19,7 +19,8 @@
 namespace souffle::ast {
 IntrinsicAggregator::IntrinsicAggregator(AggregateOp baseOperator, Own<Argument> expr, Own<Argument> second,
         VecOwn<Literal> body, VecOwn<OrderByElement> orderby, SrcLocation loc)
-        : Aggregator(NK_IntrinsicAggregator, std::move(expr), std::move(second), std::move(body), std::move(orderby), std::move(loc)),
+        : Aggregator(NK_IntrinsicAggregator, std::move(expr), std::move(second), std::move(body),
+                  std::move(orderby), std::move(loc)),
           baseOperator(baseOperator) {}
 
 void IntrinsicAggregator::print(std::ostream& os) const {

src/ram/Aggregate.h

@@ -83,7 +83,7 @@ class Aggregate : public RelationOperation, public AbstractAggregate {
     Aggregate(NodeKind kind, Own<Operation> nested, Own<Aggregator> fun, std::string rel,
             Own<Expression> expression, Own<Expression> second, Own<Condition> condition, VecOwn<Expression> orderBy, std::size_t ident)
             : RelationOperation(kind, rel, ident, std::move(nested)),
-              AbstractAggregate(std::move(fun), std::move(expression), std::move(condition), std::move(condition), std::move(orderBy)) {
+              AbstractAggregate(std::move(fun), std::move(expression), std::move(second), std::move(condition), std::move(orderBy)) {
         assert(kind >= NK_Aggregate && kind < NK_LastAggregate);
     }
 

src/ram/IndexAggregate.h

@@ -60,6 +60,7 @@ class IndexAggregate : public IndexOperation, public AbstractAggregate {
         }
         return new IndexAggregate(NK_IndexAggregate, clone(getOperation()), clone(function), relation,
                 clone(expression), clone(second), clone(condition), clone(orderBy), std::move(pattern), getTupleId());
+                getTupleId());
     }
 
     void apply(const NodeMapper& map) override {