rbs-inline 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f73d1f3ac7e111f773fe9b2d034dc5ccc3a8732f50aacf1a07655ad3450e24f4
-  data.tar.gz: '082c1f8a6ef85a239f29563f1e95d6af0ac0af89c5860a6c552d56505a0a27ba'
+  metadata.gz: 83b5fc9f8e331ee20d2e8dc61604dc9a21693dcf6869f79e29eebbc885c45554
+  data.tar.gz: 5c7a7abdc5acbf156bbd914ccaaa2eb86a54086ddf6562b6fc6f485921b120a0
 SHA512:
-  metadata.gz: 6002e610f1440abbfe351ee3c746e6c4c1f6dcae1a885fc9a5f60d701ebd0548620d8c6ffc6211bffd5830fd9c65901f7d7155d6de049a8670f0b72749f55b0c
-  data.tar.gz: 61041de88fbc0048f48fc46c012e1d1a7ff66760aef73e288f60351705425f466d84a4d50488feac54bb58e50fb504916596a8ceaf8ee5f99c76919227ee431e
+  metadata.gz: e4acaf6c3c40bcee7639b9d7f482b8e3acc47466c5069c15437c9f2205775938f6acba61ba4afe4612ab98a65dbeb4e2fd7894c6bc0071512edce0e89db76632
+  data.tar.gz: ab895615e1dab1d9ce750e55ee06499cfd224de8df9b754c592fd2224d8d89c33d2f64f14c312a9f61515e60627fd247f6d5646eb51d1b1731ed10b60b9c1524

data/README.md

@@ -2,9 +2,6 @@
 
 RBS::Inline allows embedding RBS type declarations into Ruby code as comments. You can declare types, write the implementation, and verifies they are consistent without leaving the editor opening the Ruby code.
 
-> [!IMPORTANT]
-> The syntax is experimental. We are still seeking the best syntax with your feedbacks.
-
 > [!IMPORTANT]
 > This gem is a prototype for testing. We plan to merge this feature to rbs-gem and deprecate rbs-inline gem after that.
 
@@ -21,6 +18,8 @@ class Person
 
   attr_reader :addresses #: Array[String]
 
+  # You can write the type of parameters and return types.
+  #
   # @rbs name: String
   # @rbs addresses: Array[String]
   # @rbs return: void
@@ -29,10 +28,20 @@ class Person
     @addresses = addresses
   end
 
-  def to_s #: String
+  # Or write the type of the method just after `@rbs` keyword.
+  #
+  # @rbs () -> String
+  def to_s
     "Person(name = #{name}, addresses = #{addresses.join(", ")})"
   end
 
+  # The `:` syntax is the shortest one.
+  #
+  #: () -> String
+  def hash
+    [name, addresses].hash
+  end
+
   # @rbs &block: (String) -> void
   def each_address(&block) #: void
     addresses.each(&block)

data/lib/rbs/inline/ast/annotations.rb

@@ -482,7 +482,7 @@ module RBS
                   case last_token
                   when Array
                     # `*` clause
