rbs 1.1.1 → 1.3.1

data/lib/rbs/prototype/rb.rb

@@ -148,7 +148,7 @@ module RBS
             types = [
               MethodType.new(
                 type_params: [],
-                type: function_type_from_body(def_body),
+                type: function_type_from_body(def_body, def_name),
                 block: block_from_body(def_body),
                 location: nil
               )
@@ -377,12 +377,16 @@ module RBS
         each_node node.children, &block
       end
 
-      def function_type_from_body(node)
+      def function_type_from_body(node, def_name)
         table_node, args_node, *_ = node.children
 
         pre_num, _pre_init, opt, _first_post, post_num, _post_init, rest, kw, kwrest, _block = args_from_node(args_node)
 
-        return_type = function_return_type_from_body(node)
+        return_type = if def_name == :initialize
+                        Types::Bases::Void.new(location: nil)
+                      else
+                        function_return_type_from_body(node)
+                      end
 
         fun = Types::Function.empty(return_type)
 

data/lib/rbs/prototype/runtime.rb

@@ -9,6 +9,7 @@ module RBS
       def initialize(patterns:, env:, merge:, owners_included: [])
         @patterns = patterns
         @decls = nil
+        @modules = []
         @env = env
         @merge = merge
         @owners_included = owners_included.map do |name|
@@ -39,7 +40,8 @@ module RBS
       def decls
         unless @decls
           @decls = []
-          ObjectSpace.each_object(Module).select {|mod| target?(mod) }.sort_by{|mod| const_name(mod) }.each do |mod|
+          @modules = ObjectSpace.each_object(Module).to_a
+          @modules.select {|mod| target?(mod) }.sort_by{|mod| const_name(mod) }.each do |mod|
             case mod
             when Class
               generate_class mod
@@ -48,16 +50,21 @@ module RBS
             end
           end
         end
+
         @decls
       end
 
-      def to_type_name(name)
+      def to_type_name(name, full_name: false)
         *prefix, last = name.split(/::/)
 
-        if prefix.empty?
-          TypeName.new(name: last.to_sym, namespace: Namespace.empty)
+        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.parse(prefix.join("::")))
+          TypeName.new(name: last.to_sym, namespace: Namespace.empty)
         end
       end
 
@@ -131,6 +138,11 @@ module RBS
           end
         end
 
