rbs 0.4.0 → 0.9.0

data/lib/rbs/prototype/rb.rb

@@ -6,19 +6,20 @@ module RBS
 
       def initialize
         @source_decls = []
-        @toplevel_members = []
       end
 
       def decls
         decls = []
 
-        decls.push(*source_decls)
+        top_decls, top_members = source_decls.partition {|decl| decl.is_a?(AST::Declarations::Base) }
 
-        unless toplevel_members.empty?
-          top = AST::Declarations::Extension.new(
+        decls.push(*top_decls)
+
+        unless top_members.empty?
+          top = AST::Declarations::Class.new(
             name: TypeName.new(name: :Object, namespace: Namespace.empty),
-            extension_name: :Toplevel,
-            members: toplevel_members,
+            super_class: nil,
+            members: top_members,
             annotations: [],
             comment: nil,
             location: nil,
@@ -27,7 +28,7 @@ module RBS
           decls << top
         end
 
-        decls.uniq
+        decls
       end
 
       def parse(string)
@@ -51,19 +52,15 @@ module RBS
           end
         end
 
-        process RubyVM::AbstractSyntaxTree.parse(string), namespace: Namespace.empty, current_module: nil, comments: comments, singleton: false
-      end
-
-      def nested_name(name)
-        (current_namespace + const_to_name(name).to_namespace).to_type_name.relative!
+        process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, singleton: false
       end
 
-      def process(node, namespace:, current_module:, comments:, singleton:)
+      def process(node, decls:, comments:, singleton:)
         case node.type
         when :CLASS
           class_name, super_class, *class_body = node.children
           kls = AST::Declarations::Class.new(
-            name: const_to_name(class_name).with_prefix(namespace).relative!,
+            name: const_to_name(class_name),
             super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
             type_params: AST::Declarations::ModuleTypeParams.empty,
             members: [],
@@ -72,39 +69,42 @@ module RBS
             comment: comments[node.first_lineno - 1]
           )
 
-          source_decls.push kls
+          decls.push kls
 
           each_node class_body do |child|
-            process child, namespace: kls.name.to_namespace, current_module: kls, comments: comments, singleton: false
+            process child, decls: kls.members, comments: comments, singleton: false
           end
+
         when :MODULE
           module_name, *module_body = node.children
 
           mod = AST::Declarations::Module.new(
-            name: const_to_name(module_name).with_prefix(namespace).relative!,
+            name: const_to_name(module_name),
             type_params: AST::Declarations::ModuleTypeParams.empty,
-            self_type: nil,
+            self_types: [],
             members: [],
             annotations: [],
             location: nil,
             comment: comments[node.first_lineno - 1]
           )
 
-          source_decls.push mod
+          decls.push mod
 
           each_node module_body do |child|
-            process child, namespace: mod.name.to_namespace, current_module: mod, comments: comments, singleton: false
+            process child, decls: mod.members, comments: comments, singleton: false
           end
+
         when :SCLASS
-          this = node.children[0]
+          this, body = node.children
+
           if this.type != :SELF
             RBS.logger.warn "`class <<` syntax with not-self may be compiled to incorrect code: #{this}"
           end
 
-          body = node.children[1]
           each_child(body) do |child|
-            process child, namespace: namespace, current_module: current_module, comments: comments, singleton: true
+            process child, decls: decls, comments: comments, singleton: true
           end
+
         when :DEFN, :DEFS
             if node.type == :DEFN
               def_name, def_body = node.children
@@ -130,116 +130,104 @@ module RBS
               types: types,
               kind: kind,
               comment: comments[node.first_lineno - 1],
-              attributes: []
+              attributes: [],
+              overload: false
             )
 
-            if current_module
-              current_module.members.push member
-            else
-              toplevel_members.push member
-            end
+            decls.push member unless decls.include?(member)
+
         when :FCALL
-          if current_module
-            # Inside method definition cannot reach here.
-            args = node.children[1]&.children || []
-
-            case node.children[0]
-            when :include
-              args.each do |arg|
-                if (name = const_to_name(arg))
-                  current_module.members << AST::Members::Include.new(
-                    name: name,
-                    args: [],
-                    annotations: [],
-                    location: nil,
-                    comment: comments[node.first_lineno - 1]
-                  )
-                end
+          # Inside method definition cannot reach here.
+          args = node.children[1]&.children || []
+
+          case node.children[0]
+          when :include
+            args.each do |arg|
+              if (name = const_to_name(arg))
+                decls << AST::Members::Include.new(
+                  name: name,
+                  args: [],
+                  annotations: [],
+                  location: nil,
+                  comment: comments[node.first_lineno - 1]
+                )
               end
-            when :extend
-              args.each do |arg|
-                if (name = const_to_name(arg))
-                  current_module.members << AST::Members::Extend.new(
-                    name: name,
-                    args: [],
-                    annotations: [],
-                    location: nil,
-                    comment: comments[node.first_lineno - 1]
-                  )
-                end
+            end
+          when :extend
+            args.each do |arg|
+              if (name = const_to_name(arg))
+                decls << AST::Members::Extend.new(
+                  name: name,
+                  args: [],
+                  annotations: [],
+                  location: nil,
+                  comment: comments[node.first_lineno - 1]
+                )
               end
-            when :attr_reader
-              args.each do |arg|
-                if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
-                  current_module.members << AST::Members::AttrReader.new(
-                    name: arg.children[0],
-                    ivar_name: nil,
-                    type: Types::Bases::Any.new(location: nil),
-                    location: nil,
-                    comment: comments[node.first_lineno - 1],
-                    annotations: []
-                  )
-                end
+            end
+          when :attr_reader
+            args.each do |arg|
+              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                decls << AST::Members::AttrReader.new(
+                  name: arg.children[0],
+                  ivar_name: nil,
+                  type: Types::Bases::Any.new(location: nil),
+                  location: nil,
+                  comment: comments[node.first_lineno - 1],
+                  annotations: []
+                )
               end
-            when :attr_accessor
-              args.each do |arg|
-                if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
-                  current_module.members << AST::Members::AttrAccessor.new(
-                    name: arg.children[0],
-                    ivar_name: nil,
-                    type: Types::Bases::Any.new(location: nil),
-                    location: nil,
-                    comment: comments[node.first_lineno - 1],
-                    annotations: []
-                  )
-                end
+            end
+          when :attr_accessor
+            args.each do |arg|
+              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                decls << AST::Members::AttrAccessor.new(
+                  name: arg.children[0],
+                  ivar_name: nil,
+                  type: Types::Bases::Any.new(location: nil),
+                  location: nil,
+                  comment: comments[node.first_lineno - 1],
+                  annotations: []
+                )
               end
-            when :attr_writer
-              args.each do |arg|
-                if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
-                  current_module.members << AST::Members::AttrWriter.new(
-                    name: arg.children[0],
-                    ivar_name: nil,
-                    type: Types::Bases::Any.new(location: nil),
-                    location: nil,
-                    comment: comments[node.first_lineno - 1],
-                    annotations: []
-                  )
-                end
+            end
+          when :attr_writer
+            args.each do |arg|
+              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                decls << AST::Members::AttrWriter.new(
+                  name: arg.children[0],
+                  ivar_name: nil,
+                  type: Types::Bases::Any.new(location: nil),
+                  location: nil,
+                  comment: comments[node.first_lineno - 1],
+                  annotations: []
+                )
               end
             end
           end
+
           each_child node do |child|
-            process child, namespace: namespace, current_module: current_module, comments: comments, singleton: singleton
+            process child, decls: decls, comments: comments, singleton: singleton
           end
 
         when :CDECL
-          type_name = case
-                      when node.children[0].is_a?(Symbol)
-                        ns = if current_module
-                               current_module.name.to_namespace
-                             else
-                               Namespace.empty
-                             end
-                        TypeName.new(name: node.children[0], namespace: ns)
-                      else
-                        name = const_to_name(node.children[0])
-                        if current_module
-                          name.with_prefix current_module.name.to_namespace
-                        else
-                          name
-                        end.relative!
-                      end
-
-          source_decls << AST::Declarations::Constant.new(
-            name: type_name,
+          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])
+                       end
+
+          decls << AST::Declarations::Constant.new(
+            name: const_name,
             type: node_type(node.children.last),
             location: nil,
             comment: comments[node.first_lineno - 1]
           )
