rbs 0.2.0 → 0.6.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
+
         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
@@ -328,7 +316,19 @@ module RBS
         body = node.children[2]
         return Types::Bases::Nil.new(location: nil) unless body
 
-        literal_to_type(body)
+        if body.type == :BLOCK
+          return_stmts = any_node?(body) do |n|
+            n.type == :RETURN
+          end&.map do |return_node|
+            returned_value = return_node.children[0]
+            returned_value ? literal_to_type(returned_value) : Types::Bases::Nil.new(location: nil)
+          end || []
+          last_node = body.children.last
+          last_evaluated =  last_node ? literal_to_type(last_node) : Types::Bases::Nil.new(location: nil)
+          types_to_union_type([*return_stmts, last_evaluated])
+        else
+          literal_to_type(body)
+        end
       end
 
       def literal_to_type(node)
@@ -393,7 +393,7 @@ module RBS
             value_types << literal_to_type(v)
           end
 
-          if key_types.all? { |t| t.is_a?(Types::Literal) }
+          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
             Types::Record.new(fields: fields, location: nil)
           else
@@ -408,9 +408,11 @@ module RBS
 
       def types_to_union_type(types)
         return untyped if types.empty?
-        return untyped if types.include?(untyped)
 
-        Types::Union.new(types: types.uniq, location: nil)
+        uniq = types.uniq
+        return uniq.first if uniq.size == 1
+
+        Types::Union.new(types: uniq, location: nil)
       end
 
       def range_element_type(types)

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
@@ -281,6 +285,11 @@ module RBS
           value = mod.const_get(name)
 
           next if value.is_a?(Class) || value.is_a?(Module)
+          unless value.class.name
+            RBS.logger.warn("Skipping constant #{name} #{value} of #{mod} as an instance of anonymous class")
+            next
+          end
+
           type = case value
                  when true, false
                    Types::Bases::Bool.new(location: nil)
@@ -306,6 +315,9 @@ module RBS
         type_name = to_type_name(mod.name)
         super_class = if mod.superclass == ::Object
                         nil
+                      elsif mod.superclass.name.nil?
+                        RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
+                        nil
                       else
                         AST::Declarations::Class::Super.new(name: to_type_name(mod.superclass.name), args: [])
                       end
@@ -321,6 +333,11 @@ module RBS
         )
 
         each_mixin(mod.included_modules, *mod.superclass.included_modules, *mod.included_modules.flat_map(&:included_modules)) do |included_module|
+          unless included_module.name
+            RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
+            next
+          end
+
           module_name = to_type_name(included_module.name)
           if module_name.namespace == type_name.namespace
             module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
@@ -343,12 +360,17 @@ module RBS
       end
 
       def generate_module(mod)
+        unless mod.name
+          RBS.logger.warn("Skipping anonymous module #{mod}")
+          return
+        end
+
         type_name = to_type_name(mod.name)
 
         decl = AST::Declarations::Module.new(
           name: type_name,
           type_params: AST::Declarations::ModuleTypeParams.empty,
-          self_type: nil,
+          self_types: [],
           members: [],
           annotations: [],
           location: nil,
@@ -356,6 +378,11 @@ module RBS
         )
 
         each_mixin(mod.included_modules, *mod.included_modules.flat_map(&:included_modules), namespace: type_name.namespace) do |included_module|
+          unless included_module.name
+            RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
+            next
+          end
+
           module_name = to_type_name(included_module.name)
           if module_name.namespace == type_name.namespace
             module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)