rbs 3.7.0 → 3.8.0.pre.1

data/ext/rbs_extension/parserstate.c

@@ -4,16 +4,26 @@
 
 id_table *alloc_empty_table(void) {
   id_table *table = malloc(sizeof(id_table));
-  table->size = 10;
-  table->count = 0;
-  table->ids = calloc(10, sizeof(ID));
+
+  *table = (id_table) {
+    .size = 10,
+    .count = 0,
+    .ids = calloc(10, sizeof(ID)),
+    .next = NULL,
+  };
 
   return table;
 }
 
 id_table *alloc_reset_table(void) {
   id_table *table = malloc(sizeof(id_table));
-  table->size = 0;
+
+  *table = (id_table) {
+    .size = 0,
+    .count = 0,
+    .ids = NULL,
+    .next = NULL,
+  };
 
   return table;
 }
@@ -182,15 +192,18 @@ VALUE get_comment(parserstate *state, int subject_line) {
 }
 
 comment *alloc_comment(token comment_token, comment *last_comment) {
-  comment *new_comment = calloc(1, sizeof(comment));
+  comment *new_comment = malloc(sizeof(comment));
 
-  new_comment->next_comment = last_comment;
+  *new_comment = (comment) {
+    .start = comment_token.range.start,
+    .end = comment_token.range.end,
 
-  new_comment->start = comment_token.range.start;
-  new_comment->end = comment_token.range.end;
+    .line_size = 0,
+    .line_count = 0,
+    .tokens = NULL,
 
-  new_comment->line_size = 0;
-  new_comment->line_count = 0;
+    .next_comment = last_comment,
+  };
 
   comment_insert_new_line(new_comment, comment_token);
 
@@ -279,11 +292,25 @@ lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos) {
     rb_raise(rb_eArgError, "negative position range: %d...%d", start_pos, end_pos);
   }
 
-  lexstate *lexer = calloc(1, sizeof(lexstate));
-  lexer->string = string;
-  lexer->current.line = 1;
-  lexer->start_pos = start_pos;
-  lexer->end_pos = end_pos;
+  lexstate *lexer = malloc(sizeof(lexstate));
+
+  position start_position = (position) {
+    .byte_pos = 0,
+    .char_pos = 0,
+    .line = 1,
+    .column = 0,
+  };
+
+  *lexer = (lexstate) {
+    .string = string,
+    .start_pos = start_pos,
+    .end_pos = end_pos,
+    .current = start_position,
+    .start = { 0 },
+    .first_token_of_line = false,
+    .last_char = 0,
+  };
+
   skipn(lexer, start_pos);
   lexer->start = lexer->current;
   lexer->first_token_of_line = lexer->current.column == 0;
