rbi 0.1.13 → 0.2.0

data/lib/rbi/type_parser.rb

@@ -0,0 +1,320 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Type
+    class Error < RBI::Error; end
+
+    class << self
+      sig { params(string: String).returns(Type) }
+      def parse_string(string)
+        result = Prism.parse(string)
+        unless result.success?
+          raise Error, result.errors.map { |e| "#{e.message}." }.join(" ")
+        end
+
+        node = result.value
+        raise Error, "Expected a type expression, got `#{node.class}`" unless node.is_a?(Prism::ProgramNode)
+        raise Error, "Expected a type expression, got nothing" if node.statements.body.empty?
+        raise Error, "Expected a single type expression, got `#{node.slice}`" if node.statements.body.size > 1
+
+        node = T.must(node.statements.body.first)
+        parse_node(node)
+      end
+
+      sig { params(node: Prism::Node).returns(Type) }
+      def parse_node(node)
+        case node
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          parse_constant(node)
+        when Prism::CallNode
+          parse_call(node)
+        when Prism::ArrayNode
+          parse_tuple(node)
+        when Prism::HashNode, Prism::KeywordHashNode
+          parse_shape(node)
+        when Prism::ParenthesesNode
+          body = node.body
+          raise Error, "Expected exactly 1 child, got 0" unless body.is_a?(Prism::StatementsNode)
+
+          children = body.body
+          raise Error, "Expected exactly 1 child, got #{children.size}" unless children.size == 1
+
+          parse_node(T.must(children.first))
+        else
+          raise Error, "Unexpected node `#{node}`"
+        end
+      end
+
+      private
+
+      sig { params(node: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)).returns(Type) }
+      def parse_constant(node)
+        case node
+        when Prism::ConstantReadNode
+          # `Foo`
+          Type::Simple.new(node.slice)
+        when Prism::ConstantPathNode
+          if t_boolean?(node)
+            # `T::Boolean` or `::T::Boolean`
+            Type::Boolean.new
+          else
+            # `::Foo` or `::Foo::Bar`
+            Type::Simple.new(node.slice)
+          end
+        end
+      end
+
+      sig { params(node: Prism::CallNode).returns(Type) }
+      def parse_call(node)
+        recv = node.receiver
+
+        case node.name
+        when :void
+          # `void`
+          check_arguments_exactly!(node, 0)
+          return Type::Void.new if recv.nil?
+        when :[]
+          case recv
+          when Prism::ConstantReadNode
+            # `Foo[Bar]` or `Foo[Bar, Baz]`
+            args = check_arguments_at_least!(node, 1)
+            return T.unsafe(Type::Generic).new(recv.slice, *args.map { |arg| parse_node(arg) })
+          when Prism::ConstantPathNode
+            if t_class?(recv)
+              # `T::Class[Foo]` or `::T::Class[Foo]`
+              args = check_arguments_exactly!(node, 1)
+              return Type::Class.new(parse_node(T.must(args.first)))
+            else
+              # `::Foo[Bar]` or `::Foo[Bar, Baz]`
+              args = check_arguments_at_least!(node, 1)
+              return T.unsafe(Type::Generic).new(recv.slice, *args.map { |arg| parse_node(arg) })
+            end
+          when Prism::CallNode
+            # `T.class_of(Foo)[Bar]`
+            if t_class_of?(recv)
+              type_args = check_arguments_exactly!(recv, 1)
+              type = parse_node(T.must(type_args.first))
+              raise Error, "Expected a simple type, got `#{type}`" unless type.is_a?(Type::Simple)
+
+              type_param_args = check_arguments_exactly!(node, 1)
+              type_param = parse_node(T.must(type_param_args.first))
+              return Type::ClassOf.new(type, type_param)
+            end
+          end
+
+          # `something[]`
+          raise Error, "Unexpected expression `#{node.slice}`"
+        end
+
+        # `T.proc`
+        return parse_proc(node) if t_proc?(node)
+
+        # `Foo.nilable` or anything called on a constant that is not `::T`
+        raise Error, "Unexpected expression `#{node.slice}`" unless t?(recv)
+
+        case node.name
+        when :nilable
+          # `T.nilable(Foo)`
+          args = check_arguments_exactly!(node, 1)
+          type = parse_node(T.must(args.first))
+          Type::Nilable.new(type)
+        when :anything
+          # `T.anything`
+          check_arguments_exactly!(node, 0)
+          Type::Anything.new
+        when :untyped
+          # `T.untyped`
+          check_arguments_exactly!(node, 0)
+          Type::Untyped.new
+        when :noreturn
+          # `T.noreturn`
+          check_arguments_exactly!(node, 0)
+          Type::NoReturn.new
+        when :self_type
+          # `T.self_type`
+          check_arguments_exactly!(node, 0)
+          Type::SelfType.new
+        when :attached_class
+          # `T.attached_class`
+          check_arguments_exactly!(node, 0)
+          Type::AttachedClass.new
+        when :class_of
+          # `T.class_of(Foo)`
+          args = check_arguments_exactly!(node, 1)
+          type = parse_node(T.must(args.first))
+          raise Error, "Expected a simple type, got `#{type}`" unless type.is_a?(Type::Simple)
+
+          Type::ClassOf.new(type)
+        when :all
+          # `T.all(Foo, Bar)`
+          args = check_arguments_at_least!(node, 2)
+          Type::All.new(args.map { |arg| parse_node(arg) })
+        when :any
+          # `T.any(Foo, Bar)`
+          args = check_arguments_at_least!(node, 2)
+          Type::Any.new(args.map { |arg| parse_node(arg) })
+        when :type_parameter
+          # `T.type_parameter(:T)`
+          args = check_arguments_exactly!(node, 1)
+          symbol = args.first
+          raise Error, "Expected a symbol, got `#{symbol&.slice || "nil"}`" unless symbol.is_a?(Prism::SymbolNode)
+
+          Type::TypeParameter.new(symbol.slice.delete_prefix(":").to_sym)
+        else
+          # `T.something`
+          raise Error, "Unexpected expression `#{node.slice}`"
+        end
+      end
+
+      sig { params(node: Prism::ArrayNode).returns(Type) }
+      def parse_tuple(node)
+        T.unsafe(Type).tuple(*node.elements.map { |elem| parse_node(elem) })
+      end
+
+      sig { params(node: T.any(Prism::HashNode, Prism::KeywordHashNode)).returns(Type) }
+      def parse_shape(node)
+        hash = node.elements.map do |elem|
+          raise Error, "Expected key-value pair, got `#{elem.slice}`" unless elem.is_a?(Prism::AssocNode)
+
+          elem_key = elem.key
+          key = case elem_key
+          when Prism::SymbolNode
+            T.must(elem_key.value).to_sym
+          when Prism::StringNode
+            elem_key.content
+          else
+            raise Error, "Expected symbol or string, got `#{elem_key.slice}`"
+          end
+          [key, parse_node(elem.value)]
+        end.to_h
+        T.unsafe(Type).shape(**hash)
+      end
+
+      sig { params(node: Prism::CallNode).returns(Type) }
+      def parse_proc(node)
+        calls = call_chain(node).reverse
+        calls.pop # remove `T.`
+
+        raise Error, "Unexpected expression `#{node.slice}`" if calls.empty?
+
+        type = Type::Proc.new
+        calls.each do |call|
+          raise Error, "Unexpected expression `#{node.slice}`..." unless call.is_a?(Prism::CallNode)
+
+          case call.name
+          when :params
+            args = call.arguments&.arguments || []
+            hash = args.first
+            raise Error, "Expected hash, got `#{hash.class}`" unless hash.is_a?(Prism::KeywordHashNode)
+
+            params = hash.elements.map do |elem|
+              raise Error, "Expected key-value pair, got `#{elem.slice}`" unless elem.is_a?(Prism::AssocNode)
+
+              [elem.key.slice.delete_suffix(":").to_sym, parse_node(elem.value)]
+            end.to_h
+            T.unsafe(type).params(**params)
+          when :returns
+            args = check_arguments_exactly!(call, 1)
+            type.returns(parse_node(T.must(args.first)))
+          when :void
+            type.void
+          when :proc
+            return type
+          when :bind
+            args = check_arguments_exactly!(call, 1)
+            type.bind(parse_node(T.must(args.first)))
+          else
+            raise Error, "Unexpected expression `#{node.slice}`"
+          end
+        end
+        type
+      end
+
+      sig { params(node: Prism::CallNode, count: Integer).returns(T::Array[Prism::Node]) }
+      def check_arguments_exactly!(node, count)
+        args = node.arguments&.arguments || []
+        unless args.size == count
+          if count == 0
+            raise Error, "Expected no arguments, got #{args.size}"
+          elsif count == 1
+            raise Error, "Expected exactly 1 argument, got #{args.size}"
+          else
+            raise Error, "Expected exactly #{count} arguments, got #{args.size}"
+          end
+        end
+        args
+      end
+
+      sig { params(node: Prism::CallNode, count: Integer).returns(T::Array[Prism::Node]) }
+      def check_arguments_at_least!(node, count)
+        args = node.arguments&.arguments || []
+        if args.size < count
+          if count == 1
+            raise Error, "Expected at least 1 argument, got #{args.size}"
+          else
+            raise Error, "Expected at least #{count} arguments, got #{args.size}"
+          end
+        end
+        args
+      end
+
+      sig { params(node: Prism::CallNode).returns(T::Array[Prism::Node]) }
+      def call_chain(node)
+        call_chain = T.let([node], T::Array[Prism::Node])
+        receiver = T.let(node.receiver, T.nilable(Prism::Node))
+        while receiver
+          call_chain.prepend(receiver)
+          break unless receiver.is_a?(Prism::CallNode)
+
+          receiver = receiver.receiver
+        end
+        call_chain
+      end
+
+      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def t?(node)
+        case node
+        when Prism::ConstantReadNode
+          return true if node.name == :T
+        when Prism::ConstantPathNode
+          return true if node.parent.nil? && node.name == :T
+        end
+
+        false
+      end
+
+      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def t_boolean?(node)
+        return false unless node.is_a?(Prism::ConstantPathNode)
+
+        t?(node.parent) && node.name == :Boolean
+      end
+
+      sig { params(node: Prism::ConstantPathNode).returns(T::Boolean) }
+      def t_class?(node)
+        t?(node.parent) && node.name == :Class
+      end
+
+      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+      def t_class_of?(node)
+        return false unless node.is_a?(Prism::CallNode)
+
+        t?(node.receiver) && node.name == :class_of
+      end
+
+      sig { params(node: Prism::CallNode).returns(T::Boolean) }
+      def t_proc?(node)
+        chain = call_chain(node)
+        return false if chain.size < 2
+        return false unless t?(chain[0])
+
+        second = chain[1]
+        return false unless second.is_a?(Prism::CallNode)
+        return false unless second.name == :proc
+
+        true
+      end
+    end
+  end
+end

