rbi 0.2.4 → 0.3.2

data/lib/rbi/type_parser.rb

@@ -6,7 +6,7 @@ module RBI
     class Error < RBI::Error; end
 
     class << self
-      sig { params(string: String).returns(Type) }
+      #: (String string) -> Type
       def parse_string(string)
         result = Prism.parse(string)
         unless result.success?
@@ -18,11 +18,11 @@ module RBI
         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)
+        node = node.statements.body.first #: as !nil
         parse_node(node)
       end
 
-      sig { params(node: Prism::Node).returns(Type) }
+      #: (Prism::Node node) -> Type
       def parse_node(node)
         case node
         when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -40,7 +40,9 @@ module RBI
           children = body.body
           raise Error, "Expected exactly 1 child, got #{children.size}" unless children.size == 1
 
-          parse_node(T.must(children.first))
+          parse_node(
+            children.first, #: as !nil
+          )
         else
           raise Error, "Unexpected node `#{node}`"
         end
@@ -48,7 +50,7 @@ module RBI
 
       private
 
-      sig { params(node: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)).returns(Type) }
+      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode) node) -> Type
       def parse_constant(node)
         case node
         when Prism::ConstantReadNode
@@ -65,7 +67,7 @@ module RBI
         end
       end
 
-      sig { params(node: Prism::CallNode).returns(Type) }
+      #: (Prism::CallNode node) -> Type
       def parse_call(node)
         recv = node.receiver
 
@@ -84,7 +86,11 @@ module RBI
             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)))
+              return Type::Class.new(
+                parse_node(
+                  args.first, #: as !nil
+                ),
+              )
             else
               # `::Foo[Bar]` or `::Foo[Bar, Baz]`
               args = check_arguments_at_least!(node, 1)
@@ -94,11 +100,15 @@ module RBI
             # `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))
+              type = parse_node(
+                type_args.first, #: as !nil
+              )
               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))
+              type_param = parse_node(
+                type_param_args.first, #: as !nil
+              )
               return Type::ClassOf.new(type, type_param)
             end
           end
@@ -117,7 +127,9 @@ module RBI
         when :nilable
           # `T.nilable(Foo)`
           args = check_arguments_exactly!(node, 1)
-          type = parse_node(T.must(args.first))
+          type = parse_node(
+            args.first, #: as !nil
+          )
           Type::Nilable.new(type)
         when :anything
           # `T.anything`
@@ -142,7 +154,9 @@ module RBI
         when :class_of
           # `T.class_of(Foo)`
           args = check_arguments_exactly!(node, 1)
-          type = parse_node(T.must(args.first))
+          type = parse_node(
+            args.first, #: as !nil
+          )
           raise Error, "Expected a simple type, got `#{type}`" unless type.is_a?(Type::Simple)
 
           Type::ClassOf.new(type)
@@ -167,12 +181,12 @@ module RBI
         end
       end
 
-      sig { params(node: Prism::ArrayNode).returns(Type) }
+      #: (Prism::ArrayNode node) -> 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) }
+      #: ((Prism::HashNode | Prism::KeywordHashNode) node) -> 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)
@@ -180,7 +194,9 @@ module RBI
           elem_key = elem.key
           key = case elem_key
           when Prism::SymbolNode
-            T.must(elem_key.value).to_sym
+            elem_key
+              .value #: as !nil
+              .to_sym
           when Prism::StringNode
             elem_key.content
           else
@@ -191,7 +207,7 @@ module RBI
         T.unsafe(Type).shape(**hash)
       end
 
-      sig { params(node: Prism::CallNode).returns(Type) }
+      #: (Prism::CallNode node) -> Type
       def parse_proc(node)
         calls = call_chain(node).reverse
         calls.pop # remove `T.`
@@ -216,14 +232,22 @@ module RBI
             T.unsafe(type).params(**params)
           when :returns
             args = check_arguments_exactly!(call, 1)
-            type.returns(parse_node(T.must(args.first)))
+            type.returns(
+              parse_node(
+                args.first, #: as !nil
+              ),
+            )
           when :void
             type.void
           when :proc
             return type
           when :bind
             args = check_arguments_exactly!(call, 1)
-            type.bind(parse_node(T.must(args.first)))
+            type.bind(
+              parse_node(
+                args.first, #: as !nil
+              ),
+            )
           else
             raise Error, "Unexpected expression `#{node.slice}`"
           end
@@ -231,7 +255,7 @@ module RBI
         type
       end
 
-      sig { params(node: Prism::CallNode, count: Integer).returns(T::Array[Prism::Node]) }
+      #: (Prism::CallNode node, Integer count) -> Array[Prism::Node]
       def check_arguments_exactly!(node, count)
         args = node.arguments&.arguments || []
         unless args.size == count
@@ -246,7 +270,7 @@ module RBI
         args
       end
 
-      sig { params(node: Prism::CallNode, count: Integer).returns(T::Array[Prism::Node]) }
+      #: (Prism::CallNode node, Integer count) -> Array[Prism::Node]
       def check_arguments_at_least!(node, count)
         args = node.arguments&.arguments || []
         if args.size < count
