Update environment

Author: soutaro

lib/rbs/environment.rb

@@ -409,6 +409,23 @@ def insert_ruby_decl(decl, context:, namespace:)
         decl.each_decl do |member|
           insert_ruby_decl(member, context: inner_context, namespace: name.to_namespace)
         end
+
+      when AST::Ruby::Declarations::ConstantDecl
+        name = decl.constant_name.with_prefix(namespace)
+
+        if entry = constant_entry(name)
+          case entry
+          when ClassAliasEntry, ModuleAliasEntry, ConstantEntry
+            raise DuplicatedDeclarationError.new(name, decl, entry.decl)
+          when ClassEntry, ModuleEntry
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
+          end
+        end
+
+        constant_decls[name] = ConstantEntry.new(name: name, decl: decl, context: context)
+
+      else
+        raise "Unknown Ruby declaration type: #{decl.class}"
       end
     end
 
@@ -717,6 +734,17 @@ def resolve_ruby_decl(resolver, decl, context:, prefix:)
           end
         end
 
+      when AST::Ruby::Declarations::ConstantDecl
+        full_name = decl.constant_name.with_prefix(prefix)
+
+        AST::Ruby::Declarations::ConstantDecl.new(
+          decl.buffer,
+          full_name,
+          decl.node,
+          decl.leading_comment,
+          decl.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        )
+
       else
         raise "Unknown declaration type: #{decl.class}"
       end

sig/environment.rbs

@@ -24,7 +24,7 @@ module RBS
     class TypeAliasEntry < SingleEntry[TypeName, AST::Declarations::TypeAlias]
     end
 
-    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant]
+    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant | AST::Ruby::Declarations::ConstantDecl]
     end
 
     class GlobalEntry < SingleEntry[Symbol, AST::Declarations::Global]

test/rbs/environment_test.rb

@@ -746,4 +746,51 @@ module World
       assert_equal 2, module_decl.context_decls.size
     end
   end
+
+  def test__ruby__constant_declarations
+    result = parse_inline(<<~RUBY)
+      A = "123"
+      B = [1, 2] #: Object
+      Object::FOO = :FOO
+
+      class Object
+        BAR = "BAR"
+      end
+    RUBY
+
+    env = Environment.new
+    env.add_source(RBS::Source::Ruby.new(result.buffer, result.prism_result, result.declarations, result.diagnostics))
+    resolved_env = env.resolve_type_names
+
+    # Check top-level constant A with inferred type
+    assert_operator resolved_env.constant_decls, :key?, type_name("::A")
+    resolved_env.constant_decls[type_name("::A")].tap do |entry|
+      assert_equal type_name("::A"), entry.name
+      assert_equal "::String", entry.decl.type.to_s
+    end
+
+    # Check top-level constant B with type annotation
+    assert_operator resolved_env.constant_decls, :key?, type_name("::B")
+    resolved_env.constant_decls[type_name("::B")].tap do |entry|
+      assert_equal type_name("::B"), entry.name
+      assert_equal "::Object", entry.decl.type.to_s
+    end
+
+    # Check constant path Object::FOO
+    assert_operator resolved_env.constant_decls, :key?, type_name("::Object::FOO")
+    resolved_env.constant_decls[type_name("::Object::FOO")].tap do |entry|
+      assert_equal type_name("::Object::FOO"), entry.name
+      assert_equal "::Symbol", entry.decl.type.to_s
+    end
+
+    # Check constant inside class Object
+    assert_operator resolved_env.constant_decls, :key?, type_name("::Object::BAR")
+    resolved_env.constant_decls[type_name("::Object::BAR")].tap do |entry|
+      assert_equal type_name("::Object::BAR"), entry.name
+      assert_equal "::String", entry.decl.type.to_s
+    end
+
+    # Verify that Object class is created
+    assert_operator resolved_env.class_decls, :key?, type_name("::Object")
+  end
 end