+        return_type = if method.name == :initialize
+                        Types::Bases::Void.new(location: nil)
+                      else
+                        untyped
+                      end
         method_type = Types::Function.new(
           required_positionals: required_positionals,
           optional_positionals: optional_positionals,
@@ -139,7 +151,7 @@ module RBS
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
-          return_type: untyped
+          return_type: return_type,
         )
 
         MethodType.new(
@@ -300,7 +312,7 @@ module RBS
         end
       end
 
-      def generate_constants(mod)
+      def generate_constants(mod, decls)
         mod.constants(false).sort.each do |name|
           value = mod.const_get(name)
 
@@ -324,8 +336,8 @@ module RBS
                    Types::ClassInstance.new(name: value_type_name, args: args, location: nil)
                  end
 
-          @decls << AST::Declarations::Constant.new(
-            name: "#{const_name(mod)}::#{name}",
+          decls << AST::Declarations::Constant.new(
+            name: name,
             type: type,
             location: nil,
             comment: nil
@@ -333,28 +345,38 @@ module RBS
         end
       end
 
+      def generate_super_class(mod)
+        if mod.superclass == ::Object
+          nil
+        elsif const_name(mod.superclass).nil?
+          RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
+          nil
+        else
+          super_name = to_type_name(const_name(mod.superclass), full_name: true)
+          super_args = type_args(super_name)
+          AST::Declarations::Class::Super.new(name: super_name, args: super_args, location: nil)
+        end
+      end
+
       def generate_class(mod)
         type_name = to_type_name(const_name(mod))
-        super_class = if mod.superclass == ::Object
-                        nil
-                      elsif const_name(mod.superclass).nil?
-                        RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
-                        nil
-                      else
-                        super_name = to_type_name(const_name(mod.superclass))
-                        super_args = type_args(super_name)
-                        AST::Declarations::Class::Super.new(name: super_name, args: super_args, location: nil)
-                      end
+        outer_decls = ensure_outer_module_declarations(mod)
+
+        # Check if a declaration exists for the actual module
+        decl = outer_decls.detect { |decl| decl.is_a?(AST::Declarations::Class) && decl.name.name == only_name(mod).to_sym }
+        unless decl
+          decl = AST::Declarations::Class.new(
+            name: to_type_name(only_name(mod)),
+            type_params: AST::Declarations::ModuleTypeParams.empty,
+            super_class: generate_super_class(mod),
+            members: [],
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
 
-        decl = AST::Declarations::Class.new(
-          name: type_name,
-          type_params: AST::Declarations::ModuleTypeParams.empty,
-          super_class: super_class,
-          members: [],
-          annotations: [],
-          location: nil,
-          comment: nil
-        )
+          outer_decls << decl
+        end
 
         each_included_module(type_name, mod) do |module_name, module_full_name, _|
           args = type_args(module_full_name)
@@ -380,9 +402,7 @@ module RBS
 
         generate_methods(mod, type_name, decl.members)
 
-        @decls << decl
-
-        generate_constants mod
+        generate_constants mod, decl.members
       end
 
       def generate_module(mod)
@@ -394,16 +414,23 @@ module RBS
         end
 
         type_name = to_type_name(name)
+        outer_decls = ensure_outer_module_declarations(mod)
+
+        # Check if a declaration exists for the actual class
+        decl = outer_decls.detect { |decl| decl.is_a?(AST::Declarations::Module) && decl.name.name == only_name(mod).to_sym }
+        unless decl
+          decl = AST::Declarations::Module.new(
+            name: to_type_name(only_name(mod)),
+            type_params: AST::Declarations::ModuleTypeParams.empty,
+            self_types: [],
+            members: [],
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
 
-        decl = AST::Declarations::Module.new(
-          name: type_name,
-          type_params: AST::Declarations::ModuleTypeParams.empty,
-          self_types: [],
-          members: [],
-          annotations: [],
-          location: nil,
-          comment: nil
-        )
+          outer_decls << decl
+        end
 
         each_included_module(type_name, mod) do |module_name, module_full_name, _|
           args = type_args(module_full_name)
@@ -429,9 +456,58 @@ module RBS
 
         generate_methods(mod, type_name, decl.members)
 
-        @decls << decl
+        generate_constants mod, decl.members
+      end
+
+      # Generate/find outer module declarations
+      # This is broken down into another method to comply with `DRY`
+      # This generates/finds declarations in nested form & returns the last array of declarations
+      def ensure_outer_module_declarations(mod)
+        *outer_module_names, _ = const_name(mod).split(/::/) #=> parent = [A, B], mod = C
+        destination = @decls # Copy the entries in ivar @decls, not .dup
+
+        outer_module_names&.each do |outer_module_name|
+          outer_module = @modules.detect { |x| const_name(x) == outer_module_name }
+          outer_decl = destination.detect { |decl| decl.is_a?(outer_module.is_a?(Class) ? AST::Declarations::Class : AST::Declarations::Module) && decl.name.name == outer_module_name.to_sym }
+
+          # Insert AST::Declarations if declarations are not added previously
+          unless outer_decl
+            if outer_module.is_a?(Class)
+              outer_decl = AST::Declarations::Class.new(
+                name: to_type_name(outer_module_name),
+                type_params: AST::Declarations::ModuleTypeParams.empty,
+                super_class: generate_super_class(outer_module),
+                members: [],
+                annotations: [],
+                location: nil,
+                comment: nil
+              )
+            else
+              outer_decl = AST::Declarations::Module.new(
+                name: to_type_name(outer_module_name),
+                type_params: AST::Declarations::ModuleTypeParams.empty,
+                self_types: [],
+                members: [],
+                annotations: [],
+                location: nil,
+                comment: nil
+              )
+            end
+
+            destination << outer_decl
+          end
+
+          destination = outer_decl.members
+        end
+
+        # Return the array of declarations checked out at the end
+        destination
+      end
 
-        generate_constants mod
+      # 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 # (A::B::C) => C
       end
 
       def const_name(const)

data/lib/rbs/test/hook.rb

@@ -25,7 +25,11 @@ module RBS
         :! => "not",
         :<< => "lshift",
         :>> => "rshift",
-        :~ => "tilda"
+        :~ => "tilda",
+        :=~ => "eqtilda",
+        :% => "percent",
+        :+@ => "unary_plus",
+        :-@ => "unary_minus"
       }
       def self.alias_names(target, random)
         suffix = "#{RBS::Test.suffix}_#{random}"
@@ -71,7 +75,9 @@ module RBS
         with_name, without_name = alias_names(method_name, random)
         full_method_name = "#{prefix}#{method_name}"
 
-        param_source = params.take_while {|param| param[0] == :req }.map(&:last) + ["*rest_args__#{random}"]
+        param_source = params.take_while {|param| param[0] == :req }
+                             .map.with_index {|pair, index| pair[1] || "__req__#{random}__#{index}" }
+        param_source.push("*rest_args__#{random}")
         block_param = "block__#{random}"
 
         RBS.logger.debug {

data/lib/rbs/type_name.rb

@@ -1,4 +1,3 @@
-
 module RBS
   class TypeName
     attr_reader :namespace
@@ -35,8 +34,8 @@ module RBS
       "#{namespace.to_s}#{name}"
     end
 
-    def to_json(*a)
-      to_s.to_json(*a)
+    def to_json(state = _ = nil)
+      to_s.to_json(state)
     end
 
     def to_namespace

data/lib/rbs/type_name_resolver.rb

@@ -39,7 +39,7 @@ module RBS
         raise unless path_head
 
         name_head = TypeName.new(name: path_head, namespace: Namespace.empty)
-
+ 
         absolute_head = context.find do |namespace|
           # @type break: TypeName
           full_name = name_head.with_prefix(namespace)

data/lib/rbs/types.rb

@@ -52,9 +52,9 @@ module RBS
         include EmptyEachType
         include NoTypeName
 
-        def to_json(*a)
+        def to_json(state = _ = nil)
           klass = to_s.to_sym
-          { class: klass, location: location }.to_json(*a)
+          { class: klass, location: location }.to_json(state)
         end
 
         def to_s(level = 0)
@@ -125,8 +125,8 @@ module RBS
         end
       end
 
-      def to_json(*a)
-        { class: :variable, name: name, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :variable, name: name, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -177,8 +177,8 @@ module RBS
       include NoFreeVariables
       include NoSubst
 
-      def to_json(*a)
-        { class: :class_singleton, name: name, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :class_singleton, name: name, location: location }.to_json(state)
       end
 
       def to_s(level = 0)
@@ -245,8 +245,8 @@ module RBS
         @location = location
       end
 
-      def to_json(*a)
-        { class: :interface, name: name, args: args, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :interface, name: name, args: args, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -275,8 +275,8 @@ module RBS
         @location = location
       end
 
-      def to_json(*a)
-        { class: :class_instance, name: name, args: args, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :class_instance, name: name, args: args, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -316,8 +316,8 @@ module RBS
       include NoFreeVariables
       include NoSubst
 
-      def to_json(*a)
-        { class: :alias, name: name, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :alias, name: name, location: location }.to_json(state)
       end
 
       def to_s(level = 0)
@@ -361,8 +361,8 @@ module RBS
         end
       end
 
-      def to_json(*a)
-        { class: :tuple, types: types, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :tuple, types: types, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -421,8 +421,8 @@ module RBS
         end
       end
 
-      def to_json(*a)
-        { class: :record, fields: fields, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :record, fields: fields, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -482,8 +482,8 @@ module RBS
         type.free_variables(set)
       end
 
-      def to_json(*a)
-        { class: :optional, type: type, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :optional, type: type, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -545,8 +545,8 @@ module RBS
         end
       end
 
-      def to_json(*a)
-        { class: :union, types: types, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :union, types: types, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -613,8 +613,8 @@ module RBS
         end
       end
 
-      def to_json(*a)
-        { class: :intersection, types: types, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :intersection, types: types, location: location }.to_json(state)
       end
 
       def sub(s)
@@ -659,10 +659,12 @@ module RBS
       class Param
         attr_reader :type
         attr_reader :name
+        attr_reader :location
 
-        def initialize(type:, name:)
+        def initialize(type:, name:, location: nil)
           @type = type
           @name = name
+          @location = location
         end
 
         def ==(other)
@@ -677,14 +679,14 @@ module RBS
 
         def map_type(&block)
           if block
-            Param.new(name: name, type: yield(type))
+            Param.new(name: name, type: yield(type), location: location)
           else
             enum_for :map_type
           end
         end
 
-        def to_json(*a)
-          { type: type, name: name }.to_json(*a)
+        def to_json(state = _ = nil)
+          { type: type, name: name }.to_json(state)
         end
 
         def to_s
@@ -826,7 +828,7 @@ module RBS
         end
       end
 
-      def to_json(*a)
+      def to_json(state = _ = nil)
         {
           required_positionals: required_positionals,
           optional_positionals: optional_positionals,
@@ -836,7 +838,7 @@ module RBS
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
           return_type: return_type
-        }.to_json(*a)
+        }.to_json(state)
       end
 
       def sub(s)
@@ -966,11 +968,11 @@ module RBS
           other.required == required
       end
 
-      def to_json(*a)
+      def to_json(state = _ = nil)
         {
           type: type,
           required: required
-        }.to_json(*a)
+        }.to_json(state)
       end
 
       def sub(s)
@@ -1015,13 +1017,13 @@ module RBS
         set
       end
 
-      def to_json(*a)
+      def to_json(state = _ = nil)
         {
           class: :proc,
           type: type,
           block: block,
           location: location
-        }.to_json(*a)
+        }.to_json(state)
       end
 
       def sub(s)
@@ -1083,8 +1085,8 @@ module RBS
       include EmptyEachType
       include NoTypeName
 
-      def to_json(*a)
-        { class: :literal, literal: literal.inspect, location: location }.to_json(*a)
+      def to_json(state = _ = nil)
+        { class: :literal, literal: literal.inspect, location: location }.to_json(state)
       end
 
       def to_s(level = 0)