-                    namespace = Namespace(token_strs.join)
+                    namespace = RBS::Namespace.parse(token_strs.join)
                     @clauses << RBS::AST::Directives::Use::WildcardClause.new(
                       namespace: namespace,
                       location: nil

data/lib/rbs/inline/ast/declarations.rb

@@ -189,7 +189,7 @@ module RBS
 
           # @rbs %a{pure}
           # @rbs return: Types::t
-          def type
+          def type(default_type)
             if assertion
               case assertion.type
               when MethodType, nil
@@ -203,7 +203,7 @@ module RBS
               return literal
             end
 
-            Types::Bases::Any.new(location: nil)
+            default_type
           end
 
           # @rbs %a{pure}

data/lib/rbs/inline/ast/members.rb

@@ -41,6 +41,10 @@ module RBS
           # ```
           attr_reader :visibility #: RBS::AST::Members::visibility?
 
+          # The function is defined as singleton and instance method (as known as module_function)
+          #
+          attr_accessor :singleton_instance #: bool
+
           # Assertion given at the end of the method name
           #
           attr_reader :assertion #: Annotations::TypeAssertion?
@@ -48,11 +52,13 @@ module RBS
           # @rbs node: Prism::DefNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs visibility: RBS::AST::Members::visibility?
+          # @rbs singleton_instance: bool
           # @rbs assertion: Annotations::TypeAssertion?
-          def initialize(node, comments, visibility, assertion) #: void
+          def initialize(node, comments, visibility, singleton_instance, assertion) #: void
             @node = node
             @comments = comments
             @visibility = visibility
+            @singleton_instance = singleton_instance
             @assertion = assertion
 
             super(node.location)
@@ -152,7 +158,8 @@ module RBS
             end
           end
 
-          def method_overloads #: Array[RBS::AST::Members::MethodDefinition::Overload]
+          # @rbs (::RBS::Types::t default_type) -> Array[RBS::AST::Members::MethodDefinition::Overload]
+          def method_overloads(default_type)
             case
             when method_types = annotated_method_types
               method_types.map do |method_type|
@@ -175,7 +182,7 @@ module RBS
                   when Prism::RequiredParameterNode
                     required_positionals << Types::Function::Param.new(
                       name: param.name,
-                      type: var_type_hash[param.name] || Types::Bases::Any.new(location: nil),
+                      type: var_type_hash[param.name] || default_type,
                       location: nil
                     )
                   end
@@ -186,7 +193,7 @@ module RBS
                   when Prism::OptionalParameterNode
                     optional_positionals << Types::Function::Param.new(
                       name: param.name,
-                      type: var_type_hash[param.name] || Types::Bases::Any.new(location: nil),
+                      type: var_type_hash[param.name] || default_type,
                       location: nil
                     )
                   end
@@ -201,7 +208,7 @@ module RBS
 
                   rest_positionals = Types::Function::Param.new(
                     name: rest.name,
-                    type: splat_type || Types::Bases::Any.new(location: nil),
+                    type: splat_type || default_type,
                     location: nil
                   )
                 end
@@ -210,7 +217,7 @@ module RBS
                   if node.is_a?(Prism::RequiredKeywordParameterNode)
                     required_keywords[node.name] = Types::Function::Param.new(
                       name: nil,
-                      type: var_type_hash[node.name] || Types::Bases::Any.new(location: nil),
+                      type: var_type_hash[node.name] || default_type,
                       location: nil
                     )
                   end
@@ -218,7 +225,7 @@ module RBS
                   if node.is_a?(Prism::OptionalKeywordParameterNode)
                     optional_keywords[node.name] = Types::Function::Param.new(
                       name: nil,
-                      type: var_type_hash[node.name] || Types::Bases::Any.new(location: nil),
+                      type: var_type_hash[node.name] || default_type,
                       location: nil
                     )
                   end
@@ -233,13 +240,13 @@ module RBS
 
                   rest_keywords = Types::Function::Param.new(
                     name: kw_rest.name,
-                    type: double_splat_type || Types::Bases::Any.new(location: nil),
+                    type: double_splat_type || default_type,
                     location: nil)
                 end
 
                 if node.parameters.block
                   block = Types::Block.new(
-                    type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
+                    type: Types::UntypedFunction.new(return_type: default_type),
                     required: false,
                     self_type: nil
                   )
@@ -262,7 +269,7 @@ module RBS
                       required_keywords: required_keywords,
                       optional_keywords: optional_keywords,
                       rest_keywords: rest_keywords,
-                      return_type: return_type || Types::Bases::Any.new(location: nil)
+                      return_type: return_type || default_type
                     ),
                     block: block,
                     location: nil
@@ -408,22 +415,26 @@ module RBS
         class RubyAttr < RubyBase
           attr_reader :node #: Prism::CallNode
           attr_reader :comments #: AnnotationParser::ParsingResult?
+          attr_reader :visibility #: RBS::AST::Members::visibility?
           attr_reader :assertion #: Annotations::TypeAssertion?
 
           # @rbs node: Prism::CallNode
           # @rbs comments: AnnotationParser::ParsingResult?
+          # @rbs visibility: RBS::AST::Members::visibility?
           # @rbs assertion: Annotations::TypeAssertion?
           # @rbs return: void
-          def initialize(node, comments, assertion)
+          def initialize(node, comments, visibility, assertion)
             super(node.location)
 
             @node = node
             @comments = comments
+            @visibility = visibility
             @assertion = assertion
           end
 
           # @rbs return Array[RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter | RBS::AST::Members::AttrAccessor]?
