Many improvements to ASTVisitor and supporting types

tdp2110 · Mar 21, 2020 · 3957da7 · 3957da7
1 parent 237eab5
commit 3957da7
Show file tree

Hide file tree

Showing 13 changed files with 305 additions and 28 deletions.
diff --git a/include/slang/binding/AssignmentExpressions.h b/include/slang/binding/AssignmentExpressions.h
@@ -46,6 +46,12 @@ class AssignmentExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::Assignment; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        left().visit(visitor);
+        right().visit(visitor);
+    }
+
 private:
     Expression* left_;
     Expression* right_;
@@ -81,6 +87,11 @@ class ConversionExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::Conversion; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        operand().visit(visitor);
+    }
+
 private:
     Expression* operand_;
 };

diff --git a/include/slang/binding/Expression.h b/include/slang/binding/Expression.h
@@ -214,10 +214,10 @@ class Expression {
     }
 
     template<typename TVisitor, typename... Args>
-    decltype(auto) visit(TVisitor& visitor, Args&&... args);
+    decltype(auto) visit(TVisitor&& visitor, Args&&... args);
 
     template<typename TVisitor, typename... Args>
-    decltype(auto) visit(TVisitor& visitor, Args&&... args) const;
+    decltype(auto) visit(TVisitor&& visitor, Args&&... args) const;
 
 protected:
     Expression(ExpressionKind kind, const Type& type, SourceRange sourceRange) :
@@ -272,7 +272,7 @@ class Expression {
     struct PropagationVisitor;
 
     template<typename TExpression, typename TVisitor, typename... Args>
-    decltype(auto) visitExpression(TExpression* expr, TVisitor& visitor, Args&&... args) const;
+    decltype(auto) visitExpression(TExpression* expr, TVisitor&& visitor, Args&&... args) const;
 };
 
 /// Represents an invalid expression, which is usually generated and inserted

diff --git a/include/slang/binding/MiscExpressions.h b/include/slang/binding/MiscExpressions.h
@@ -65,6 +65,12 @@ class ElementSelectExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::ElementSelect; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        value().visit(visitor);
+        selector().visit(visitor);
+    }
+
 private:
     Expression* value_;
     Expression* selector_;
@@ -104,6 +110,13 @@ class RangeSelectExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::RangeSelect; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        value().visit(visitor);
+        left().visit(visitor);
+        right().visit(visitor);
+    }
+
 private:
     static ConstantRange getIndexedRange(RangeSelectionKind kind, int32_t l, int32_t r,
                                          bool littleEndian);
@@ -197,6 +210,12 @@ class CallExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::Call; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        for (auto arg : arguments())
+            arg->visit(visitor);
+    }
+
 private:
     static Expression& createSystemCall(Compilation& compilation,
                                         const SystemSubroutine& subroutine,

diff --git a/include/slang/binding/OperatorExpressions.h b/include/slang/binding/OperatorExpressions.h
@@ -42,6 +42,11 @@ class UnaryExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::UnaryOp; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        operand().visit(visitor);
+    }
+
 private:
     Expression* operand_;
 };
@@ -75,6 +80,12 @@ class BinaryExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::BinaryOp; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        left().visit(visitor);
+        right().visit(visitor);
+    }
+
 private:
     Expression* left_;
     Expression* right_;
@@ -111,6 +122,13 @@ class ConditionalExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::ConditionalOp; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        pred().visit(visitor);
+        left().visit(visitor);
+        right().visit(visitor);
+    }
+
 private:
     Expression* pred_;
     Expression* left_;
@@ -141,6 +159,13 @@ class InsideExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::Inside; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        left().visit(visitor);
+        for (auto range : rangeList())
+            range->visit(visitor);
+    }
+
 private:
     const Expression* left_;
     span<const Expression* const> rangeList_;
@@ -170,6 +195,12 @@ class ConcatenationExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::Concatenation; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        for (auto op : operands())
+            op->visit(visitor);
+    }
+
 private:
     span<const Expression* const> operands_;
 };
@@ -200,6 +231,12 @@ class ReplicationExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::Replication; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        count().visit(visitor);
+        concat().visit(visitor);
+    }
+
 private:
     const Expression* count_;
     Expression* concat_;
@@ -236,6 +273,12 @@ class OpenRangeExpression : public Expression {
 
     static bool isKind(ExpressionKind kind) { return kind == ExpressionKind::OpenRange; }
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        left().visit(visitor);
+        right().visit(visitor);
+    }
+
 private:
     Expression* left_;
     Expression* right_;

diff --git a/include/slang/binding/PatternExpressions.h b/include/slang/binding/PatternExpressions.h
@@ -20,6 +20,12 @@ class AssignmentPatternExpressionBase : public Expression {
 
     void serializeTo(ASTSerializer& serializer) const;
 
+    template<typename TVisitor>
+    void visitExprs(TVisitor&& visitor) const {
+        for (auto elem : elements())
+            elem->visit(visitor);
+    }
+
 protected:
     AssignmentPatternExpressionBase(ExpressionKind kind, const Type& type,
                                     span<const Expression* const> elements,