rbs 2.8.4 → 3.8.1

data/lib/rbs/prototype/rb.rb

@@ -5,11 +5,11 @@ module RBS
     class RB
       include Helpers
 
-      Context = _ = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
+      class Context < Struct.new(:module_function, :singleton, :namespace, :in_def, keyword_init: true)
         # @implements Context
 
         def self.initial(namespace: Namespace.root)
-          self.new(module_function: false, singleton: false, namespace: namespace)
+          self.new(module_function: false, singleton: false, namespace: namespace, in_def: false)
         end
 
         def method_kind
@@ -29,6 +29,14 @@ module RBS
             :instance
           end
         end
+
+        def enter_namespace(namespace)
+          Context.initial(namespace: self.namespace + namespace)
+        end
+
+        def update(module_function: self.module_function, singleton: self.singleton, in_def: self.in_def)
+          Context.new(module_function: module_function, singleton: singleton, namespace: namespace, in_def: in_def)
+        end
       end
 
       attr_reader :source_decls
@@ -67,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
@@ -81,8 +89,7 @@ module RBS
               body = "\n" if body.empty?
 
               comment = AST::Comment.new(string: body, location: nil)
-              if (prev_comment = hash[line - 1])
-                hash[line - 1] = nil
+              if prev_comment = hash.delete(line - 1)
                 hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
                                               location: nil)
               else
@@ -121,11 +128,12 @@ module RBS
 
           decls.push kls
 
-          new_ctx = Context.initial(namespace: context.namespace + kls.name.to_namespace)
+          new_ctx = context.enter_namespace(kls.name.to_namespace)
           each_node class_body do |child|
             process child, decls: kls.members, comments: comments, context: new_ctx
           end
           remove_unnecessary_accessibility_methods! kls.members
+          sort_members! kls.members
 
         when :MODULE
           module_name, *module_body = node.children
@@ -142,11 +150,12 @@ module RBS
 
           decls.push mod
 
-          new_ctx = Context.initial(namespace: context.namespace + mod.name.to_namespace)
+          new_ctx = context.enter_namespace(mod.name.to_namespace)
           each_node module_body do |child|
             process child, decls: mod.members, comments: comments, context: new_ctx
           end
           remove_unnecessary_accessibility_methods! mod.members
+          sort_members! mod.members
 
         when :SCLASS
           this, body = node.children
@@ -186,14 +195,20 @@ module RBS
             name: def_name,
             location: nil,
             annotations: [],
-            types: types,
+            overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type )},
             kind: kind,
             comment: comments[node.first_lineno - 1],
-            overload: false
+            overloading: false,
+            visibility: nil
           )
 
           decls.push member unless decls.include?(member)
 