-          def rbs
+          # @rbs default_type: RBS::Types::t
+          def rbs(default_type)
             if comments
               comment = RBS::AST::Comment.new(string: comments.content(trim: true), location: nil)
             end
@@ -454,13 +465,13 @@ module RBS
               args.map do |arg|
                 klass.new(
                   name: arg,
-                  type: attribute_type,
+                  type: attribute_type || default_type,
                   ivar_name: nil,
                   kind: :instance,
                   annotations: [],
                   location: nil,
                   comment: comment,
-                  visibility: nil
+                  visibility: visibility
                 )
               end
             end
@@ -468,13 +479,11 @@ module RBS
 
           # Returns the type of the attribute
           #
-          # Returns `untyped` when not annotated.
-          #
-          def attribute_type #: Types::t
+          def attribute_type #: Types::t?
             type = assertion&.type
             raise if type.is_a?(MethodType)
 
-            type || Types::Bases::Any.new(location: nil)
+            type
           end
         end
 

data/lib/rbs/inline/cli.rb

@@ -73,6 +73,7 @@ module RBS
         base_paths = [Pathname("lib"), Pathname("app")]
         output_path = nil #: Pathname?
         opt_in = true
+        unknown_type = nil #: String?
 
         OptionParser.new do |opts|
           opts.on("--base=BASE", "The path to calculate relative path of files (defaults to #{base_paths.join(File::PATH_SEPARATOR)})") do |str|
@@ -96,6 +97,10 @@ module RBS
             opt_in = true
           end
 
+          opts.on("--unknown-type=TYPE", "Use given type instead of untyped for unknown types (default: untyped)") do
+            unknown_type = _1
+          end
+
           opts.on("--verbose") do
             logger.level = :DEBUG
           end
@@ -141,6 +146,12 @@ module RBS
 
           if (uses, decls, rbs_decls = Parser.parse(Prism.parse_file(target.to_s), opt_in: opt_in))
             writer = Writer.new()
+
+            if unknown_type
+              type = RBS::Parser.parse_type(unknown_type, require_eof: true)
+              type && writer.default_type = type
+            end
+
             writer.header("Generated from #{target.relative? ? target : target.relative_path_from(Pathname.pwd)} with RBS::Inline")
             writer.write(uses, decls, rbs_decls)
 

data/lib/rbs/inline/parser.rb

@@ -37,10 +37,14 @@ module RBS
       #
       attr_reader :current_visibility #: RBS::AST::Members::visibility?
 
+      # The current module_function applied to single `def` node
+      attr_reader :current_module_function #: bool
+
       def initialize() #: void
         @decls = []
         @surrounding_decls = []
         @comments = {}
+        @current_module_function = false
       end
 
       # Parses the given Prism result to a three tuple
@@ -253,9 +257,7 @@ module RBS
 
           assertion = assertion_annotation(node.rparen_loc || node&.parameters&.location || node.name_loc)
 
-          current_decl.members << AST::Members::RubyDef.new(node, associated_comment, current_visibility, assertion)
-
-          super
+          current_decl.members << AST::Members::RubyDef.new(node, associated_comment, current_visibility, current_module_function, assertion)
         end
       end
 
@@ -302,7 +304,7 @@ module RBS
               end #: AST::Annotations::TypeAssertion?
             end
 
-            current_class_module_decl!.members << AST::Members::RubyAttr.new(node, comment, assertion)
+            current_class_module_decl!.members << AST::Members::RubyAttr.new(node, comment, current_visibility, assertion)
 
             return
           end
@@ -331,6 +333,30 @@ module RBS
               end
             end
           end
+        when :module_function
+          if node.arguments && node.arguments.arguments.size > 0
+            args = node.arguments.arguments.filter_map do |arg|
+              case arg
+              when Prism::SymbolNode
+                arg.unescaped.to_sym
+              end
+            end
+
+            current_decl = current_class_module_decl
+
+            if current_decl
+              node.arguments.arguments.each do |arg|
+                current_decl.members.each do |member|
+                  if member.is_a?(AST::Members::RubyDef) && args.include?(member.node.name)
+                    member.singleton_instance = true
+                    break
+                  end
+                end
+              end
+            end
+          else
+            @current_module_function = true
+          end
         end
 
         super

data/lib/rbs/inline/version.rb

@@ -2,6 +2,6 @@
 
 module RBS
   module Inline
