调试Scala编译器代码：克隆仓库后的后续步骤咨询

Great question! Debugging the Scala compiler is such a hands-on way to unpack how it turns your source code into bytecode. Now that you’ve got the repo cloned, here’s a step-by-step breakdown of what to do next:

First, make sure you’ve got the right tools to avoid build headaches:

• JDK Version: For Scala 3, stick with JDK 11 or 17 (most maintainers use 17). For Scala 2, JDK 8 or 11 works best. Verify your version with java -version.
• Build Tool: The Scala repo uses sbt. Ensure you’re on the latest stable version—run sbt sbtVersion to check, and update if needed.
• Full Initial Build: Run sbt compile from the repo root. It’ll take a while, but this ensures all modules compile cleanly and you don’t hit unexpected errors later.

You need to know where the compiler starts executing:

• Scala 3: The main class is dotty.tools.dotc.Main, found at compiler/src/dotty/tools/dotc/Main.scala.
• Scala 2: Look for scala.tools.nsc.Main in src/compiler/scala/tools/nsc/Main.scala.

Test that you can run the compiler directly first:

• Scala 3: sbt "dotc -version"
• Scala 2: sbt "scalac -version"

If you see a version output, you’re good to go.

Most folks use IntelliJ IDEA or VS Code with Metals—let’s use IntelliJ as an example:

1. Import the repo as an sbt project (File > New > Project from Existing Sources, select the repo root, choose sbt).
2. Wait for the IDE to index all files (this can take several minutes).
3. Create a Run/Debug Configuration:
   • Select "Application" as the type.
   • Set the main class to dotty.tools.dotc.Main (or the Scala 2 equivalent).
   • Add program arguments: point to a simple test Scala file (e.g., src/test/Hello.scala with a basic object Hello { def main(args: Array[String]) = println("Hi") }).
   • Set the working directory to your repo root if needed.
4. Set breakpoints in key places: start with the main method in the entry class, then move to core phases like parsing or type checking once you’re comfortable.

Don’t jump into complex code—start with the simplest possible program (like the Hello World above). Run the debugger and step through the code:

• Watch how the compiler initializes its phases.
• Trace how the source file is read, parsed into an AST (Abstract Syntax Tree), and passed through each compilation phase.
• Pay attention to data structures like Tree (Scala 2) or Tree/Type (Scala 3)—these are the core of the compiler’s processing.

The Scala repo has a massive collection of tests that are perfect for debugging:

• Scala 3: Check the tests/ directory—tests/run/ has working programs, tests/pos/ has valid code that should compile, and tests/neg/ has code that should fail (great for testing error handling).
• Scala 2: Look in test/files/ for similar test categories.

You can run a test through the debugger using sbt’s debug mode:

• Scala 3: sbt -jvm-debug 5005 "dotc tests/run/HelloWorld.scala"
• Then in your IDE, create a "Remote JVM Debug" configuration pointing to port 5005 and connect. This lets you debug the compiler instance that sbt is running.

Both Scala 2 and 3 use a phase-based architecture—each phase transforms the AST before passing it to the next. Key phases to focus on first:

• Parser: Turns raw source text into an AST. Look for classes like dotty.tools.dotc.parsing.Parser (Scala3) or scala.tools.nsc.parsing.Parsers (Scala2).
• Typer: Handles type checking and inference. This is where most of the "smart" logic lives—breakpoints here will show you how the compiler verifies your code’s types.
• Erasure: Removes generic type information (since the JVM doesn’t understand it) and prepares the AST for bytecode generation.
• Backend: Generates JVM bytecode (or JavaScript, for Scala.js) from the processed AST.

The compiler codebase is well-documented—take advantage of:

• Inline comments on classes and methods (they often explain the "why" behind complex logic).
• The docs/ directory in the repo: Scala 3 has docs/internals/ with high-level overviews of the compiler architecture.

Once you’re familiar with a phase, try making a tiny modification to see how it affects the compiler’s behavior. For example:

• Add a debug log in the Parser phase to print out the AST nodes it creates.
• Adjust a type checking rule (carefully!) to see how it changes error messages or compilation output.

This hands-on experimentation will solidify your understanding way faster than just reading code.

内容的提问来源于stack exchange，提问作者Mandroid