+          new_ctx = context.update(singleton: kind == :singleton, in_def: true)
+          each_node def_body.children do |child|
+            process child, decls: decls, comments: comments, context: new_ctx
+          end
+
         when :ALIAS
           new_name, old_name = node.children.map { |c| literal_to_symbol(c) }
           member = AST::Members::Alias.new(
@@ -214,7 +229,8 @@ module RBS
           when :include
             args.each do |arg|
               if (name = const_to_name(arg, context: context))
-                decls << AST::Members::Include.new(
+                klass = context.singleton ? AST::Members::Extend : AST::Members::Include
+                decls << klass.new(
                   name: name,
                   args: [],
                   annotations: [],
@@ -304,7 +320,7 @@ module RBS
             if args.empty?
               context.module_function = true
             else
-              module_func_context = context.dup.tap { |ctx| ctx.module_function = true }
+              module_func_context = context.update(module_function: true)
               args.each do |arg|
                 if arg && (name = literal_to_symbol(arg))
                   if (i, defn = find_def_index_by_name(decls, name))
@@ -345,20 +361,14 @@ module RBS
           end
 
         when :ITER
-          method_name = node.children.first.children.first
-          case method_name
-          when :refine
-            # ignore
-          else
-            process_children(node, decls: decls, comments: comments, context: context)
-          end
+          # ignore
 
         when :CDECL
           const_name = case
                        when node.children[0].is_a?(Symbol)
                          TypeName.new(name: node.children[0], namespace: Namespace.empty)
                        else
-                         const_to_name!(node.children[0])
+                         const_to_name!(node.children[0], context: context)
                        end
 
           value_node = node.children.last
@@ -375,6 +385,39 @@ module RBS
             comment: comments[node.first_lineno - 1]
           )
 
+        when :IASGN
+          case [context.singleton, context.in_def]
+          when [true, true], [false, false]
+            member = AST::Members::ClassInstanceVariable.new(
+              name: node.children.first,
+              type: Types::Bases::Any.new(location: nil),
+              location: nil,
+              comment: comments[node.first_lineno - 1]
+            )
+          when [false, true]
+            member = AST::Members::InstanceVariable.new(
+              name: node.children.first,
+              type: Types::Bases::Any.new(location: nil),
+              location: nil,
+              comment: comments[node.first_lineno - 1]
+            )
+          when [true, false]
+            # The variable is for the singleton class of the class object.
+            # RBS does not have a way to represent it. So we ignore it.
+          else
+            raise 'unreachable'
+          end
+
+          decls.push member if member && !decls.include?(member)
+
+        when :CVASGN
+          member = AST::Members::ClassVariable.new(
+            name: node.children.first,
+            type: Types::Bases::Any.new(location: nil),
+            location: nil,
+            comment: comments[node.first_lineno - 1]
+          )
+          decls.push member unless decls.include?(member)
         else
           process_children(node, decls: decls, comments: comments, context: context)
         end
@@ -386,13 +429,13 @@ module RBS
         end
       end
 
-      def const_to_name!(node)
+      def const_to_name!(node, context: nil)
         case node.type
         when :CONST
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
         when :COLON2
           if node.children[0]
-            namespace = const_to_name!(node.children[0]).to_namespace
+            namespace = const_to_name!(node.children[0], context: context).to_namespace
           else
             namespace = Namespace.empty
           end
@@ -400,6 +443,10 @@ module RBS
           TypeName.new(name: node.children[1], namespace: namespace)
         when :COLON3
           TypeName.new(name: node.children[0], namespace: Namespace.root)
+        when :SELF
+          raise if context.nil?
+
+          context.namespace.to_type_name
         else
           raise
         end
@@ -411,13 +458,15 @@ module RBS
           when :SELF
             context.namespace.to_type_name
           when :CONST, :COLON2, :COLON3
-            const_to_name!(node)
+            const_to_name!(node) rescue nil
           end
         end
       end
 
       def literal_to_symbol(node)
         case node.type
+        when :SYM
+          node.children[0]
         when :LIT
           node.children[0] if node.children[0].is_a?(Symbol)
         when :STR
@@ -452,7 +501,7 @@ module RBS
         end
 
         if rest
-          rest_name = rest == :* ? nil : rest # # For `def f(...) end` syntax
+          rest_name = rest == :* ? nil : rest # `def f(...)` syntax has `*` name
           fun = fun.update(rest_positionals: Types::Function::Param.new(name: rest_name, type: untyped))
         end
 
@@ -475,7 +524,9 @@ module RBS
         end
 
         if kwrest && kwrest.children.any?
-          fun = fun.update(rest_keywords: Types::Function::Param.new(name: kwrest.children[0], type: untyped))
+          kwrest_name = kwrest.children[0] #: Symbol?
+          kwrest_name = nil if kwrest_name == :** # `def f(...)` syntax has `**` name
+          fun = fun.update(rest_keywords: Types::Function::Param.new(name: kwrest_name, type: untyped))
         end
 
         fun
@@ -531,9 +582,16 @@ module RBS
           end
         when :DSTR, :XSTR
           BuiltinNames::String.instance_type
+        when :SYM
+          lit = node.children[0]
+          if lit.to_s.ascii_only?
+            Types::Literal.new(literal: lit, location: nil)
+          else
+            BuiltinNames::Symbol.instance_type
+          end
         when :DSYM
           BuiltinNames::Symbol.instance_type
-        when :DREGX
+        when :DREGX, :REGX
           BuiltinNames::Regexp.instance_type
         when :TRUE
           Types::Literal.new(literal: true, location: nil)
@@ -541,6 +599,14 @@ module RBS
           Types::Literal.new(literal: false, location: nil)
         when :NIL
           Types::Bases::Nil.new(location: nil)
+        when :INTEGER
+          Types::Literal.new(literal: node.children[0], location: nil)
+        when :FLOAT
+          BuiltinNames::Float.instance_type
+        when :RATIONAL, :IMAGINARY
+          lit = node.children[0]
+          type_name = TypeName.new(name: lit.class.name.to_sym, namespace: Namespace.root)
+          Types::ClassInstance.new(name: type_name, args: [], location: nil)
         when :LIT
           lit = node.children[0]
           case lit
@@ -552,6 +618,11 @@ module RBS
             end
           when Integer
             Types::Literal.new(literal: lit, location: nil)
+          when String
+            # For Ruby <=3.3 which generates `LIT` node for string literals inside Hash literal.
+            # "a"             => STR node
+            # { "a" => nil }  => LIT node
+            Types::Literal.new(literal: lit, location: nil)
           else
             type_name = TypeName.new(name: lit.class.name.to_sym, namespace: Namespace.root)
             Types::ClassInstance.new(name: type_name, args: [], location: nil)
@@ -572,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)
@@ -588,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)
@@ -627,7 +701,7 @@ module RBS
 
         types = types.map do |t|
           if t.is_a?(Types::Literal)