@@ -259,10 +283,10 @@ module RBI
         args
       end
 
-      sig { params(node: Prism::CallNode).returns(T::Array[Prism::Node]) }
+      #: (Prism::CallNode node) -> 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))
+        call_chain = [node] #: Array[Prism::Node]
+        receiver = node.receiver #: Prism::Node?
         while receiver
           call_chain.prepend(receiver)
           break unless receiver.is_a?(Prism::CallNode)
@@ -272,7 +296,7 @@ module RBI
         call_chain
       end
 
-      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Prism::Node? node) -> bool
       def t?(node)
         case node
         when Prism::ConstantReadNode
@@ -284,26 +308,26 @@ module RBI
         false
       end
 
-      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Prism::Node? node) -> bool
       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) }
+      #: (Prism::ConstantPathNode node) -> bool
       def t_class?(node)
         t?(node.parent) && node.name == :Class
       end
 
-      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Prism::Node? node) -> bool
       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) }
+      #: (Prism::CallNode node) -> bool
       def t_proc?(node)
         chain = call_chain(node)
         return false if chain.size < 2

data/lib/rbi/type_visitor.rb

@@ -4,11 +4,9 @@
 module RBI
   class Type
     class Visitor
-      extend T::Sig
-
       class Error < RBI::Error; end
 
-      sig { params(node: Type).void }
+      #: (Type node) -> void
       def visit(node)
         case node
         when Type::Simple
@@ -54,58 +52,58 @@ module RBI
 
       private
 
-      sig { params(type: Type::All).void }
+      #: (Type::All type) -> void
       def visit_all(type); end
 
-      sig { params(type: Type::Any).void }
+      #: (Type::Any type) -> void
       def visit_any(type); end
 
-      sig { params(type: Type::Anything).void }
+      #: (Type::Anything type) -> void
       def visit_anything(type); end
 
-      sig { params(type: Type::AttachedClass).void }
+      #: (Type::AttachedClass type) -> void
       def visit_attached_class(type); end
 
-      sig { params(type: Type::Boolean).void }
+      #: (Type::Boolean type) -> void
       def visit_boolean(type); end
 
-      sig { params(type: Type::Class).void }
+      #: (Type::Class type) -> void
       def visit_class(type); end
 
-      sig { params(type: Type::ClassOf).void }
+      #: (Type::ClassOf type) -> void
       def visit_class_of(type); end
 
-      sig { params(type: Type::Generic).void }
+      #: (Type::Generic type) -> void
       def visit_generic(type); end
 
-      sig { params(type: Type::Nilable).void }
+      #: (Type::Nilable type) -> void
       def visit_nilable(type); end
 
-      sig { params(type: Type::Simple).void }
+      #: (Type::Simple type) -> void
       def visit_simple(type); end
 
-      sig { params(type: Type::NoReturn).void }
+      #: (Type::NoReturn type) -> void
       def visit_no_return(type); end
 
-      sig { params(type: Type::Proc).void }
+      #: (Type::Proc type) -> void
       def visit_proc(type); end
 
-      sig { params(type: Type::SelfType).void }
+      #: (Type::SelfType type) -> void
       def visit_self_type(type); end
 
-      sig { params(type: Type::Void).void }
+      #: (Type::Void type) -> void
       def visit_void(type); end
 
-      sig { params(type: Type::Shape).void }
+      #: (Type::Shape type) -> void
       def visit_shape(type); end
 
-      sig { params(type: Type::Tuple).void }
+      #: (Type::Tuple type) -> void
       def visit_tuple(type); end
 
-      sig { params(type: Type::TypeParameter).void }
+      #: (Type::TypeParameter type) -> void
       def visit_type_parameter(type); end
 
-      sig { params(type: Type::Untyped).void }
+      #: (Type::Untyped type) -> void
       def visit_untyped(type); end
     end
   end

data/lib/rbi/version.rb

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

data/lib/rbi/visitor.rb

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

data/lib/rbi.rb

@@ -3,11 +3,10 @@
 
 require "sorbet-runtime"
 require "stringio"
+require "rbs"
 
 module RBI
-  class Error < StandardError
-    extend T::Sig
-  end
+  class Error < StandardError; end
 end
 
 require "rbi/loc"
@@ -15,6 +14,10 @@ require "rbi/model"
 require "rbi/type"
 require "rbi/visitor"
 require "rbi/index"
+
+require "rbi/rbs/method_type_translator"
+require "rbi/rbs/type_translator"
+
 require "rbi/rewriters/add_sig_templates"
 require "rbi/rewriters/annotate"
 require "rbi/rewriters/deannotate"
@@ -29,6 +32,7 @@ require "rbi/rewriters/group_nodes"
 require "rbi/rewriters/remove_known_definitions"
 require "rbi/rewriters/attr_to_methods"
 require "rbi/rewriters/sort_nodes"
+require "rbi/rewriters/translate_rbs_sigs"
 require "rbi/parser"
 require "rbi/type_parser"
 require "rbi/type_visitor"