@@ -292,13 +319,20 @@ lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos) {
 }
 
 parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_pos, VALUE variables) {
-  parserstate *parser = calloc(1, sizeof(parserstate));
-  parser->lexstate = lexer;
-  parser->buffer = buffer;
-  parser->current_token = NullToken;
-  parser->next_token = NullToken;
-  parser->next_token2 = NullToken;
-  parser->next_token3 = NullToken;
+  parserstate *parser = malloc(sizeof(parserstate));
+
+  *parser = (parserstate) {
+    .lexstate = lexer,
+
+    .current_token = NullToken,
+    .next_token = NullToken,
+    .next_token2 = NullToken,
+    .next_token3 = NullToken,
+    .buffer = buffer,
+
+    .vars = NULL,
+    .last_comment = NULL,
+  };
 
   parser_advance(parser);
   parser_advance(parser);

data/lib/rbs/annotate/annotations.rb

@@ -93,7 +93,7 @@ module RBS
           case
           when match = source.match(/(?<constant_name>[^#]+)#(?<method_name>.+)/)
             [
-              TypeName(match[:constant_name] || raise),
+              TypeName.parse(match[:constant_name] || raise),
               [
                 false,
                 (match[:method_name] or raise).to_sym
@@ -101,7 +101,7 @@ module RBS
             ]
           when match = source.match(/(?<constant_name>[^#]+)\.(?<method_name>.+)/)
             [
-              TypeName(match[:constant_name] || raise),
+              TypeName.parse(match[:constant_name] || raise),
               [
                 true,
                 (match[:method_name] or raise).to_sym
@@ -109,7 +109,7 @@ module RBS
             ]
           else
             [
-              TypeName(source),
+              TypeName.parse(source),
               nil
             ]
           end

data/lib/rbs/annotate/rdoc_source.rb

@@ -31,7 +31,7 @@ module RBS
       end
 
       def find_class(typename)
-        classes = []
+        classes = [] #: Array[::RDoc::ClassModule]
 
         @stores.each do |store|
           if klass = store.find_class_or_module(typename.relative!.to_s)
@@ -70,7 +70,7 @@ module RBS
       def find_const(const_name)
         namespace =
           if const_name.namespace.empty?
-            TypeName("::Object")
+            TypeName.parse("::Object")
           else
             const_name.namespace.to_type_name
           end

data/lib/rbs/cli/diff.rb

@@ -11,8 +11,8 @@ module RBS
         # @type var type_name: String?
         type_name = nil
         library_options = library_options
-        before_path = []
-        after_path = []
+        before_path = [] #: Array[String]
+        after_path = [] #: Array[String]
         detail = false
 
         opt = OptionParser.new do |o|
@@ -46,7 +46,7 @@ module RBS
         end
 
         @diff = RBS::Diff.new(
-          type_name: TypeName(type_name).absolute!,
+          type_name: TypeName.parse(type_name).absolute!,
           library_options: library_options,
           after_path: after_path,
           before_path: before_path,

data/lib/rbs/cli/validate.rb

@@ -52,7 +52,7 @@ module RBS
         loader = options.loader()
         @env = Environment.from_loader(loader).resolve_type_names
         @builder = DefinitionBuilder.new(env: @env)
-        @validator = Validator.new(env: @env, resolver: Resolver::TypeNameResolver.new(@env))
+        @validator = Validator.new(env: @env)
         exit_error = false
         limit = nil #: Integer?
         OptionParser.new do |opts|

data/lib/rbs/cli.rb

@@ -288,7 +288,7 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder::AncestorBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
 
       case env.constant_entry(type_name)
       when Environment::ClassEntry, Environment::ModuleEntry, Environment::ClassAliasEntry, Environment::ModuleAliasEntry
@@ -353,7 +353,7 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
 
       if env.module_name?(type_name)
         definition = case kind
@@ -406,7 +406,7 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
       method_name = args[1].to_sym
 
       unless env.module_name?(type_name)
@@ -479,9 +479,9 @@ EOU
       builder = DefinitionBuilder.new(env: env)
       resolver = Resolver::ConstantResolver.new(builder: builder)
 
-      resolver_context = context ? [nil, TypeName(context).absolute!] : nil #: Resolver::context
+      resolver_context = context ? [nil, TypeName.parse(context).absolute!] : nil #: Resolver::context
       stdout.puts "Context: #{context}"
-      const_name = TypeName(args[0])
+      const_name = TypeName.parse(args[0])
       stdout.puts "Constant name: #{const_name}"
 
       if const_name.absolute?
@@ -554,11 +554,11 @@ EOU
       when "rbi", "rb"
         run_prototype_file(format, args)
       when "runtime"
-        require_libs = []
-        relative_libs = []
+        require_libs = [] #: Array[String]
+        relative_libs = [] #: Array[String]
         merge = false
         todo = false
-        owners_included = []
+        owners_included = [] #: Array[Symbol]
         outline = false
         autoload = false
 
@@ -591,7 +591,7 @@ EOU
             todo = true
           end
           opts.on("--method-owner CLASS", "Generate method prototypes if the owner of the method is [CLASS]") do |klass|
-            owners_included << klass
+            owners_included << klass.to_sym
           end
           opts.on("--outline", "Generates only module/class/constant declaration (no method definition)") do
             outline = true
@@ -615,9 +615,9 @@ EOU
             ::Module.prepend(hook)
             ::Kernel.prepend(hook)
 
-            arguments = []
+            arguments = [] #: Array[[Module, interned]]
             TracePoint.new(:call) do |tp|
-              base = tp.self.kind_of?(Module) ? tp.self : Kernel
+              base = tp.self.kind_of?(Module) ? tp.self : Kernel #: Module
               name = (tp.binding or raise).local_variable_get(:name)
               arguments << [base, name]
             end.enable(target: hook.instance_method(:autoload), &block)
@@ -979,7 +979,7 @@ Options:
     end
 
     def test_opt options
-      opts = []
+      opts = [] #: Array[String]
 
       opts.push(*options.repos.map {|dir| "--repo #{Shellwords.escape(dir)}"})
       opts.push(*options.dirs.map {|dir| "-I #{Shellwords.escape(dir)}"})
@@ -1056,7 +1056,7 @@ EOB
       require 'bundler'
 
       opts = collection_options(args)
-      params = {}
+      params = {} #: Hash[Symbol, untyped]
       opts.order args.drop(1), into: params
       config_path = options.config_path or raise
       lock_path = Collection::Config.to_lockfile_path(config_path)

data/lib/rbs/collection/config.rb

@@ -72,7 +72,9 @@ module RBS
       end
 
       def gems
-        @data['gems'] ||= []
+        @data['gems'] ||= (
+          [] #: Array[gem_entry]
+        )
       end
     end
   end

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -209,7 +209,7 @@ module RBS
               super_args = super_class.args
             else
               super_name = BuiltinNames::Object.name
-              super_args = []
+              super_args = [] #: Array[Types::t]
             end
 
             super_name = env.normalize_module_name(super_name)
@@ -525,7 +525,7 @@ module RBS
 
         one_ancestors = one_singleton_ancestors(type_name)
 
-        ancestors = []
+        ancestors = [] #: Array[Definition::Ancestor::t]
 
         case super_class = one_ancestors.super_class
         when Definition::Ancestor::Instance
@@ -581,7 +581,7 @@ module RBS
         building_ancestors.push self_ancestor
 
         one_ancestors = one_interface_ancestors(type_name)
-        ancestors = []
+        ancestors = [] #: Array[Definition::Ancestor::t]
 
         included_interfaces = one_ancestors.included_interfaces or raise
         included_interfaces.each do |a|

data/lib/rbs/environment_loader.rb

@@ -26,7 +26,7 @@ module RBS
     DEFAULT_CORE_ROOT = Pathname(_ = __dir__) + "../../core"
 
     def self.gem_sig_path(name, version)
-      requirements = []
+      requirements = [] #: Array[String]
       requirements << version if version
       spec = Gem::Specification.find_by_name(name, *requirements)
       path = Pathname(spec.gem_dir) + "sig"

data/lib/rbs/namespace.rb

@@ -119,6 +119,7 @@ end
 
 module Kernel
   def Namespace(name)
+    warn "Kernel#Namespace() is deprecated. Use RBS::Namespace.parse instead.", category: :deprecated
     RBS::Namespace.parse(name)
   end
 end

data/lib/rbs/parser_aux.rb

@@ -70,8 +70,8 @@ module RBS
       untyped
       true
       false
-      ).each_with_object({}) do |keyword, hash|
-        hash[keyword] = nil
+      ).each_with_object({}) do |keyword, hash| #$ Hash[String, bot]
+        hash[keyword] = _ = nil
       end
   end
 end

data/lib/rbs/prototype/rb.rb

@@ -75,8 +75,8 @@ module RBS
       def parse(string)
         # @type var comments: Hash[Integer, AST::Comment]
         comments = Ripper.lex(string).yield_self do |tokens|
-          code_lines = {}
-          tokens.each.with_object({}) do |token, hash|
+          code_lines = {} #: Hash[Integer, bool]
+          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
             case token[1]
             when :on_sp, :on_ignored_nl
               # skip
@@ -643,11 +643,11 @@ module RBS
             children = list.children
             children.pop
           else
-            children = []
+            children = [] #: Array[untyped]
           end
 
-          key_types = []
-          value_types = []
+          key_types = [] #: Array[Types::t]
+          value_types = [] #: Array[Types::t]
           children.each_slice(2) do |k, v|
             if k
               key_types << literal_to_type(k)
@@ -659,7 +659,10 @@ module RBS
           end
 
           if !key_types.empty? && key_types.all? { |t| t.is_a?(Types::Literal) }
-            fields = key_types.map { |t| t.literal }.zip(value_types).to_h
+            fields = key_types.map {|t|
+              t.is_a?(Types::Literal) or raise
+              t.literal
+            }.zip(value_types).to_h #: Hash[Types::Literal::literal, Types::t]
             Types::Record.new(fields: fields, location: nil)
           else
             key_type = types_to_union_type(key_types)
@@ -719,9 +722,9 @@ module RBS
         when :FLOAT
           BuiltinNames::Float.instance_type
         when :RATIONAL
-          Types::ClassInstance.new(name: TypeName("::Rational"), args: [], location: nil)
+          Types::ClassInstance.new(name: TypeName.parse("::Rational"), args: [], location: nil)
         when :IMAGINARY
-          Types::ClassInstance.new(name: TypeName("::Complex"), args: [], location: nil)
+          Types::ClassInstance.new(name: TypeName.parse("::Complex"), args: [], location: nil)
         when :LIT
           case node.children[0]
           when Symbol

data/lib/rbs/prototype/rbi.rb

@@ -17,9 +17,7 @@ module RBS
 
       def parse(string)
         comments = Ripper.lex(string).yield_self do |tokens|
-          tokens.each.with_object({}) do |token, hash|
-            # @type var hash: Hash[Integer, AST::Comment]
-
+          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
             if token[1] == :on_comment
               line = token[0][0]
               body = token[2][2..-1] or raise
@@ -325,11 +323,17 @@ module RBS
               end
             end
           when :type_parameters
-            type_params = []
+            type_params = [] #: Array[AST::TypeParam]
 
             each_arg args do |node|
               if name = symbol_literal_node?(node)
-                type_params << name
+                type_params << AST::TypeParam.new(
+                  name: name,
+                  variance: :invariant,
+                  upper_bound: nil,
+                  location: nil,
+                  default_type: nil
+                )
               end
             end
 

data/lib/rbs/prototype/runtime/value_object_generator.rb

@@ -80,7 +80,9 @@ module RBS
               kind: :instance,
               location: nil,
               comment: nil,
-              annotations: []
+              annotations: (
+                [] #: Array[AST::Annotation]
+              )
             )
           end
         end
@@ -100,7 +102,7 @@ module RBS
         CAN_CALL_KEYWORD_INIT_P = Struct.new(:tmp).respond_to?(:keyword_init?)
 
         def build_super_class
-          AST::Declarations::Class::Super.new(name: TypeName("::Struct"), args: [untyped], location: nil)
+          AST::Declarations::Class::Super.new(name: TypeName.parse("::Struct"), args: [untyped], location: nil)
         end
 
         def add_decl_members(decl)
@@ -114,7 +116,7 @@ module RBS
         #             | (?foo: untyped, ?bar: untyped) -> instance
         def build_s_new
           [:new, :[]].map do |name|
-            new_overloads = []
+            new_overloads = [] #: Array[AST::Members::MethodDefinition::Overload]
 
             if CAN_CALL_KEYWORD_INIT_P
               case @target_class.keyword_init?
@@ -221,7 +223,7 @@ module RBS
         private
 
         def build_super_class
-          AST::Declarations::Class::Super.new(name: TypeName("::Data"), args: [], location: nil)
+          AST::Declarations::Class::Super.new(name: TypeName.parse("::Data"), args: [], location: nil)
         end
 
         def add_decl_members(decl)
@@ -234,7 +236,7 @@ module RBS
         #             | (foo: untyped, bar: untyped) -> instance
         def build_s_new
           [:new, :[]].map do |name|
-            new_overloads = []
+            new_overloads = [] #: Array[AST::Members::MethodDefinition::Overload]
 
             new_overloads << AST::Members::MethodDefinition::Overload.new(
               annotations: [],

data/lib/rbs/prototype/runtime.rb

@@ -48,7 +48,8 @@ module RBS
 
         def mixin_decls(type_name)
           type_name_absolute = type_name.absolute!
-          (@mixin_decls_cache ||= {}).fetch(type_name_absolute) do
+          @mixin_decls_cache ||= {} #: Hash[TypeName, Array[AST::Members::Mixin]]
+          @mixin_decls_cache.fetch(type_name_absolute) do
             @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].decls.flat_map do |d|
               d.decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
             end
@@ -448,9 +449,9 @@ module RBS
                      location: nil
                    )
                  when ARGF
-                   Types::ClassInstance.new(name: TypeName("::RBS::Unnamed::ARGFClass"), args: [], location: nil)
+                   Types::ClassInstance.new(name: TypeName.parse("::RBS::Unnamed::ARGFClass"), args: [], location: nil)
                  when ENV
-                   Types::ClassInstance.new(name: TypeName("::RBS::Unnamed::ENVClass"), args: [], location: nil)
+                   Types::ClassInstance.new(name: TypeName.parse("::RBS::Unnamed::ENVClass"), args: [], location: nil)
                  else
                    value_type_name = to_type_name(const_name!(Reflection.object_class(value)), full_name: true).absolute!
                    args = type_args(value_type_name)
@@ -648,8 +649,6 @@ module RBS
       end
 
       def block_from_ast_of(method)
-        return nil if RUBY_VERSION < '3.1'
-
         begin
           ast = RubyVM::AbstractSyntaxTree.of(method)
         rescue ArgumentError

data/lib/rbs/type_name.rb

@@ -86,19 +86,24 @@ module RBS
         )
       end
     end
+    
+    def self.parse(string)
+      absolute = string.start_with?("::")
+
+      *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
+      raise unless name
+
+      TypeName.new(
+        name: name,
+        namespace: RBS::Namespace.new(path: path, absolute: absolute)
+      )
+    end
   end
 end
 
 module Kernel
   def TypeName(string)
-    absolute = string.start_with?("::")
-
-    *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
-    raise unless name
-
-    RBS::TypeName.new(
-      name: name,
-      namespace: RBS::Namespace.new(path: path, absolute: absolute)
-    )
+    warn "Kernel#TypeName() is deprecated. Use RBS::TypeName.parse instead.", category: :deprecated
+    RBS::TypeName.parse(string)
   end
 end

data/lib/rbs/unit_test/type_assertions.rb

@@ -15,7 +15,7 @@ module RBS
           @target = nil
         end
 
-        @@env_cache = {}
+        @@env_cache = {} #: Hash[Array[String], RBS::Environment]
 
         def env
           @env = @@env_cache[@libs] ||=
@@ -271,7 +271,7 @@ module RBS
 
         assert typecheck.value(constant, value_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with given type `#{value_type}`"
 
-        type_name = TypeName(constant_name).absolute!
+        type_name = TypeName.parse(constant_name).absolute!
         definition = env.constant_entry(type_name)
         assert definition, "Cannot find RBS type definition of `#{constant_name}`"
 

data/lib/rbs/validator.rb

@@ -6,13 +6,15 @@ module RBS
     attr_reader :resolver
     attr_reader :definition_builder
 
-    def initialize(env:, resolver:)
+    def initialize(env:, resolver: nil)
       @env = env
       @resolver = resolver
       @definition_builder = DefinitionBuilder.new(env: env)
     end
 
     def absolute_type(type, context:, &block)
+      return type unless resolver
+
       type.map_type_name do |type_name, _, type|
         resolver.resolve(type_name, context: context) || (block ? yield(type) : type_name)
       end

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.7.0"
+  VERSION = "3.8.0.pre.1"
 end

data/lib/rdoc_plugin/parser.rb

@@ -108,7 +108,7 @@ module RBS
 
       def parse_include_decl(decl:, context:, outer_name: nil)
         name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : []
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
         qualified_name = ''
         outer_names.each do |namespace|
           qualified_name += namespace
@@ -124,7 +124,7 @@ module RBS
 
       def parse_extend_decl(decl:, context:, outer_name: nil)
         name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : []
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
         qualified_name = ''
         outer_names.each do |namespace|
           qualified_name += namespace

data/rbs.gemspec

@@ -37,6 +37,10 @@ Gem::Specification.new do |spec|
   end
   spec.extensions = %w{ext/rbs_extension/extconf.rb}
 
+  if false
+    spec.required_ruby_version = ">= 3.3"
+  end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/sig/ancestor_graph.rbs

@@ -4,11 +4,11 @@ module RBS
   # ```ruby
   # graph = AncestorGraph.new(env: env, ancestor_builder: ancestor_builder)
   #
-  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
-  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
   #
-  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
-  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
   # ```
   #
   # Note that the class works for class/module declarations.

data/sig/namespace.rbs

@@ -141,7 +141,6 @@ module RBS
 end
 
 module Kernel
-  # Parses given string and returns Namespace.
-  #
-  def Namespace: (String) -> RBS::Namespace
+  # Deprecated: Use `RBS::Namespace.parse` instead
+  %a{steep:deprecated} def Namespace: (String) -> RBS::Namespace
 end

data/sig/resolver/constant_resolver.rbs

@@ -6,8 +6,8 @@ module RBS
       # ```rb
       # table = RBS::ConstantResolver::Table.new(env)
       #
-      # table.children(TypeName("::Object"))                # -> { ... }  Returns a hash of name and constants.
-      # table.children(TypeName("::File::PATH_SEPARATOR"))  # -> nil      Returns nil because the constant is not a module.
+      # table.children(TypeName.parse("::Object"))                # -> { ... }  Returns a hash of name and constants.
+      # table.children(TypeName.parse("::File::PATH_SEPARATOR"))  # -> nil      Returns nil because the constant is not a module.
       #
       # table.toplevel                                      # -> { ... }  Returns a hash of top level constants.
       # ```