Interpreter: Circular require with glob pattern causes double evaluation of constants

[cyangle]

Description
When using require "path/**" in combination with a circular require back to the file containing the glob, the interpreter appears to re-evaluate the required files, causing constants to be instantiated multiple times. This results in object identity mismatches where a constant and a reference to that constant (e.g., stored in a class variable) point to different object instances.

This behavior differs from the compiler, which correctly handles the circular dependency and ensures files are only evaluated once.

Reproduction Steps

Create the following file structure:

common.cr

# The entry point that uses a glob require
require "./lib/**"

lib/circular.cr

# This circular require, combined with the glob in common.cr, triggers the bug
require "../common"

lib/schema.cr

class Schema
  def initialize(@name : String)
  end
end

# This constant will be instantiated TWICE by the interpreter due to the bug
MyDB = Schema.new("db")

lib/model.cr

class Model
  @@schema : Schema?

  def self.set_schema(schema)
    @@schema = schema
  end

  def self.schema
    @@schema.not_nil!
  end
end

# At this point, MyDB might be a different instance than what main sees
Model.set_schema(MyDB)

repro.cr

require "./common"

puts "Checking object identity..."
puts "Constant (MyDB) object_id: #{MyDB.object_id}"
puts "Class Var (Model.schema) object_id: #{Model.schema.object_id}"

if MyDB.object_id != Model.schema.object_id
  puts "❌ BUG REPRODUCED: Objects are different!"
  exit 1
else
  puts "✅ SUCCESS: Objects are the same."
end

Expected Behavior (Compiler)
Running with crystal run repro.cr (or build):

Checking object identity...
Constant (MyDB) object_id: 132575200268192
Class Var (Model.schema) object_id: 132575200268192
✅ SUCCESS: Objects are the same.

Actual Behavior (Interpreter)
Running with crystal i repro.cr:

Checking object identity...
Constant (MyDB) object_id: 123345412094208
Class Var (Model.schema) object_id: 123345412094240
❌ BUG REPRODUCED: Objects are different!

Environment

• Crystal version: 1.20.0-dev
• OS: Linux

[cyangle]

AI analysis and proposed fix:

The bug was caused by the interpreter re-evaluating constant initializers even if the constant was already initialized.

When a constant is defined in a file (e.g., MyDB = Schema.new("db")), the interpreter's compiler (Crystal::Repl::Compiler) generates bytecode to execute this assignment. Normally, this is fine. However, in the case of circular dependencies involving require, it is possible for a file to be required and for code in that file (or another file) to reference the constant before the interpreter reaches the line where the constant is defined.

When the constant is referenced (read access), the interpreter correctly checks if it is initialized, and if not, runs the initializer (lazily). So MyDB gets initialized with an instance of Schema.

Later, when the interpreter execution flow reaches the actual definition MyDB = ... in the source file, the compiler was generating unconditional initialization code. This caused the initializer to run again, creating a second instance of Schema and overwriting MyDB.

The fix involves modifying Crystal::Repl::Compiler#visit(node : Assign) to check if the constant is already initialized before generating the initialization code. If it is initialized, the assignment is skipped (preserving the existing value).

diff --git a/src/compiler/crystal/interpreter/compiler.cr b/src/compiler/crystal/interpreter/compiler.cr
index bba9d5093..40f906bf1 100644
--- a/src/compiler/crystal/interpreter/compiler.cr
+++ b/src/compiler/crystal/interpreter/compiler.cr
@@ -685,13 +685,17 @@ class Crystal::Repl::Compiler < Crystal::Visitor
 
         # This will initialize the constant
         const_initialized index, node: nil
-        pop(sizeof(Pointer(Void)), node: nil) # pop the bool value
+        branch_if 0, node: nil
+        cond_jump_location = patch_location
 
         call compiled_def, node: nil
-
-        # Why we dup: check the Var case (it's similar)
-        dup(aligned_sizeof_type(const.value.type), node: nil) if @wants_value
         set_const index, aligned_sizeof_type(const.value), node: nil
+
+        patch_jump(cond_jump_location)
+
+        if @wants_value
+          get_const index, aligned_sizeof_type(const.value), node: nil
+        end
       elsif @wants_value
         # This is probably the last constant defined in a file, and it's a throw-away value
         put_nil node: node