-            type_name = TypeName.new(name: t.literal.class.name.to_sym, namespace: Namespace.root)
+            type_name = TypeName.new(name: t.literal.class.name&.to_sym || raise, namespace: Namespace.root)
             Types::ClassInstance.new(name: type_name, args: [], location: nil)
           else
             t
@@ -643,6 +717,14 @@ module RBS
 
       def param_type(node, default: Types::Bases::Any.new(location: nil))
         case node.type
+        when :INTEGER
+          BuiltinNames::Integer.instance_type
+        when :FLOAT
+          BuiltinNames::Float.instance_type
+        when :RATIONAL
+          Types::ClassInstance.new(name: TypeName.parse("::Rational"), args: [], location: nil)
+        when :IMAGINARY
+          Types::ClassInstance.new(name: TypeName.parse("::Complex"), args: [], location: nil)
         when :LIT
           case node.children[0]
           when Symbol
@@ -654,6 +736,8 @@ module RBS
           else
             default
           end
+        when :SYM
+          BuiltinNames::Symbol.instance_type
         when :STR, :DSTR
           BuiltinNames::String.instance_type
         when :NIL
@@ -741,6 +825,16 @@ module RBS
           ]
         end
       end
+
+      def sort_members!(decls)
+        i = 0
+        orders = {
+          AST::Members::ClassVariable => -3,
+          AST::Members::ClassInstanceVariable => -2,
+          AST::Members::InstanceVariable => -1,
+        } #: Hash[Class, Integer]
+        decls.sort_by! { |decl| [orders.fetch(decl.class, 0), i += 1] }
+      end
     end
   end
 end

data/lib/rbs/prototype/rbi.rb

@@ -3,6 +3,8 @@
 module RBS
   module Prototype
     class RBI
+      include Helpers
+
       attr_reader :decls
       attr_reader :modules
       attr_reader :last_sig
@@ -15,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
@@ -185,10 +185,11 @@ module RBS
               name: node.children[1],
               location: nil,
               annotations: [],
-              types: types,
+              overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type) },
               kind: :singleton,
               comment: comment,
-              overload: false
+              overloading: false,
+              visibility: nil
             )
           end
 
@@ -205,10 +206,11 @@ module RBS
               name: node.children[0],
               location: nil,
               annotations: [],
-              types: types,
+              overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type) },
               kind: :instance,
               comment: comment,
-              overload: false
+              overloading: false,
+              visibility: nil
             )
           end
 
@@ -216,11 +218,11 @@ module RBS
           if (send = node.children.last) && send.type == :FCALL && send.children[0] == :type_member
             unless each_arg(send.children[1]).any? {|node|
               node.type == :HASH &&
-                each_arg(node.children[0]).each_slice(2).any? {|a, _| a.type == :LIT && a.children[0] == :fixed }
+                each_arg(node.children[0]).each_slice(2).any? {|a, _| symbol_literal_node?(a) == :fixed }
             }
               # @type var variance: AST::TypeParam::variance?
-              if (a0 = each_arg(send.children[1]).to_a[0]) && a0.type == :LIT
-                variance = case a0.children[0]
+              if (a0 = each_arg(send.children[1]).to_a[0]) && (v = symbol_literal_node?(a0))
+                variance = case v
                            when :out
                              :covariant
                            when :in
@@ -232,7 +234,8 @@ module RBS
                 name: node.children[0],
                 variance: variance || :invariant,
                 location: nil,
-                upper_bound: nil
+                upper_bound: nil,
+                default_type: nil
               )
             end
           else
@@ -244,7 +247,7 @@ module RBS
               end
             end
             value_node = node.children.last
-            type = if value_node.type == :CALL && value_node.children[1] == :let
+            type = if value_node && value_node.type == :CALL && value_node.children[1] == :let
                      type_node = each_arg(value_node.children[2]).to_a[1]
                      type_of type_node, variables: current_module&.type_params || []
                    else
@@ -313,14 +316,24 @@ module RBS
                 Types::Function::Param.new(name: name, type: type)
               end
 
