Sorbet中如何解决`Dynamic constant references`错误？

问题背景 #

在使用Sorbet进行类型检查时，动态引用不同模块的同名常量会触发Dynamic constant references are unsupported错误。示例代码如下：

module A
  CONSTANT = { x: 1, y: 0 }.freeze
end

module B
  CONSTANT = { x: 0, y: 1 }.freeze
end

class C
  def initialize(kind)
    @kind = kind
  end

  def target_module
    @kind == 'a' ? A : B
  end

  def foo
    p target_module::CONSTANT # 错误：Dynamic constant references are unsupported
  end
end

C.new('a').foo # 预期输出 -> {x: 1, y: 0}

模块A和B拥有结构一致的CONSTANT常量，但通过target_module动态返回的模块引用常量时，Sorbet无法静态推断常量的存在，因此抛出错误。同时存在疑问：是否有针对常量的抽象机制，还是必须将常量引用改为方法？

解决方案 #

1. 封装为抽象方法（推荐） #

Sorbet对静态常量引用的检查严格，但支持方法调用的类型推断。可以通过定义抽象模块统一方法签名，将常量封装为模块方法：

# typed: true
extend T::Sig

# 定义抽象接口模块，规范常量获取方法
module ConstantProvider
  extend T::Sig
  extend T::Helpers

  interface!

  sig { returns(T::Hash[Symbol, Integer]) }
  def self.constant; end
end

module A
  extend ConstantProvider

  CONSTANT = { x: 1, y: 0 }.freeze

  sig { override.returns(T::Hash[Symbol, Integer]) }
  def self.constant
    CONSTANT
  end
end

module B
  extend ConstantProvider

  CONSTANT = { x: 0, y: 1 }.freeze

  sig { override.returns(T::Hash[Symbol, Integer]) }
  def self.constant
    CONSTANT
  end
end

class C
  extend T::Sig

  sig { params(kind: String).void }
  def initialize(kind)
    @kind = kind
  end

  sig { returns(ConstantProvider) }
  def target_module
    @kind == 'a' ? A : B
  end

  def foo
    p target_module.constant # 无类型检查错误
  end
end

C.new('a').foo # -> {:x=>1, :y=>0}

这种方式通过抽象模块ConstantProvider统一了方法签名，让Sorbet能准确推断target_module的类型，同时封装了常量获取逻辑，符合面向抽象的设计原则。

2. 类型断言绕过检查（不推荐） #

如果不想修改原有模块结构，可以使用T.cast进行类型断言，强制Sorbet认可动态引用的合法性，但会削弱类型检查的安全性：

# typed: true
extend T::Sig

module A
  CONSTANT = { x: 1, y: 0 }.freeze
end

module B
  CONSTANT = { x: 0, y: 1 }.freeze
end

class C
  extend T::Sig

  sig { params(kind: String).void }
  def initialize(kind)
    @kind = kind
  end

  sig { returns(T.any(T.class_of(A), T.class_of(B))) }
  def target_module
    @kind == 'a' ? A : B
  end

  def foo
    # 断言模块包含指定类型的CONSTANT常量
    mod = T.cast(target_module, T.type_alias { {CONSTANT: T::Hash[Symbol, Integer]} })
    p mod::CONSTANT
  end
end

C.new('a').foo # -> {:x=>1, :y=>0}

该方法虽能快速解决错误，但丢失了编译时的类型安全保障，不建议在大型项目中使用。

关于常量的抽象机制 #

Sorbet本身不支持直接定义抽象常量，因为Ruby的常量是静态绑定的，而Sorbet的类型系统更倾向于通过方法接口实现抽象。因此将常量封装为方法是最符合Sorbet设计理念的解决方案。

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