rbi 0.2.4 → 0.3.0

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?
@@ -22,7 +22,7 @@ module RBI
         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
@@ -48,7 +48,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 +65,7 @@ module RBI
         end
       end
 
-      sig { params(node: Prism::CallNode).returns(Type) }
+      #: (Prism::CallNode node) -> Type
       def parse_call(node)
         recv = node.receiver
 
@@ -167,12 +167,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)
@@ -191,7 +191,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.`
@@ -231,7 +231,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 +246,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,7 +259,7 @@ 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))
@@ -272,7 +272,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 +284,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.0"
 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
@@ -104,142 +105,145 @@ 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 }
+    #: (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"