-              method_type.update(type: method_type.type.update(required_positionals: required_positionals))
+              if method_type.type.is_a?(RBS::Types::Function)
+                method_type.update(type: method_type.type.update(required_positionals: required_positionals))
+              else
+                method_type
+              end
             end
           when :type_parameters
-            type_params = []
+            type_params = [] #: Array[AST::TypeParam]
 
             each_arg args do |node|
-              if node.type == :LIT
-                type_params << node.children[0]
+              if name = symbol_literal_node?(node)
+                type_params << AST::TypeParam.new(
+                  name: name,
+                  variance: :invariant,
+                  upper_bound: nil,
+                  location: nil,
+                  default_type: nil
+                )
               end
             end
 
@@ -442,18 +455,22 @@ module RBS
           end
         end
 
-        method_type.update(
-          type: method_type.type.update(
-            required_positionals: required_positionals,
-            optional_positionals: optional_positionals,
-            rest_positionals: rest_positionals,
-            trailing_positionals: trailing_positionals,
-            required_keywords: required_keywords,
-            optional_keywords: optional_keywords,
-            rest_keywords: rest_keywords
-          ),
-          block: method_block
-        )
+        if method_type.type.is_a?(Types::Function)
+          method_type.update(
+            type: method_type.type.update(
+              required_positionals: required_positionals,
+              optional_positionals: optional_positionals,
+              rest_positionals: rest_positionals,
+              trailing_positionals: trailing_positionals,
+              required_keywords: required_keywords,
+              optional_keywords: optional_keywords,
+              rest_keywords: rest_keywords
+            ),
+            block: method_block
+          )
+        else
+          method_type
+        end
       end
 
       def type_of(type_node, variables:)
@@ -477,7 +494,7 @@ module RBS
           else
             Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
           end
-        when type_node.type == :COLON2
+        when type_node.type == :COLON2 || type_node.type == :COLON3
           Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
         when call_node?(type_node, name: :[], receiver: -> (_) { true })
           # The type_node represents a type application
@@ -551,11 +568,7 @@ module RBS
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
         when :COLON2
           if node.children[0]
-            if node.children[0].type == :COLON3
-              namespace = Namespace.root
-            else
-              namespace = const_to_name(node.children[0]).to_namespace
-            end
+            namespace = const_to_name(node.children[0]).to_namespace
           else
             namespace = Namespace.empty
           end
@@ -615,8 +628,8 @@ module RBS
           each_arg(node.children[0]).each_slice(2) do |var, type|
             var or raise
 
-            if var.type == :LIT && type
-              hash[var.children[0]] = type
+            if (name = symbol_literal_node?(var)) && type
+              hash[name] = type
             end
           end
 

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RBS
+  module Prototype
+    class Runtime
+      module Helpers
+        private
+
+        # Returns the exact name & not compactly declared name
+        def only_name(mod)
+          # No nil check because this method is invoked after checking if the module exists
+          const_name!(mod).split(/::/).last or raise # (A::B::C) => C
+        end
+
+        def const_name!(const)
+          const_name(const) or raise
+        end
+
+        def const_name(const)
+          @module_name_method ||= Module.instance_method(:name)
+          name = @module_name_method.bind(const).call
+          return nil unless name
+
+          begin
+            deprecated, Warning[:deprecated] = Warning[:deprecated], false
+            Object.const_get(name)
+          rescue NameError
+            # Should generate const name if anonymous or internal module (e.g. NameError::message)
+            nil
+          else
+            name
+          ensure
+            Warning[:deprecated] = deprecated
+          end
+        end
+
+        def to_type_name(name, full_name: false)
+          *prefix, last = name.split(/::/)
+
+          last or raise
+
+          if full_name
+            if prefix.empty?
+              TypeName.new(name: last.to_sym, namespace: Namespace.empty)
+            else
+              TypeName.new(name: last.to_sym, namespace: Namespace.parse(prefix.join("::")))
+            end
+          else
+            TypeName.new(name: last.to_sym, namespace: Namespace.empty)
+          end
+        end
+
+        def untyped
+          @untyped ||= Types::Bases::Any.new(location: nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RBS
+  module Prototype
+    class Runtime
+      module Reflection
+        def self.object_class(value)
+          @object_class ||= Object.instance_method(:class)
+          @object_class.bind_call(value)
+        end
+
+        def self.constants_of(mod, inherit = true)
+          @constants_of ||= Module.instance_method(:constants)
+          @constants_of.bind_call(mod, inherit)
+        end
+      end
+    end
+  end
+end