Merge pull request #2635 from ruby/inline--constant

Inline constant declaration

Author: soutaro

docs/inline.md

@@ -388,3 +388,67 @@ Instance variable declarations must be under the `class`/`module` syntax, and th
 ### Current Limitations
 
 - Only instance variables of class/module instances are allowed
+
+## Constants
+
+Constants are supported by inline RBS declaration.
+
+```ruby
+Foo = 123
+
+module Bar
+  Baz = [1, ""] #: [Integer, String]
+end
+
+# Version of the library
+#
+VERSION = "1.2.3".freeze #: String
+```
+
+### Type Inference for Literal Constants
+
+The types of constants may be automatically inferred when the right-hand side consists of literals:
+
+- **Integers**: `COUNT = 42` → `Integer`
+- **Floats**: `RATE = 3.14` → `Float`
+- **Booleans**: `ENABLED = true` → `bool`
+- **Strings**: `NAME = "test"` → `String`
+- **Symbols**: `STATUS = :ready` → `:ready`
+
+```ruby
+MAX_SIZE = 100           # Inferred as Integer
+PI = 3.14159            # Inferred as Float
+DEBUG = false           # Inferred as bool
+APP_NAME = "MyApp"      # Inferred as String
+DEFAULT_MODE = :strict  # Inferred as :strict
+```
+
+### Explicit Type Annotations
+
+For more complex types or when you want to override inference, use the `#:` syntax:
+
+```ruby
+ITEMS = [1, "hello"] #: [Integer, String]
+CONFIG = { name: "app", version: 1 } #: { name: String, version: Integer }
+CALLBACK = -> { puts "done" } #: ^() -> void
+```
+
+### Documentation Comments
+
+Comments above constant declarations become part of the constant's documentation:
+
+```ruby
+# The maximum number of retries allowed
+# before giving up on the operation
+MAX_RETRIES = 3
+
+# Application configuration loaded from environment
+#
+# This hash contains all the runtime configuration
+# settings for the application.
+CONFIG = load_config() #: Hash[String, untyped]
+```
+
+### Current Limitations
+
+- Module/class aliases are not supported

lib/rbs/ast/ruby/comment_block.rb

@@ -222,6 +222,23 @@ def leading_annotation?(index)
 
           false
         end
+
+        def as_comment
+          lines = [] #: Array[String]
+
+          each_paragraph([]) do |paragraph|
+            case paragraph
+            when Location
+              lines << paragraph.local_source
+            end
+          end
+
+          string = lines.join("\n")
+
+          unless string.strip.empty?
+            AST::Comment.new(string: string, location: location)
+          end
+        end
       end
     end
   end

lib/rbs/ast/ruby/declarations.rb

@@ -129,6 +129,59 @@ def name_location
             rbs_location(node.constant_path.location)
           end
         end
+
+        class ConstantDecl < Base
+          attr_reader :leading_comment
+          attr_reader :constant_name
+          attr_reader :node
+          attr_reader :type_annotation
+
+          def initialize(buffer, constant_name, node, leading_comment, type_annotation)
+            super(buffer)
+            @constant_name = constant_name
+            @node = node
+            @leading_comment = leading_comment
+            @type_annotation = type_annotation
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            case node
+            when Prism::ConstantWriteNode
+              rbs_location(node.name_loc)
+            when Prism::ConstantPathWriteNode
+              rbs_location(node.target.location)
+            end
+          end
+
+          def type
+            return type_annotation.type if type_annotation
+
+            case node.value
+            when Prism::IntegerNode
+              BuiltinNames::Integer.instance_type
+            when Prism::FloatNode
+              BuiltinNames::Float.instance_type
+            when Prism::StringNode
+              BuiltinNames::String.instance_type
+            when Prism::TrueNode, Prism::FalseNode
+              Types::Bases::Bool.new(location: nil)
+            when Prism::SymbolNode
+              BuiltinNames::Symbol.instance_type
+            when Prism::NilNode
+              Types::Bases::Nil.new(location: nil)
+            else
+              Types::Bases::Any.new(location: nil)
+            end
+          end
+
+          def comment
+            leading_comment&.as_comment
+          end
+        end
       end
     end
   end

lib/rbs/ast/ruby/helpers/constant_helper.rb

@@ -15,6 +15,10 @@ def constant_as_type_name(node)
               rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
                 nil
               end
+            when Prism::ConstantWriteNode
+              TypeName.new(name: node.name, namespace: Namespace.empty)
+            when Prism::ConstantPathWriteNode
+              constant_as_type_name(node.target)
             end
           end
         end

lib/rbs/buffer.rb