data/lib/rbi/type_visitor.rb

@@ -0,0 +1,112 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Type
+    class Visitor
+      extend T::Sig
+
+      class Error < RBI::Error; end
+
+      sig { params(node: Type).void }
+      def visit(node)
+        case node
+        when Type::Simple
+          visit_simple(node)
+        when Type::Void
+          visit_void(node)
+        when Type::Boolean
+          visit_boolean(node)
+        when Type::Nilable
+          visit_nilable(node)
+        when Type::Untyped
+          visit_untyped(node)
+        when Type::Generic
+          visit_generic(node)
+        when Type::Anything
+          visit_anything(node)
+        when Type::NoReturn
+          visit_no_return(node)
+        when Type::SelfType
+          visit_self_type(node)
+        when Type::AttachedClass
+          visit_attached_class(node)
+        when Type::ClassOf
+          visit_class_of(node)
+        when Type::All
+          visit_all(node)
+        when Type::Any
+          visit_any(node)
+        when Type::Tuple
+          visit_tuple(node)
+        when Type::Shape
+          visit_shape(node)
+        when Type::Proc
+          visit_proc(node)
+        when Type::TypeParameter
+          visit_type_parameter(node)
+        when Type::Class
+          visit_class(node)
+        else
+          raise Error, "Unhandled node: #{node.class}"
+        end
+      end
+
+      private
+
+      sig { params(type: Type::All).void }
+      def visit_all(type); end
+
+      sig { params(type: Type::Any).void }
+      def visit_any(type); end
+
+      sig { params(type: Type::Anything).void }
+      def visit_anything(type); end
+
+      sig { params(type: Type::AttachedClass).void }
+      def visit_attached_class(type); end
+
+      sig { params(type: Type::Boolean).void }
+      def visit_boolean(type); end
+
+      sig { params(type: Type::Class).void }
+      def visit_class(type); end
+
+      sig { params(type: Type::ClassOf).void }
+      def visit_class_of(type); end
+
+      sig { params(type: Type::Generic).void }
+      def visit_generic(type); end
+
+      sig { params(type: Type::Nilable).void }
+      def visit_nilable(type); end
+
+      sig { params(type: Type::Simple).void }
+      def visit_simple(type); end
+
+      sig { params(type: Type::NoReturn).void }
+      def visit_no_return(type); end
+
+      sig { params(type: Type::Proc).void }
+      def visit_proc(type); end
+
+      sig { params(type: Type::SelfType).void }
+      def visit_self_type(type); end
+
+      sig { params(type: Type::Void).void }
+      def visit_void(type); end
+
+      sig { params(type: Type::Shape).void }
+      def visit_shape(type); end
+
+      sig { params(type: Type::Tuple).void }
+      def visit_tuple(type); end
+
+      sig { params(type: Type::TypeParameter).void }
+      def visit_type_parameter(type); end
+
+      sig { params(type: Type::Untyped).void }
+      def visit_untyped(type); end
+    end
+  end
+end