-    VERSION = "0.9.0"
+    VERSION = "0.11.0"
   end
 end

data/lib/rbs/inline/writer.rb

@@ -1,5 +1,7 @@
 # rbs_inline: enabled
 
+require 'stringio'
+
 module RBS
   module Inline
     class Writer
@@ -13,17 +15,22 @@ module RBS
       attr_reader :output #: String
       attr_reader :writer #: RBS::Writer
 
+      attr_accessor :default_type #: Types::t
+
       # @rbs buffer: String
       def initialize(buffer = +"") #: void
         @output = buffer
         @writer = RBS::Writer.new(out: StringIO.new(buffer))
+        @default_type = Types::Bases::Any.new(location: nil)
       end
 
       # @rbs uses: Array[AST::Annotations::Use]
       # @rbs decls: Array[AST::Declarations::t]
       # @rbs rbs_decls: Array[RBS::AST::Declarations::t]
-      def self.write(uses, decls, rbs_decls) #: void
+      # @rbs &: ? (Writer) -> void
+      def self.write(uses, decls, rbs_decls, &) #: void
         writer = Writer.new()
+        yield writer if block_given?
         writer.write(uses, decls, rbs_decls)
         writer.output
       end
@@ -198,7 +205,7 @@ module RBS
         attributes = decl.each_attribute.map do |name, type|
           RBS::AST::Members::AttrReader.new(
             name: name,
-            type: type&.type || Types::Bases::Any.new(location: nil),
+            type: type&.type || default_type,
             ivar_name: false,
             comment: nil,
             kind: :instance,
@@ -218,7 +225,7 @@ module RBS
                 type: Types::Function.empty(Types::Bases::Instance.new(location: nil)).update(
                   required_positionals: decl.each_attribute.map do |name, attr|
                     RBS::Types::Function::Param.new(
-                      type: attr&.type || Types::Bases::Any.new(location: nil),
+                      type: attr&.type || default_type,
                       name: name,
                       location: nil
                     )
@@ -237,7 +244,7 @@ module RBS
                     [
                       name,
                       RBS::Types::Function::Param.new(
-                        type: attr&.type || Types::Bases::Any.new(location: nil),
+                        type: attr&.type || default_type,
                         name: nil,
                         location: nil
                       )
@@ -315,7 +322,7 @@ module RBS
           if decl.readonly_attributes?
             RBS::AST::Members::AttrReader.new(
               name: name,
-              type: type&.type || Types::Bases::Any.new(location: nil),
+              type: type&.type || default_type,
               ivar_name: false,
               comment: nil,
               kind: :instance,
@@ -326,7 +333,7 @@ module RBS
           else
             RBS::AST::Members::AttrAccessor.new(
               name: name,
-              type: type&.type || Types::Bases::Any.new(location: nil),
+              type: type&.type || default_type,
               ivar_name: false,
               comment: nil,
               kind: :instance,
@@ -351,7 +358,7 @@ module RBS
         if decl.positional_init?
           attr_params = decl.each_attribute.map do |name, attr|
             RBS::Types::Function::Param.new(
-              type: attr&.type || Types::Bases::Any.new(location: nil),
+              type: attr&.type || default_type,
               name: name,
               location: nil
             )
@@ -376,7 +383,7 @@ module RBS
             [
               name,
               RBS::Types::Function::Param.new(
-                type: attr&.type || Types::Bases::Any.new(location: nil),
+                type: attr&.type || default_type,
                 name: nil,
                 location: nil
               )
@@ -405,7 +412,7 @@ module RBS
                     t.update(required_positionals: [
                       RBS::Types::Function::Param.new(
                         type: RBS::Types::Record.new(all_fields: decl.each_attribute.map do |name, attr|
-                          [name, attr&.type || Types::Bases::Any.new(location: nil)]
+                          [name, attr&.type || default_type]
                         end.to_h, location: nil),
                         name: nil,
                         location: nil
@@ -426,7 +433,12 @@ module RBS
           members: [*attributes, new],
           super_class: RBS::AST::Declarations::Class::Super.new(
             name: RBS::TypeName.new(name: :Struct, namespace: RBS::Namespace.empty),
-            args: [RBS::Types::Bases::Any.new(location: nil)],
+            args: [
+              RBS::Types::Union.new(
+                types: decl.each_attribute.map { |_, attr| attr&.type || default_type }.uniq,
+                location: nil
+              )
+            ],
             location: nil
           ),
           annotations: decl.class_annotations,
@@ -478,7 +490,7 @@ module RBS
           rbs << RBS::AST::Members::MethodDefinition.new(
             name: member.method_name,
             kind: kind,
-            overloads: member.method_overloads,
+            overloads: member.method_overloads(default_type),
             annotations: member.method_annotations,
             location: nil,
             comment: comment,
@@ -490,10 +502,11 @@ module RBS
             comment = RBS::AST::Comment.new(string: member.comments.content(trim: true), location: nil)
           end
 
+          kind = decl ? :singleton : :instance #: RBS::AST::Members::Alias::kind
           rbs << RBS::AST::Members::Alias.new(
             new_name: member.new_name,
             old_name: member.old_name,
-            kind: :instance,
+            kind: kind,
             annotations: [],
             location: nil,
             comment: comment
@@ -503,7 +516,7 @@ module RBS
             rbs << m
           end
         when AST::Members::RubyAttr
-          if m = member.rbs
+          if m = member.rbs(default_type)
             rbs.concat m
           end
         when AST::Members::RubyPrivate
@@ -542,6 +555,7 @@ module RBS
       # @rbs return: RBS::AST::Members::MethodDefinition::kind
       def method_kind(member, decl)
         return :singleton if decl
+        return :singleton_instance if member.singleton_instance
 
         case member.node.receiver
         when Prism::SelfNode
@@ -612,24 +626,19 @@ module RBS
       # @rbs decl: AST::Declarations::ConstantDecl
       # @rbs return: RBS::Types::t
       def constant_decl_to_type(decl)
-        type = decl.type
+        type = decl.type(default_type)
         return type unless type.is_a?(RBS::Types::ClassInstance)
         return type if type.args.any?
 
         case decl.node.value
         when Prism::ArrayNode
-          RBS::BuiltinNames::Array.instance_type(untyped)
+          RBS::BuiltinNames::Array.instance_type(default_type)
         when Prism::HashNode
-          RBS::BuiltinNames::Hash.instance_type(untyped, untyped)
+          RBS::BuiltinNames::Hash.instance_type(default_type, default_type)
         else
           type
         end
       end
-
-      # @rbs return: RBS::Types::Bases::Any
-      def untyped
-        @untyped ||= RBS::Types::Bases::Any.new(location: nil)
-      end
     end
   end
 end

data/rbs_collection.lock.yaml

@@ -34,7 +34,7 @@ gems:
   source:
     type: stdlib
 - name: prism
-  version: 1.0.0
+  version: 1.2.0
   source:
     type: rubygems
 - name: rake
@@ -42,11 +42,11 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 25b8cf2135233e112d93d6b64083ee5e419875b6
+    revision: 218cf130d31f63e110e350efc3fa265311b0f238
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rbs
-  version: 3.6.0
+  version: 3.6.1
   source:
     type: rubygems
 - name: rdoc

data/sig/generated/rbs/inline/ast/declarations.rbs

@@ -99,7 +99,7 @@ module RBS
           # @rbs %a{pure}
           # @rbs return: Types::t
           %a{pure}
-          def type: () -> Types::t
+          def type: (untyped default_type) -> Types::t
 
           # @rbs %a{pure}
           # @rbs return Types::t?

data/sig/generated/rbs/inline/ast/members.rbs

@@ -37,14 +37,18 @@ module RBS
           # ```
           attr_reader visibility: RBS::AST::Members::visibility?
 
+          # The function is defined as singleton and instance method (as known as module_function)
+          attr_accessor singleton_instance: bool
+
           # Assertion given at the end of the method name
           attr_reader assertion: Annotations::TypeAssertion?
 
           # @rbs node: Prism::DefNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs visibility: RBS::AST::Members::visibility?
+          # @rbs singleton_instance: bool
           # @rbs assertion: Annotations::TypeAssertion?
-          def initialize: (Prism::DefNode node, AnnotationParser::ParsingResult? comments, RBS::AST::Members::visibility? visibility, Annotations::TypeAssertion? assertion) -> void
+          def initialize: (Prism::DefNode node, AnnotationParser::ParsingResult? comments, RBS::AST::Members::visibility? visibility, bool singleton_instance, Annotations::TypeAssertion? assertion) -> void
 
           # Returns the name of the method
           def method_name: () -> Symbol
@@ -64,7 +68,8 @@ module RBS
 
           def overloading?: () -> bool
 
-          def method_overloads: () -> Array[RBS::AST::Members::MethodDefinition::Overload]
+          # @rbs (::RBS::Types::t default_type) -> Array[RBS::AST::Members::MethodDefinition::Overload]
+          def method_overloads: (::RBS::Types::t default_type) -> Array[RBS::AST::Members::MethodDefinition::Overload]
 
           def method_annotations: () -> Array[RBS::AST::Annotation]
 
@@ -120,21 +125,23 @@ module RBS
 
           attr_reader comments: AnnotationParser::ParsingResult?
 
+          attr_reader visibility: RBS::AST::Members::visibility?
+
           attr_reader assertion: Annotations::TypeAssertion?
 
           # @rbs node: Prism::CallNode
           # @rbs comments: AnnotationParser::ParsingResult?
+          # @rbs visibility: RBS::AST::Members::visibility?
           # @rbs assertion: Annotations::TypeAssertion?
           # @rbs return: void
-          def initialize: (Prism::CallNode node, AnnotationParser::ParsingResult? comments, Annotations::TypeAssertion? assertion) -> void
+          def initialize: (Prism::CallNode node, AnnotationParser::ParsingResult? comments, RBS::AST::Members::visibility? visibility, Annotations::TypeAssertion? assertion) -> void
 
           # @rbs return Array[RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter | RBS::AST::Members::AttrAccessor]?
-          def rbs: () -> Array[RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter | RBS::AST::Members::AttrAccessor]?
+          # @rbs default_type: RBS::Types::t
+          def rbs: (RBS::Types::t default_type) -> Array[RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter | RBS::AST::Members::AttrAccessor]?
 
           # Returns the type of the attribute
-          #
-          # Returns `untyped` when not annotated.
-          def attribute_type: () -> Types::t
+          def attribute_type: () -> Types::t?
         end
 
         # `private` call without arguments

data/sig/generated/rbs/inline/parser.rbs

@@ -30,6 +30,9 @@ module RBS
       # `nil` when the `def` node is not inside `private` or `public` calls.
       attr_reader current_visibility: RBS::AST::Members::visibility?
 
+      # The current module_function applied to single `def` node
+      attr_reader current_module_function: bool
+
       def initialize: () -> void
 
       # Parses the given Prism result to a three tuple

data/sig/generated/rbs/inline/writer.rbs

@@ -13,13 +13,16 @@ module RBS
 
       attr_reader writer: RBS::Writer
 
+      attr_accessor default_type: Types::t
+
       # @rbs buffer: String
       def initialize: (?String buffer) -> void
 
       # @rbs uses: Array[AST::Annotations::Use]
       # @rbs decls: Array[AST::Declarations::t]
       # @rbs rbs_decls: Array[RBS::AST::Declarations::t]
-      def self.write: (Array[AST::Annotations::Use] uses, Array[AST::Declarations::t] decls, Array[RBS::AST::Declarations::t] rbs_decls) -> void
+      # @rbs &: ? (Writer) -> void
+      def self.write: (Array[AST::Annotations::Use] uses, Array[AST::Declarations::t] decls, Array[RBS::AST::Declarations::t] rbs_decls) ?{ (Writer) -> void } -> void
 
       # @rbs *lines: String
       # @rbs return: void
@@ -111,9 +114,6 @@ module RBS
       # @rbs decl: AST::Declarations::ConstantDecl
       # @rbs return: RBS::Types::t
       def constant_decl_to_type: (AST::Declarations::ConstantDecl decl) -> RBS::Types::t
-
-      # @rbs return: RBS::Types::Bases::Any
-      def untyped: () -> RBS::Types::Bases::Any
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rbs-inline
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-01 00:00:00.000000000 Z
+date: 2025-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -19,7 +18,7 @@ dependencies:
         version: '0.29'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +28,7 @@ dependencies:
         version: '0.29'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -95,7 +94,6 @@ metadata:
   homepage_uri: https://github.com/soutaro/rbs-inline
   source_code_uri: https://github.com/soutaro/rbs-inline
   changelog_uri: https://github.com/soutaro/rbs-inline/blob/master/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -110,8 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Inline RBS type declaration.
 test_files: []