[DO NOT MERGE] Implement SigsRewriterPrism

[KaanOzkan]

Extracted from #681

Equivalent file using whitequark AST https://github.com/sorbet/sorbet/blob/master/rbs/SigsRewriter.cc

[allcre]

some methods take const parser::Prism::Parser &prismParser as an argument and others take parser::Prism::Parser &parser, maybe these should be consistent?

[KaanOzkan]

I think we should use const whenever we can. There was one function that could take const but wasn't, it's now updated.

[allcre]

I think statements is used as a variable name a lot more than stmts in this file

[KaanOzkan]

There's a lot of both names. Since statements is long we'd have to break the lines in some cases. So I went with using stmts for short lived variables that are easy to understand. But for cases like this one it's migrated to statements. I think this is better than doing only stmts or only statements.

[allcre]

Does using unordered maps vs ordered maps affect performance

[KaanOzkan]

Yes, std::map will have to keep itself ordered so it's implemented as a tree (Red black tree probably). Meanwhile unordered_map can be a simple hash table. Looks ups are going to be more performant, O(log n) vs O(1)

[amomchilov]

Working my way through it, here's the first batch of comments

[amomchilov]

The linter doesn't strictly require it, but try to use uniform initialization sytnax whenever you can

Suggested change

	Factory prism(parser);
	Factory prism{parser};

[amomchilov]

Done for now

[amomchilov]

Both of these can be inverted into early-returning guard clauses

[amomchilov]

This pattern comes up a lot. Can you add an overload of rewriteBody that takes and returns pm_statements_node_t *?

[amomchilov]

one more thing

[amomchilov]

Suggested change

	// Save old statements before modifying (pm_node_list_append can realloc, invalidating pointers)
	pm_node_list_t oldStmts = statements->body;
	statements->body = (pm_node_list_t){.size = 0, .capacity = 0, .nodes = nullptr};
	// For each statement, insert signatures before it if it's a signature target
	for (size_t i = 0; i < oldStmts.size; i++) {
	pm_node_t *stmt = oldStmts.nodes[i];
	if (canHaveSignature(stmt, parser)) {
	if (auto signatures = signaturesForNode(stmt)) {
	// Add all signatures
	for (auto sig : *signatures) {
	pm_node_list_append(&statements->body, sig);
	}
	}
	}
	// Add the rewritten statement
	pm_node_list_append(&statements->body, rewriteNode(stmt));
	}
	// Free the old list structure (not the nodes themselves, as they were moved)
	free(oldStmts.nodes);
	return node;
	return rewriteBody(statements)

[amomchilov]

I suggest inverting this. Make rewriteBody(pm_node_t *node) call rewriteBody(pm_statements_node_t *stmts). It's more "direct", and you don't need the up/down cast

Suggested change

	pm_statements_node_t *SigsRewriterPrism::rewriteBody(pm_statements_node_t *stmts) {
	return down_cast<pm_statements_node_t>(rewriteBody(up_cast(stmts)));
	pm_statements_node_t *SigsRewriterPrism::rewriteBody(pm_statements_node_t *statements) {
	// Save old statements before modifying (pm_node_list_append can realloc, invalidating pointers)
	pm_node_list_t oldStmts = statements->body;
	statements->body = (pm_node_list_t){.size = 0, .capacity = 0, .nodes = nullptr};
	// For each statement, insert signatures before it if it's a signature target
	for (size_t i = 0; i < oldStmts.size; i++) {
	pm_node_t *stmt = oldStmts.nodes[i];
	if (canHaveSignature(stmt, parser)) {
	if (auto signatures = signaturesForNode(stmt)) {
	// Add all signatures
	for (auto sig : *signatures) {
	pm_node_list_append(&statements->body, sig);
	}
	}
	}
	// Add the rewritten statement
	pm_node_list_append(&statements->body, rewriteNode(stmt));
	}
	// Free the old list structure (not the nodes themselves, as they were moved)
	free(oldStmts.nodes);
	return statements;