s/dsl/rewriter/ (sorbet#2064)

* mv dsl rewriter

* mv ./test/testdata/dsl ./test/testdata/rewriter

* mv rewriter/dsl.h rewriter/rewriter.h

* mv rewriter/dsl.cc rewriter/rewriter.cc

* mv core/errors/dsl.h core/errors/rewriter.h

* replace "dsl {" "rewriter {"

* replace "dsl/" "rewriter/"

* replace "//dsl" "//rewriter"

* replace " = "dsl"" " = "rewriter""

* replace "DSLSynthesized" "RewriterSynthesized"

* replace ""dsl"sv" ""rewriter"sv"

* replace "dsl::" "rewriter::"

* replace ""dsl-tree"" ""rewrite-tree""

* replace "skip-dsl-pass" "skip-rewriter-pass"

* replace "sorbet::dsl" "sorbet::rewriter"

* replace ""dsl-tree-raw"" ""rewrite-tree-raw""

* replace "dsl.h" "rewriter.h"

* replace "Phase::DSL" "Phase::REWRITER"

* replace ""dsl"" ""rewriter""

* replace "DSLTree" "RewriterTree"

* replace "SORBET_DSL" "SORBET_REWRITER"

* replace "errors::DSL" "errors::rewriter"

* replace "class DSL final" "class Rewriter final"

* replace "class DSL;" "class Rewriter;"

* replace "DSL::run" "Rewriter::run"

* replace "DSL_SYNTHESIZED" "REWRITER_SYNTHESIZED"

* replace "skipDSLPasses" "skipRewriterPasses"

* replace "SRUBY_DSL" "SORBET_REWRITER"

* replace "DSL()" "Rewriter()"

* replace "DSL pass" "Rewriter pass"

* replace "DSL," "REWRITER,"

* replace "runDSL" "runRewriter"

* replace "DSL synthesized" "Rewriter synthesized"

* replace "replaceDSL" "run"

* replace "patchDSL" "run"

* replace "handleNamerDSL" "handleNamerRewriter"

* replace "// DSL" "// Rewriter"

* replace "dslsInlined" "rewriten"

* replace "rewriter/dsl.cc" "rewriter/rewriter.cc"

* replace "dsl pass" "Rewriter pass"

* replace "dsl-tree" "rewrite-tree"

* replace "#dsl" "#rewriter"

* replace "\[DSL\]" "[Rewriter]"

* replace " dsl  " " rewriter  "

* replace "dsl.cc" "rewriter.cc"

* replace "flags = dsl" "flags = rewriter"

* replace "//rewriter:dsl" "//rewriter"

* replace " DSL =" " rewriten ="

* replace "(DSL)" "(rewriten)"

* replace "!DSL)" "!rewriten)"

* replace "## DSL" "## Rewriter"

* replace "cache-rewriter" "cache-dsl"

* replace "\[dsl\]" "\[rewriter]"

* replace "dslUnwound" "rewriten"

* replace "DSLReplacer" "Rewriterer"

* replace "dslReplacer" "rewriter"

* record

* format

* tools/scripts/generate_compdb_targets.sh

* for i in `find . -name "*.dsl-tree-raw*"`; do mv $i ${i%dsl-tree-raw.exp}rewrite-tree-raw.exp; done

* for i in `find . -name "*.dsl-tree*"`; do mv $i ${i%dsl-tree.exp}rewrite-tree.exp; done

* record

Author: ptarjan

ast/Helpers.cc

@@ -40,9 +40,9 @@ bool definesBehavior(const unique_ptr<ast::Expression> &expr) {
                      definesBehavior(seq->expr);
         },
 
-        // Ignore code synthesized by DSL pass.
-        [&](ast::Send *send) { result = !send->isDSLSynthesized(); },
-        [&](ast::MethodDef *methodDef) { result = !methodDef->isDSLSynthesized(); },
+        // Ignore code synthesized by Rewriter pass.
+        [&](ast::Send *send) { result = !send->isRewriterSynthesized(); },
+        [&](ast::MethodDef *methodDef) { result = !methodDef->isRewriterSynthesized(); },
 
         [&](ast::Expression *klass) { result = true; });
     return result;

ast/Helpers.h

