shallow clone issue

[HungMingWu]

Hi Mike,
I have one request like this

class ExpandRewriter : public SyntaxRewriter<ExpandRewriter> {
	// Ignore
	SyntaxList<MemberSyntax> members;
	for (int i = 0; i < 5; i++)
	{
		for (auto &m : members)
		{
			auto newMemberSyntax = m->clone(alloc);
			newMemberSyntax->visit(visitor);
			insertAfter(decl, *newMemberSyntax);
		}
	}
}

I hope the result similar to

reg tmp1;
reg tmp2;
reg tmp3;
reg tmp4;
reg tmp5;

But it is hard to archive due to shallow clone.
So I write my own visitor similar this

struct MyVisitor {
	static inline size_t i = 0;
	template <typename T>
	void visit(T& node) {
		...
	}
	void handle(DeclaratorSyntax& decl) {
        decl.name = decl.name.withRawText(alloc, "tmp" + std::to_string(i++));
	}
};

It output

reg tmp5;
reg tmp5;
reg tmp5;
reg tmp5;
reg tmp5;

Have any plan to support deep clone?
Or an alternative method to archive this?
Thanks for your help.

[MikePopoloski]

Sorry, I missed this question the other day. I think the clone() method is only used for the syntax rewriting functionality right now -- do you think it makes sense to have it always do a deep clone? I don't think I'd be against that.

[HungMingWu]

I tried to simulate inline functionality on syntax rewrite.
The verilog code seems

module top(...);
sub sub1 (....);
sub sub2 (...);
endmodule
module sub(...);
reg tmp;
assign tmp = .....;
endmodule

I assume the expected output should be

module top(...);
reg sub1_tmp;
assign sub1_tmp = ....;
reg sub2_tmp;
assign sub2_tmp = ....;
endmodule

My current work flow is

1. collect MemberSyntax on sub
2. on top module, iterate each item in MemberSyntax
3. Clone it
4. Transform it
5. Insert after the node (that's why I extends multiple insertions on SyntaxRewriter)
   It is all right without deep clone, can you give me some hints how to archive it.

[MikePopoloski]

Your workflow sounds right to me. After cloning you can find the name token for each syntax element and replace it with a new token that has the correct name for the inlined element.

[HungMingWu]

The workflow is right, but the clone step is wrong due to shallow clone.
Modify it would affect the other expression, like described above.
I try another method to avoid it, but it doesn't take effect. It is a fail attempt.

    void handle(...) {
       MemberSyntax *ptr =....;
       std::string  str = ptr->toString();
       // Modify str if needed
       auto& newNode = parse(str);
       insertAfter(decl, newNode);
    }

[MikePopoloski]

I can work on an example for this inlining goal and see how it goes.

[HungMingWu]

I made an naive implementation on https://github.com/HungMingWu/slang/tree/deepClone
My test case is

TEST_CASE("Clone and DeepClone") {
    auto tree = SyntaxTree::fromText(R"(
module m;
    reg tmp;
endmodule
)");
    SECTION("Shallow Clone") {
        class CloneRewriter : public SyntaxRewriter<CloneRewriter> {
        public:
            Compilation compilation;
            SemanticModel model;

            CloneRewriter(const std::shared_ptr<SyntaxTree>& tree) : model(compilation) {
                compilation.addSyntaxTree(tree);
            }

            void handle(const slang::DataDeclarationSyntax& syntax) {
                {
                    auto cloned_ptr = syntax.clone(alloc);
                    cloned_ptr->declarators[0]->name =
                        cloned_ptr->declarators[0]->name.withRawText(alloc, "tmp1");
                    insertAfter(syntax, *cloned_ptr);
                }
                {
                    auto cloned_ptr = syntax.clone(alloc);
                    cloned_ptr->declarators[0]->name =
                        cloned_ptr->declarators[0]->name.withRawText(alloc, "tmp2");
                    insertAfter(syntax, *cloned_ptr);
                }
                {
                    auto cloned_ptr = syntax.clone(alloc);
                    cloned_ptr->declarators[0]->name =
                        cloned_ptr->declarators[0]->name.withRawText(alloc, "tmp3");
                    insertAfter(syntax, *cloned_ptr);
                }
            }
        };
        tree = CloneRewriter(tree).transform(tree);
        CHECK(SyntaxPrinter::printFile(*tree) == R"(
module m;
    reg tmp3;
    reg tmp3;
    reg tmp3;
    reg tmp3;
endmodule
)");
    }
    SECTION("Deep Clone") {
        class CloneRewriter : public SyntaxRewriter<CloneRewriter> {
        public:
            Compilation compilation;
            SemanticModel model;

            CloneRewriter(const std::shared_ptr<SyntaxTree>& tree) : model(compilation) {
                compilation.addSyntaxTree(tree);
            }

            void handle(const slang::DataDeclarationSyntax& syntax) {
                {
                    auto cloned_ptr = syntax.deepClone(alloc);
                    cloned_ptr->declarators[0]->name =
                        cloned_ptr->declarators[0]->name.withRawText(alloc, "tmp1");
                    insertAfter(syntax, *cloned_ptr);
                }
                {
                    auto cloned_ptr = syntax.deepClone(alloc);
                    cloned_ptr->declarators[0]->name =
                        cloned_ptr->declarators[0]->name.withRawText(alloc, "tmp2");
                    insertAfter(syntax, *cloned_ptr);
                }
                {
                    auto cloned_ptr = syntax.deepClone(alloc);
                    cloned_ptr->declarators[0]->name =
                        cloned_ptr->declarators[0]->name.withRawText(alloc, "tmp3");
                    insertAfter(syntax, *cloned_ptr);
                }
            }
        };
        tree = CloneRewriter(tree).transform(tree);
        CHECK(SyntaxPrinter::printFile(*tree) == R"(
module m;
    reg tmp;
    reg tmp1;
    reg tmp2;
    reg tmp3;
endmodule
)");
    }

I need some suggestion.

• Must append deepClone on SyntaxNode since I met the following code

struct DefaultCaseItemSyntax : public CaseItemSyntax {
    Token defaultKeyword;
    Token colon;
    not_null<SyntaxNode*> clause;
};

• Must append extra deepClone since the SyntaxNode::deepClone lose type information

struct ExpressionSyntax : public SyntaxNode {
    ExpressionSyntax* deepClone(BumpAllocator& alloc) const;
};

If we remove the declaration,
The implementation from

EqualsValueClauseSyntax* EqualsValueClauseSyntax::deepClone(BumpAllocator& alloc) const {
    return alloc.emplace<EqualsValueClauseSyntax>(
        equals,
        *expr->deepClone(alloc)
    );
}

to

EqualsValueClauseSyntax* EqualsValueClauseSyntax::deepClone(BumpAllocator& alloc) const {
    return alloc.emplace<EqualsValueClauseSyntax>(
        equals,
        *static_cast<ExpressionSyntax*>(expr->deepClone(alloc))
    );
}