data/lib/rbi/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module RBI
-  VERSION = "0.1.13"
+  VERSION = "0.2.0"
 end

data/lib/rbi/visitor.rb

@@ -2,18 +2,244 @@
 # frozen_string_literal: true
 
 module RBI
+  class VisitorError < Error; end
+
   class Visitor
     extend T::Helpers
     extend T::Sig
 
     abstract!
 
-    sig { abstract.params(node: T.nilable(Node)).void }
-    def visit(node); end
+    sig { params(node: T.nilable(Node)).void }
+    def visit(node)
+      return unless node
+
+      case node
+      when BlankLine
+        visit_blank_line(node)
+      when Comment
+        visit_comment(node)
+      when TEnum
+        visit_tenum(node)
+      when TStruct
+        visit_tstruct(node)
+      when Module
+        visit_module(node)
+      when Class
+        visit_class(node)
+      when SingletonClass
+        visit_singleton_class(node)
+      when Struct
+        visit_struct(node)
+      when Group
+        visit_group(node)
+      when VisibilityGroup
+        visit_visibility_group(node)
+      when ConflictTree
+        visit_conflict_tree(node)
+      when ScopeConflict
+        visit_scope_conflict(node)
+      when TEnumBlock
+        visit_tenum_block(node)
+      when Tree
+        visit_tree(node)
+      when Const
+        visit_const(node)
+      when AttrAccessor
+        visit_attr_accessor(node)
+      when AttrReader
+        visit_attr_reader(node)
+      when AttrWriter
+        visit_attr_writer(node)
+      when Method
+        visit_method(node)
+      when ReqParam
+        visit_req_param(node)
+      when OptParam
+        visit_opt_param(node)
+      when RestParam
+        visit_rest_param(node)
+      when KwParam
+        visit_kw_param(node)
+      when KwOptParam
+        visit_kw_opt_param(node)
+      when KwRestParam
+        visit_kw_rest_param(node)
+      when BlockParam
+        visit_block_param(node)
+      when Include
+        visit_include(node)
+      when Extend
+        visit_extend(node)
+      when Public
+        visit_public(node)
+      when Protected
+        visit_protected(node)
+      when Private
+        visit_private(node)
+      when Send
+        visit_send(node)
+      when KwArg
+        visit_kw_arg(node)
+      when Arg
+        visit_arg(node)
+      when Sig
+        visit_sig(node)
+      when SigParam
+        visit_sig_param(node)
+      when TStructConst
+        visit_tstruct_const(node)
+      when TStructProp
+        visit_tstruct_prop(node)
+      when Helper
+        visit_helper(node)
+      when TypeMember
+        visit_type_member(node)
+      when MixesInClassMethods
+        visit_mixes_in_class_methods(node)
+      when RequiresAncestor
+        visit_requires_ancestor(node)
+      else
+        raise VisitorError, "Unhandled node: #{node.class}"
+      end
+    end
 
     sig { params(nodes: T::Array[Node]).void }
     def visit_all(nodes)
       nodes.each { |node| visit(node) }
     end