+
         else
           each_child node do |child|
-            process child, namespace: namespace, current_module: current_module, comments: comments, singleton: singleton
+            process child, decls: decls, comments: comments, singleton: singleton
           end
         end
       end

data/lib/rbs/prototype/rbi.rb

@@ -69,7 +69,7 @@ module RBS
           members: [],
           annotations: [],
           location: nil,
-          self_type: nil,
+          self_types: [],
           comment: comment
         )
 
@@ -173,7 +173,8 @@ module RBS
               types: types,
               kind: :singleton,
               comment: comment,
-              attributes: []
+              attributes: [],
+              overload: false
             )
           end
 
@@ -193,7 +194,8 @@ module RBS
               types: types,
               kind: :instance,
               comment: comment,
-              attributes: []
+              attributes: [],
+              overload: false
             )
           end
 

data/lib/rbs/prototype/runtime.rb

@@ -128,7 +128,7 @@ module RBS
 
       def merge_rbs(module_name, members, instance: nil, singleton: nil)
         if merge
-          if env.class?(module_name.absolute!)
+          if env.class_decls[module_name.absolute!]
             case
             when instance
               method = builder.build_instance(module_name.absolute!).methods[instance]
@@ -152,9 +152,10 @@ module RBS
                 },
                 kind: kind,
                 location: nil,