@@ -29,7 +29,7 @@ def line_count
 
     def ranges
       @ranges ||= begin
-        if content.empty? 
+        if content.empty?
           ranges = [0...0] #: Array[Range[Integer]]
           lines = [""]
         else
@@ -89,9 +89,9 @@ def inspect
 
     def rbs_location(location, loc2=nil)
       if loc2
-        Location.new(self, location.start_character_offset, loc2.end_character_offset)
+        Location.new(self.top_buffer, location.start_character_offset, loc2.end_character_offset)
       else
-        Location.new(self, location.start_character_offset, location.end_character_offset)
+        Location.new(self.top_buffer, location.start_character_offset, location.end_character_offset)
       end
     end
 

lib/rbs/definition.rb

@@ -66,25 +66,7 @@ def comment
           when AST::Members::Base
             member.comment
           when AST::Ruby::Members::Base
-            if member.leading_comment
-              lines = [] #: Array[String]
-
-              member.leading_comment.each_paragraph([]) do |paragraph|
-                case paragraph
-                when Location
-                  lines << paragraph.local_source
-                end
-              end
-
-              string = lines.join("\n")
-              
-              unless string.strip.empty?
-                AST::Comment.new(
-                  string: string,
-                  location: member.leading_comment.location
-                )
-              end
-            end
+            member.leading_comment&.as_comment
           end
         end
 

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

lib/rbs/inline_parser.rb

@@ -29,6 +29,7 @@ def initialize(location, message)
       NonConstantSuperClassName = _ = Class.new(Base)
       TopLevelMethodDefinition = _ = Class.new(Base)
       TopLevelAttributeDefinition = _ = Class.new(Base)
+      NonConstantConstantDeclaration = _ = Class.new(Base)
       UnusedInlineAnnotation = _ = Class.new(Base)
       AnnotationSyntaxError = _ = Class.new(Base)
       MixinMultipleArguments = _ = Class.new(Base)
@@ -237,6 +238,19 @@ def visit_call_node(node)
         end
       end
 
+      def visit_constant_write_node(node)
+        return if skip_node?(node)
+
+        # Parse constant declaration (both top-level and in classes/modules)
+        parse_constant_declaration(node)
+      end
+
+      def visit_constant_path_write_node(node)
+        return if skip_node?(node)
+
+        parse_constant_declaration(node)
+      end
+
       def parse_mixin_call(node)
         # Check for multiple arguments
         if node.arguments && node.arguments.arguments.length > 1
@@ -353,6 +367,60 @@ def parse_attribute_call(node)
         current_module!.members << member
       end
 
+      def parse_constant_declaration(node)
+        # Create TypeName for the constant
+        unless constant_name = constant_as_type_name(node)
+          location =
+            case node
+            when Prism::ConstantWriteNode
+              node.name_loc
+            when Prism::ConstantPathWriteNode
+              node.target.location
+            end
+
+          diagnostics << Diagnostic::NonConstantConstantDeclaration.new(
+            rbs_location(location),
+            "Constant name must be a constant"
+          )
+          return
+        end
+
+        # Look for leading comment block
+        leading_block = comments.leading_block!(node)
+        report_unused_block(leading_block) if leading_block
+
+        # Look for trailing type annotation (#: Type)
+        trailing_block = comments.trailing_block!(node.location)
+        type_annotation = nil
+
+        if trailing_block
+          case annotation = trailing_block.trailing_annotation([])
+          when AST::Ruby::Annotations::NodeTypeAssertion
+            type_annotation = annotation
+          when AST::Ruby::CommentBlock::AnnotationSyntaxError
+            diagnostics << Diagnostic::AnnotationSyntaxError.new(
+              annotation.location, "Syntax error: " + annotation.error.error_message
+            )
+          end
+        end
+
+        # Create the constant declaration
+        constant_decl = AST::Ruby::Declarations::ConstantDecl.new(
+          buffer,
+          constant_name,
+          node,
+          leading_block,
+          type_annotation
+        )
+
+        # Insert the constant declaration appropriately
+        if current_module
+          current_module.members << constant_decl
+        else
+          result.declarations << constant_decl
+        end
+      end
+
       def insert_declaration(decl)
         if current_module
           current_module.members << decl

sig/ast/ruby/comment_block.rbs

@@ -115,6 +115,12 @@ module RBS
         def location: () -> Location
 
         private def leading_annotation?: (Integer index) -> bool
+
+        # Returns an comment object that contains the docs of from the comment block
+        #
+        # It ignores type annotations and syntax errors.
+        # 
+        def as_comment: () -> AST::Comment?
       end
     end
   end