编译过程中类型检查的时机：理论、实践及多编程语言场景解析

Great question—this is a common point of confusion because textbook compile-time models often simplify real-world nuances, especially when comparing static vs. dynamic typed languages across paradigms. Let’s break this down clearly, focusing on the examples you mentioned: Haskell (static functional) and Ruby (dynamic OOP), plus a quick nod to logic languages.

Static-Typed Functional Languages (e.g., Haskell) #

• Textbook Model: Most theory books place type checking as a distinct "semantic analysis" step right after AST generation (between your steps 1 and 2). It’s framed as a validation phase that ensures the AST adheres to the language’s type rules before moving to IR conversion.
• Real-World Implementation (GHC): This aligns pretty closely with the textbook, but with tighter integration. GHC parses source code into an untyped AST first, then immediately runs its type checker and inference engine over this AST. The type checker doesn’t just validate—it infers missing types, resolves polymorphic variables, and catches inconsistencies like passing an Int to a function expecting a String. If any type errors are found, compilation stops cold before ever generating Core (GHC’s IR).
• Edge Case: Some late-stage optimizations might use type information (e.g., specializing polymorphic functions), but this is using type data, not checking types. The core type validation is strictly pre-IR.

Dynamic-Typed OOP Languages (e.g., Ruby) #

• Textbook Model: Dynamic languages are often described as doing "no compile-time type checking"—all type validation happens at runtime.
• Real-World Implementation (MRI/Ruby): This is mostly true. Ruby’s compilation pipeline goes source → AST → YARV bytecode (its IR) → execution. During steps 1-4, the compiler does almost no type-related validation. For example, writing "foo" + 123 will compile to bytecode without complaint; the TypeError only gets thrown when the code runs and the VM tries to add a string and integer.
• Modern Twist: Ruby’s MJIT (Just-In-Time compiler) collects runtime type data to optimize hot paths, but this is runtime feedback for optimization, not compile-time type checking. The core "type check" (verifying operations are valid for a value’s type) is entirely runtime.

Static-Typed OOP Languages (e.g., Java) #

• Similar to Haskell: Type checking happens between AST generation and IR (bytecode) generation. Javac parses source into AST, runs type checks (verifying class hierarchies, method signatures, type conversions, etc.), and only proceeds to bytecode generation if all checks pass. Type errors halt compilation immediately.

Logic Languages (e.g., Prolog, Mercury) #

• For untyped logic languages like standard Prolog: There’s no compile-time type checking—all validation (e.g., ensuring a variable is bound to a valid term) happens at runtime.
• For statically typed logic languages like Mercury: Type checking follows the static language pattern, between AST generation and IR conversion, enforcing type consistency before compilation proceeds.

• Textbooks: Tend to present a linear, discrete workflow: Parse → Type Check → IR Generate → Optimize → Code Generate.
• Real-World:
  • Static languages may integrate type inference with AST parsing (rather than a strict post-parsing step) to streamline processing.
  • Dynamic languages skip compile-time type checking entirely, shifting all type-related work to runtime.
  • Rarely is type checking 贯穿整个编译过程 (throughout the entire compile process)—core validation is almost always early-stage, with later stages using type info for optimization, not checking.

• Static languages (Haskell, Java): Type check happens between step 1 (AST) and step 2 (IR conversion). It’s a mandatory prerequisite for moving forward.
• Dynamic languages (Ruby): Type check does not occur in steps 1-4. It happens during runtime execution of the final code.
• No case where type check is after step 4 (simplified IR): That stage is for optimizing and generating output—type errors would have been caught much earlier (static) or will be caught when running the code (dynamic).

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