-                comment: method.comment,
+                comment: method.comments[0],
                 annotations: method.annotations,
-                attributes: method.attributes
+                attributes: method.attributes,
+                overload: false
               )
               return
             end
@@ -192,7 +193,8 @@ module RBS
                 location: nil,
                 comment: nil,
                 annotations: [],
-                attributes: []
+                attributes: [],
+                overload: false
               )
             end
           else
@@ -225,7 +227,8 @@ module RBS
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  attributes: []
+                  attributes: [],
+                  overload: false
                 )
               end
             else
@@ -259,7 +262,8 @@ module RBS
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  attributes: []
+                  attributes: [],
+                  overload: false
                 )
               end
             else
@@ -366,7 +370,7 @@ module RBS
         decl = AST::Declarations::Module.new(
           name: type_name,
           type_params: AST::Declarations::ModuleTypeParams.empty,
-          self_type: nil,
+          self_types: [],
           members: [],
           annotations: [],
           location: nil,

data/lib/rbs/substitution.rb

@@ -1,6 +1,7 @@
 module RBS
   class Substitution
     attr_reader :mapping
+    attr_accessor :instance_type
 
     def initialize()
       @mapping = {}
@@ -10,7 +11,7 @@ module RBS
       mapping[from] = to
     end
 
-    def self.build(variables, types, &block)
+    def self.build(variables, types, instance_type: nil, &block)
       unless variables.size == types.size
         raise "Broken substitution: variables=#{variables}, types=#{types}"
       end
@@ -22,6 +23,8 @@ module RBS
           type = block_given? ? yield(t) : t
           subst.add(from: v, to: type)
         end
+
+        subst.instance_type = instance_type
       end
     end
 
@@ -29,6 +32,12 @@ module RBS
       case ty
       when Types::Variable
         mapping[ty.name] || ty
+      when Types::Bases::Instance
+        if instance_type
+          instance_type
+        else
+          ty
+        end
       else
         ty
       end
@@ -40,6 +49,8 @@ module RBS
         vars.each do |var|
           subst.mapping.delete(var)
         end
+
+        subst.instance_type = self.instance_type
       end
     end
   end

data/lib/rbs/test.rb

@@ -1,7 +1,11 @@
+require "securerandom"
+require "rbs/test/observer"
 require "rbs/test/spy"
 require "rbs/test/errors"
 require "rbs/test/type_check"
+require "rbs/test/tester"
 require "rbs/test/hook"
+require "rbs/test/setup_helper"
 
 module RBS
   module Test
@@ -16,11 +20,86 @@ module RBS
     INSPECT = Kernel.instance_method(:inspect)
     METHODS = Kernel.instance_method(:methods)
 
-    ArgumentsReturn = Struct.new(:arguments, :return_value, :exception, keyword_init: true)
+    class ArgumentsReturn
+      attr_reader :arguments
+      attr_reader :exit_value
+      attr_reader :exit_type
+
+      def initialize(arguments:, exit_value:, exit_type:)
+        @arguments = arguments
+        @exit_value = exit_value
+        @exit_type = exit_type
+      end
+
+      def self.return(arguments:, value:)
+        new(arguments: arguments, exit_value: value, exit_type: :return)
+      end
+
+      def self.exception(arguments:, exception:)
+        new(arguments: arguments, exit_value: exception, exit_type: :exception)
+      end
+
+      def self.break(arguments:)
+        new(arguments: arguments, exit_value: nil, exit_type: :break)
+      end
+
+      def return_value
+        raise unless exit_type == :return
+        exit_value
+      end
+
+      def exception
+        raise unless exit_type == :exception
+        exit_value
+      end
+
+      def return?
+        exit_type == :return
+      end
+
+      def exception?
+        exit_type == :exception
+      end
+
+      def break?
+        exit_type == :break
+      end
+    end
+
     CallTrace = Struct.new(:method_name, :method_call, :block_calls, :block_given, keyword_init: true)
 
-    def self.call(receiver, method, *args, **kwargs, &block)
-      method.bind_call(receiver, *args, **kwargs, &block)
+    class <<self
+      attr_accessor :suffix
+
+      def reset_suffix
+        self.suffix = "RBS_TEST_#{SecureRandom.hex(3)}"
+      end
+    end
+
+    reset_suffix
+
+    if ::UnboundMethod.instance_methods.include?(:bind_call)
+      def self.call(receiver, method, *args, &block)
+        method.bind_call(receiver, *args, &block)
+      end
+    else
+      def self.call(receiver, method, *args, &block)
+        method.bind(receiver).call(*args, &block)
+      end
     end
   end
 end
+
+unless ::Module.private_instance_methods.include?(:ruby2_keywords)
+  class Module
+    private
+    def ruby2_keywords(*)
+    end
+  end
+end
+
+unless ::Proc.instance_methods.include?(:ruby2_keywords)
+  class Proc
+    def ruby2_keywords; end
+  end
+end