@@ -296,7 +296,7 @@ class MK {
         auto sig = Send0(loc, Constant(loc, core::Symbols::T_Sig_WithoutRuntime()), core::Names::sig());
         auto sigSend = ast::cast_tree<ast::Send>(sig.get());
         sigSend->block = Block0(loc, std::move(returns));
-        sigSend->flags |= ast::Send::DSL_SYNTHESIZED;
+        sigSend->flags |= ast::Send::REWRITER_SYNTHESIZED;
         return sig;
     }
 
@@ -306,7 +306,7 @@ class MK {
         auto sig = Send0(loc, Constant(loc, core::Symbols::T_Sig_WithoutRuntime()), core::Names::sig());
         auto sigSend = ast::cast_tree<ast::Send>(sig.get());
         sigSend->block = Block0(loc, std::move(void_));
-        sigSend->flags |= ast::Send::DSL_SYNTHESIZED;
+        sigSend->flags |= ast::Send::REWRITER_SYNTHESIZED;
         return sig;
     }
 
@@ -315,7 +315,7 @@ class MK {
         auto sig = Send0(loc, Constant(loc, core::Symbols::T_Sig_WithoutRuntime()), core::Names::sig());
         auto sigSend = ast::cast_tree<ast::Send>(sig.get());
         sigSend->block = Block0(loc, std::move(returns));
-        sigSend->flags |= ast::Send::DSL_SYNTHESIZED;
+        sigSend->flags |= ast::Send::REWRITER_SYNTHESIZED;
         return sig;
     }
 

ast/Trees.cc

