Metaprogramming

Implementation Notes

Implemented in src/interpreter/executor/access/member.rs within instance_member_access:

// Implementation flow:
// 1. Check native methods via find_native_method
// 2. Check user-defined methods via find_method
// 3. If neither found, check for method_missing and call it
// 4. If method_missing exists, execute it with method name and args
// 5. Return error "undefined method" if nothing found

Implementation Notes

Implemented in src/interpreter/executor/access/member.rs at the end of instance_member_access:

// When a method is not found:
// 1. Check if class has method_missing defined
// 2. If yes, return a NativeFunction that wraps method_missing
// 3. When invoked, builds args [method_name, ...original_args]
// 4. Executes method_missing with proper 'this' binding
// 5. Returns error if method_missing also not found

Implementation Notes

Implemented in src/interpreter/executor/access/member.rs as a universal instance method:

// Checks class methods, native methods, AND universal methods
// Universal methods (inspect, class, nil?, etc.) are handled inline
// and need explicit inclusion in respond_to? checks
let is_universal = matches!(method_name.as_str(),
  "inspect" | "class" | "nil?" | "blank?" | "present?"
  | "respond_to?" | "send" | "instance_variables"
  | "instance_variable_get" | "instance_variable_set"
  | "methods" | "method_missing"
);

Implementation Notes

Implemented in src/interpreter/executor/access/member.rs:

// define_method writes to Class.methods (RefCell for interior mutability).
// Class-level form (Foo.define_method) is supported alongside the
// instance-level form (foo.define_method).
//
// For primitive-tagged classes (Int, Float, String, Array, Hash, etc.)
// writes are routed to a per-type user-method overlay instead, since
// primitive dispatch in member.rs / vm.rs does not consult Class.methods.
// See `src/interpreter/executor/calls/user_methods.rs`.

Precedence and performance

Lookup order on a primitive value: user methods → built-in methods → (for Hash) literal hash-key fallback. A user method on Hash shadows the literal-key access, matching Ruby's monkey-patching semantics.

Dispatch is gated by a single Relaxed atomic load. When no user methods have been registered for any primitive type, every call short-circuits in one cycle — no measurable overhead on the hot path. Storage is thread_local!; each worker thread registers its own copy when models load.

Implementation Notes

The closure returns the (possibly refined) QueryBuilder. Scope storage is per-thread (Rc<Function> is !Send and can't go in the process-global MODEL_REGISTRY); each worker registers scopes when it loads model files. See src/interpreter/builtins/model/scopes.rs.

Implementation Notes

Implemented in src/interpreter/executor/access/member.rs:

// alias_method copies the method function to the new name
class.methods.borrow_mut().insert(new_name, method.clone());
class.all_methods_cache.borrow_mut().take();

Implementation Notes

Implemented in src/interpreter/executor/statements.rs:

// After class creation, call inherited hook if superclass has one
if let Some(inherited_func) = superclass.find_static_method("inherited") {
  self.call_function(&inherited_func, vec![Value::Class(class_rc.clone())])?;
}
if let Some(inherited_native) = superclass.find_native_static_method("inherited") {
  let span = Span::new(0, 0, 1, 1);
  let result: Result<Value, String> =
    (inherited_native.func)(vec![Value::Class(class_rc.clone())]);
  result.map_err(|e| RuntimeError::new(e, span))?;
}

Implementation Notes

Implemented in src/interpreter/executor/access/member.rs as an instance method:

// instance_eval executes a block with:
// - 'this' bound to the instance
// - 'self' bound to the instance (alias for this)
// - closure environment preserved

// Note: class_eval requires modifying class methods at runtime,
// which requires architectural changes to Class.methods

Implementation Notes

Hook into the include statement resolution in the parser/interpreter. The included static method would be called automatically:

// When processing `include ModuleName`:
// 1. Load the module (existing behavior)
// 2. Check if Module has static method "included"
// 3. If yes, call Module.included(including_class)
// 4. The hook can modify the class's methods, etc.

Example Usage

class User
  name: String
  email: String

  def greet
    "Hello!"
  end
end

user = User.new
user.instance_variables   # => ["@name", "@email"]
user.methods             # => ["greet", "to_s", ...]
user.respond_to?("greet") # => true

class ApplicationRecord
  static def method_missing(method_name)
    if (method_name.starts_with("find_by_"))
      field = method_name.sub("find_by_", "")
      return "Finding by " + field
    end
    return "Method '" + method_name + "' was called"
  end
end

class User < ApplicationRecord
  # Inherit dynamic finder capability
end

# These all work automatically:
User.find_by_name("Alice")        # => "Finding by name"
User.find_by_email("[email protected]")  # => "Finding by email"
User.find_by_name_and_status("Bob", "active")  # => "Finding by name_and_status"