+
+    sig { params(file: File).void }
+    def visit_file(file)
+      visit(file.root)
+    end
+
+    private
+
+    sig { params(node: Comment).void }
+    def visit_comment(node); end
+
+    sig { params(node: BlankLine).void }
+    def visit_blank_line(node); end
+
+    sig { params(node: Module).void }
+    def visit_module(node); end
+
+    sig { params(node: Class).void }
+    def visit_class(node); end
+
+    sig { params(node: SingletonClass).void }
+    def visit_singleton_class(node); end
+
+    sig { params(node: Struct).void }
+    def visit_struct(node); end
+
+    sig { params(node: Tree).void }
+    def visit_tree(node); end
+
+    sig { params(node: Const).void }
+    def visit_const(node); end
+
+    sig { params(node: AttrAccessor).void }
+    def visit_attr_accessor(node); end
+
+    sig { params(node: AttrReader).void }
+    def visit_attr_reader(node); end
+
+    sig { params(node: AttrWriter).void }
+    def visit_attr_writer(node); end
+
+    sig { params(node: Method).void }
+    def visit_method(node); end
+
+    sig { params(node: ReqParam).void }
+    def visit_req_param(node); end
+
+    sig { params(node: OptParam).void }
+    def visit_opt_param(node); end
+
+    sig { params(node: RestParam).void }
+    def visit_rest_param(node); end
+
+    sig { params(node: KwParam).void }
+    def visit_kw_param(node); end
+
+    sig { params(node: KwOptParam).void }
+    def visit_kw_opt_param(node); end
+
+    sig { params(node: KwRestParam).void }
+    def visit_kw_rest_param(node); end
+
+    sig { params(node: BlockParam).void }
+    def visit_block_param(node); end
+
+    sig { params(node: Include).void }
+    def visit_include(node); end
+
+    sig { params(node: Extend).void }
+    def visit_extend(node); end
+
+    sig { params(node: Public).void }
+    def visit_public(node); end
+
+    sig { params(node: Protected).void }
+    def visit_protected(node); end
+
+    sig { params(node: Private).void }
+    def visit_private(node); end
+
+    sig { params(node: Send).void }
+    def visit_send(node); end
+
+    sig { params(node: Arg).void }
+    def visit_arg(node); end
+
+    sig { params(node: KwArg).void }
+    def visit_kw_arg(node); end
+
+    sig { params(node: Sig).void }
+    def visit_sig(node); end
+
+    sig { params(node: SigParam).void }
+    def visit_sig_param(node); end
+
+    sig { params(node: TStruct).void }
+    def visit_tstruct(node); end
+
+    sig { params(node: TStructConst).void }
+    def visit_tstruct_const(node); end
+
+    sig { params(node: TStructProp).void }
+    def visit_tstruct_prop(node); end
+
+    sig { params(node: TEnum).void }
+    def visit_tenum(node); end
+
+    sig { params(node: TEnumBlock).void }
+    def visit_tenum_block(node); end
+
+    sig { params(node: Helper).void }
+    def visit_helper(node); end
+
+    sig { params(node: TypeMember).void }
+    def visit_type_member(node); end
+
+    sig { params(node: MixesInClassMethods).void }
+    def visit_mixes_in_class_methods(node); end
+
+    sig { params(node: RequiresAncestor).void }
+    def visit_requires_ancestor(node); end
+
+    sig { params(node: Group).void }
+    def visit_group(node); end
+
+    sig { params(node: VisibilityGroup).void }
+    def visit_visibility_group(node); end
+
+    sig { params(node: ConflictTree).void }
+    def visit_conflict_tree(node); end
+
+    sig { params(node: ScopeConflict).void }
+    def visit_scope_conflict(node); end
   end
 end