@@ -453,7 +453,7 @@ string MethodDef::showRaw(const core::GlobalState &gs, int tabs) {
     buf << "flags =";
     const pair<int, string_view> flags[] = {
         {SelfMethod, "self"sv},
-        {DSLSynthesized, "dsl"sv},
+        {RewriterSynthesized, "rewriter"sv},
     };
     for (auto &ent : flags) {
         if ((this->flags & ent.first) != 0) {

ast/Trees.h

@@ -149,7 +149,7 @@ class MethodDef final : public Declaration {
 
     enum Flags {
         SelfMethod = 1,
-        DSLSynthesized = 2,
+        RewriterSynthesized = 2,
     };
 
     MethodDef(core::Loc loc, core::Loc declLoc, core::SymbolRef symbol, core::NameRef name, ARGS_store args,
@@ -163,8 +163,8 @@ class MethodDef final : public Declaration {
         return (flags & SelfMethod) != 0;
     }
 
-    bool isDSLSynthesized() const {
-        return (flags & DSLSynthesized) != 0;
+    bool isRewriterSynthesized() const {
+        return (flags & RewriterSynthesized) != 0;
     }
 
 private:
@@ -461,7 +461,7 @@ class Send final : public Expression {
     core::NameRef fun;
 
     static const int PRIVATE_OK = 1 << 0;
-    static const int DSL_SYNTHESIZED = 1 << 1;
+    static const int REWRITER_SYNTHESIZED = 1 << 1;
     u4 flags;
 
     std::unique_ptr<Expression> recv;
@@ -478,8 +478,8 @@ class Send final : public Expression {
     virtual std::string nodeName();
     virtual std::unique_ptr<Expression> _deepCopy(const Expression *avoid, bool root = false) const;
 
-    bool isDSLSynthesized() const {
-        return (flags & DSL_SYNTHESIZED) != 0;
+    bool isRewriterSynthesized() const {
+        return (flags & REWRITER_SYNTHESIZED) != 0;
     }
 
     bool isPrivateOk() const {

core/GlobalState.h

@@ -169,7 +169,7 @@ class GlobalState final {
     bool ensureCleanStrings = false;
 
     // So we can know whether we're running in autogen mode.
-    // Right now this is only used to turn certain DSL passes on or off.
+    // Right now this is only used to turn certain Rewriter passes on or off.
     // Think very hard before looking at this value in namer / resolver!
     // (hint: probably you want to find an alternate solution)
     bool runningUnderAutogen = false;

core/Symbols.h

@@ -64,8 +64,8 @@ class Symbol final {
 
         // --- Applies to all types of Symbols ---
 
-        // Synthesized by C++ code in a DSL pass
-        static constexpr u4 DSL_SYNTHESIZED = 0x0000'0001;
+        // Synthesized by C++ code in a Rewriter pass
+        static constexpr u4 REWRITER_SYNTHESIZED = 0x0000'0001;
 
         // --- For our current symbol type, what flags does it have?
 
@@ -479,11 +479,11 @@ class Symbol final {
         return isStaticField() && (flags & Symbol::Flags::STATIC_FIELD_TYPE_ALIAS) != 0;
     }
 
-    inline void setDSLSynthesized() {
-        flags |= Symbol::Flags::DSL_SYNTHESIZED;
+    inline void setRewriterSynthesized() {
+        flags |= Symbol::Flags::REWRITER_SYNTHESIZED;
     }
-    inline bool isDSLSynthesized() const {
-        return (flags & Symbol::Flags::DSL_SYNTHESIZED) != 0;
+    inline bool isRewriterSynthesized() const {
+        return (flags & Symbol::Flags::REWRITER_SYNTHESIZED) != 0;
     }
 
     SymbolRef findMember(const GlobalState &gs, NameRef name) const;

core/errors/dsl.h core/errors/rewriter.h

@@ -2,13 +2,13 @@
 #define SORBET_CORE_ERRORS_DSL_H
 #include "core/Error.h"
 
-namespace sorbet::core::errors::DSL {
+namespace sorbet::core::errors::rewriter {
 constexpr ErrorClass BadAttrArg{3501, StrictLevel::True};
 constexpr ErrorClass BadWrapInstance{3502, StrictLevel::True};
 constexpr ErrorClass PrivateMethodMismatch{3503, StrictLevel::False};
 constexpr ErrorClass BadAttrType{3504, StrictLevel::True};
 constexpr ErrorClass BadModuleFunction{3505, StrictLevel::True};
 constexpr ErrorClass OpusEnumOutsideEnumsDo{3506, StrictLevel::False};
 constexpr ErrorClass OpusEnumConstNotEnumValue{3506, StrictLevel::False};
-} // namespace sorbet::core::errors::DSL
+} // namespace sorbet::core::errors::rewriter
 #endif

definition_validator/validator.cc

@@ -314,23 +314,23 @@ void validateOverriding(const core::Context ctx, core::SymbolRef method) {
         auto isRBI = absl::c_any_of(method.data(ctx)->locs(), [&](auto &loc) { return loc.file().data(ctx).isRBI(); });
         if (!method.data(ctx)->isOverride() && method.data(ctx)->hasSig() &&
             overridenMethod.data(ctx)->isOverridable() && !anyIsInterface && overridenMethod.data(ctx)->hasSig() &&
-            !method.data(ctx)->isDSLSynthesized() && !isRBI) {
+            !method.data(ctx)->isRewriterSynthesized() && !isRBI) {
             if (auto e = ctx.state.beginError(method.data(ctx)->loc(), core::errors::Resolver::UndeclaredOverride)) {
                 e.setHeader("Method `{}` overrides an overridable method `{}` but is not declared with `{}`",
                             method.data(ctx)->show(ctx), overridenMethod.data(ctx)->show(ctx), "override.");
                 e.addErrorLine(overridenMethod.data(ctx)->loc(), "defined here");
             }
         }
         if (!method.data(ctx)->isOverride() && method.data(ctx)->hasSig() && overridenMethod.data(ctx)->isAbstract() &&
-            overridenMethod.data(ctx)->hasSig() && !method.data(ctx)->isDSLSynthesized() && !isRBI) {
+            overridenMethod.data(ctx)->hasSig() && !method.data(ctx)->isRewriterSynthesized() && !isRBI) {
             if (auto e = ctx.state.beginError(method.data(ctx)->loc(), core::errors::Resolver::UndeclaredOverride)) {
                 e.setHeader("Method `{}` implements an abstract method `{}` but is not declared with `{}`",
                             method.data(ctx)->show(ctx), overridenMethod.data(ctx)->show(ctx), "override.");
                 e.addErrorLine(overridenMethod.data(ctx)->loc(), "defined here");
             }
         }
         if ((overridenMethod.data(ctx)->isAbstract() || overridenMethod.data(ctx)->isOverridable()) &&
-            !method.data(ctx)->isIncompatibleOverride() && !isRBI && !method.data(ctx)->isDSLSynthesized()) {
+            !method.data(ctx)->isIncompatibleOverride() && !isRBI && !method.data(ctx)->isRewriterSynthesized()) {
             if (overridenMethod.data(ctx)->isFinalMethod()) {
                 if (auto e = ctx.state.beginError(method.data(ctx)->loc(), core::errors::Resolver::OverridesFinal)) {
                     e.setHeader("Method overrides a final method `{}`", overridenMethod.data(ctx)->show(ctx));

docs/internals.md

@@ -20,7 +20,7 @@ unfinished or confusing section!
 - [Phases](#phases)
   - [Parser](#parser)
   - [Desugar](#desugar)
-  - [DSL](#dsl)
+  - [Rewriter](#rewriter)
   - [LocalVars](#localvars)
   - [Namer](#namer)
   - [Resolver](#resolver)
@@ -120,8 +120,8 @@ another or make modifications within the IR they were given.
 | 1   | [Parser], `-p parse-tree`        |                     |                                   |
 |     |                                  | [`parser::Node`]    |                                   |
 | 2   | [Desugar], `-p desugar-tree`     |                     |                                   |
-| 3   |                                  | [`ast::Expression`] | [DSL]                             |
-| 4   |                                  | [`ast::Expression`] | [LocalVars], `-p dsl-tree`        |
+| 3   |                                  | [`ast::Expression`] | [Rewriter]                             |
+| 4   |                                  | [`ast::Expression`] | [LocalVars], `-p rewrite-tree`        |
 | 5   |                                  | [`ast::Expression`] | [Namer], `-p name-tree` (*)       |
 | 6   |                                  | [`ast::Expression`] | [Resolver], `-p resolve-tree` (*) |
 | 6   |                                  | [`ast::Expression`] | [Flattener], `-p flatten-tree`    |
@@ -161,7 +161,7 @@ The header itself is generated using [parser/tools/generate_ast.cc].
 
 In general, the IR the parser generates is intended to model Ruby very
 granularly, but is frequently redundant for the purpose of typechecking. We use
-the Desugar and DSL passes to simplify the IR before typechecking.
+the Desugar and Rewriter passes to simplify the IR before typechecking.
 
 
 ### Desugar
@@ -188,9 +188,9 @@ If you pass the `-p desugar-tree` or `-p desugar-tree-raw` option to `sorbet`,
 you can see what a Ruby program looks like after being desugared.
 
 
-### DSL
+### Rewriter
 
-The DSL pass is sort of like a domain-specific desugar pass. It takes
+The Rewriter pass is sort of like a domain-specific desugar pass. It takes
 [`ast::Expression`]s and rewrites specific Ruby DSLs and metaprogramming into
 code that Sorbet can analyze. DSL in this context can have a broad meaning. Some
 examples of DSLs that are rewritten by this pass:
@@ -201,16 +201,16 @@ examples of DSLs that are rewritten by this pass:
 
 - `Chalk::ODM`'s `prop` definitions are written similarly to `attr_reader`
 
-The core dsl pass lives in [dsl/dsl.cc].
-Each DSL pass lives in its own file in the [dsl/] folder.
+The core Rewriter pass lives in [rewriter/rewriter.cc].
+Each Rewriter pass lives in its own file in the [rewriter/] folder.
 
 In the future, we anticipate rewriting the DSL phase with a plugin architecture.
 This will allow for a wider audience of Rubyists to teach Sorbet about DSLs
 they've written.
 
-We artificially limit what code we call from DSL passes. Sometimes it would be
+We artificially limit what code we call from Rewriter passes. Sometimes it would be
 convenient to call into other phases of Sorbet, but instead we've reimplemented
-functionality in the DSL pass. This keeps the surface area of the API we'll have
+functionality in the Rewriter pass. This keeps the surface area of the API we'll have
 to present to plugins in the future small.
 
 
@@ -627,7 +627,7 @@ See [core/Symbols.h] and [core/SymbolRef.h] for more information.
 <!-- Phase descriptions -->
 [parser]: #parser
 [desugar]: #desugar
-[dsl]: #dsl
+[rewriter]: #rewriter
 [localvars]: #localvars
 [namer]: #namer
 [resolver]: #resolver
@@ -647,8 +647,8 @@ See [core/Symbols.h] and [core/SymbolRef.h] for more information.
 <!-- Files -->
 [parser/tools/generate_ast.cc]: ../parser/tools/generate_ast.cc
 [ast/desugar/Desugar.cc]: ../ast/desugar/Desugar.cc
-[dsl/dsl.cc]: ../dsl/dsl.cc
-[dsl/]: ../dsl/
+[rewriter/rewriter.cc]: ../rewriter/rewriter.cc
+[rewriter/]: ../rewriter/
 [namer/namer.cc]: ../namer/namer.cc
 [resolver/resolver.cc]: ../resolver/resolver.cc
 [cfg/CFG.h]: ../cfg/CFG.h

docs/pipeline.md

@@ -29,7 +29,7 @@ where what the phases of Sorbet actually do are documented.
 │    │ ast::Expression │    │    │ ast::Expression │    │   │ ast::Expression │    │
 │    └─────────────────┘    │    └─────────────────┘    │   └─────────────────┘    │
 │             │             │             │             │            │             │
-│             │ dsl         │             │ dsl         │            │ dsl         │
+│             │ rewriter         │             │ rewriter         │            │ rewriter         │
 │             ▼             │             ▼             │            ▼             │
 │    ┌─────────────────┐    │    ┌─────────────────┐    │   ┌─────────────────┐    │
 │    │ ast::Expression │    │    │ ast::Expression │    │   │ ast::Expression │    │

dsl/Regexp.h

@@ -41,11 +41,11 @@ cc_test(
         "infer",
         "//ast/desugar",
         "//cfg",
-        "//dsl",
         "//flattener",
         "//local_vars",
         "//namer",
         "//resolver",
+        "//rewriter",
         "@com_google_googletest//:gtest",
         "@com_google_googletest//:gtest_main",
     ],

dsl/TypeMembers.h

@@ -299,8 +299,8 @@ bool childNeedsOverride(core::Context ctx, core::SymbolRef childSymbol, core::Sy
         !parentSymbol.data(ctx)->loc().file().data(ctx).isRBI() &&
         // that isn't the constructor...
         childSymbol.data(ctx)->name != core::Names::initialize() &&
-        // and wasn't DSL synthesized (beause we can't change DSL'd sigs).
-        !parentSymbol.data(ctx)->isDSLSynthesized() &&
+        // and wasn't Rewriter synthesized (beause we can't change DSL'd sigs).
+        !parentSymbol.data(ctx)->isRewriterSynthesized() &&
         // It has a sig...
         parentSymbol.data(ctx)->resultType != nullptr &&
         //  that is either overridable...
@@ -370,7 +370,8 @@ bool SigSuggestion::maybeSuggestSig(core::Context ctx, core::ErrorBuilder &e, un
     }
 
     auto loc = methodSymbol.data(ctx)->loc();
-    // Sometimes the methodSymbol we're looking at has been synthesized by a DSL pass, so no 'def' exists in the source
+    // Sometimes the methodSymbol we're looking at has been synthesized by a Rewriter pass, so no 'def' exists in the
+    // source
     if (loc.file().data(ctx).source().substr(loc.beginPos(), 3) != "def") {
         return false;
     }

infer/BUILD

@@ -7,12 +7,12 @@
 #include "core/ErrorQueue.h"
 #include "core/Names.h"
 #include "core/Unfreeze.h"
-#include "dsl/dsl.h"
 #include "flattener/flatten.h"
 #include "infer/infer.h"
 #include "local_vars/local_vars.h"
 #include "namer/namer.h"
 #include "resolver/resolver.h"
+#include "rewriter/rewriter.h"
 #include "spdlog/spdlog.h"
 // has to come before the next one. This comment stops formatter from reordering them
 #include "spdlog/sinks/stdout_color_sinks.h"
@@ -49,7 +49,7 @@ void processSource(core::GlobalState &cb, string str) {
     sorbet::core::MutableContext ctx(cb, core::Symbols::root());
     auto fileId = ast->loc.file();
     auto tree = ast::ParsedFile{ast::desugar::node2Tree(ctx, move(ast)), fileId};
-    tree.tree = dsl::DSL::run(ctx, move(tree.tree));
+    tree.tree = rewriter::Rewriter::run(ctx, move(tree.tree));
     tree = local_vars::LocalVars::run(ctx, move(tree));
     vector<ast::ParsedFile> trees;
     trees.emplace_back(move(tree));