rbi 0.2.3 → 0.3.0

data/lib/rbi/parser.rb

@@ -5,12 +5,10 @@ require "prism"
 
 module RBI
   class ParseError < Error
-    extend T::Sig
-
-    sig { returns(Loc) }
+    #: Loc
     attr_reader :location
 
-    sig { params(message: String, location: Loc).void }
+    #: (String message, Loc location) -> void
     def initialize(message, location)
       super(message)
       @location = location
@@ -18,19 +16,17 @@ module RBI
   end
 
   class UnexpectedParserError < Error
-    extend T::Sig
-
-    sig { returns(Loc) }
+    #: Loc
     attr_reader :last_location
 
-    sig { params(parent_exception: Exception, last_location: Loc).void }
+    #: (Exception parent_exception, Loc last_location) -> void
     def initialize(parent_exception, last_location)
       super(parent_exception)
       set_backtrace(parent_exception.backtrace)
       @last_location = last_location
     end
 
-    sig { params(io: T.any(IO, StringIO)).void }
+    #: (?io: (IO | StringIO)) -> void
     def print_debug(io: $stderr)
       io.puts ""
       io.puts "##################################"
@@ -51,47 +47,43 @@ module RBI
   end
 
   class Parser
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig { params(string: String).returns(Tree) }
+      #: (String string) -> Tree
       def parse_string(string)
         Parser.new.parse_string(string)
       end
 
-      sig { params(path: String).returns(Tree) }
+      #: (String path) -> Tree
       def parse_file(path)
         Parser.new.parse_file(path)
       end
 
-      sig { params(paths: T::Array[String]).returns(T::Array[Tree]) }
+      #: (Array[String] paths) -> Array[Tree]
       def parse_files(paths)
         parser = Parser.new
         paths.map { |path| parser.parse_file(path) }
       end
 
-      sig { params(strings: T::Array[String]).returns(T::Array[Tree]) }
+      #: (Array[String] strings) -> Array[Tree]
       def parse_strings(strings)
         parser = Parser.new
         strings.map { |string| parser.parse_string(string) }
       end
     end
 
-    sig { params(string: String).returns(Tree) }
+    #: (String string) -> Tree
     def parse_string(string)
       parse(string, file: "-")
     end
 
-    sig { params(path: String).returns(Tree) }
+    #: (String path) -> Tree
     def parse_file(path)
       parse(::File.read(path), file: path)
     end
 
     private
 
-    sig { params(source: String, file: String).returns(Tree) }
+    #: (String source, file: String) -> Tree
     def parse(source, file:)
       result = Prism.parse(source)
       unless result.success?
@@ -120,9 +112,7 @@ module RBI
     end
 
     class Visitor < Prism::Visitor
-      extend T::Sig
-
-      sig { params(source: String, file: String).void }
+      #: (String source, file: String) -> void
       def initialize(source, file:)
         super()
 
@@ -132,34 +122,32 @@ module RBI
 
       private
 
-      sig { params(node: Prism::Node).returns(Loc) }
+      #: (Prism::Node node) -> Loc
       def node_loc(node)
         Loc.from_prism(@file, node.location)
       end
 
-      sig { params(node: T.nilable(Prism::Node)).returns(T.nilable(String)) }
+      #: (Prism::Node? node) -> String?
       def node_string(node)
         return unless node
 
         node.slice
       end
 
-      sig { params(node: Prism::Node).returns(String) }
+      #: (Prism::Node node) -> String
       def node_string!(node)
         T.must(node_string(node))
       end
     end
 
     class TreeBuilder < Visitor
-      extend T::Sig
-
-      sig { returns(Tree) }
+      #: Tree
       attr_reader :tree
 
-      sig { returns(T.nilable(Prism::Node)) }
+      #: Prism::Node?
       attr_reader :last_node
 
-      sig { params(source: String, comments: T::Array[Prism::Comment], file: String).void }
+      #: (String source, comments: Array[Prism::Comment], file: String) -> void
       def initialize(source, comments:, file:)
         super(source, file: file)
 
@@ -171,7 +159,8 @@ module RBI
         @last_sigs = T.let([], T::Array[RBI::Sig])
       end
 
-      sig { override.params(node: Prism::ClassNode).void }
+      # @override
+      #: (Prism::ClassNode node) -> void
       def visit_class_node(node)
         @last_node = node
         superclass_name = node_string(node.superclass)
@@ -206,21 +195,23 @@ module RBI
         @last_node = nil
       end
 
-      sig { override.params(node: Prism::ConstantWriteNode).void }
+      # @override
+      #: (Prism::ConstantWriteNode node) -> void
       def visit_constant_write_node(node)
         @last_node = node
         visit_constant_assign(node)
         @last_node = nil
       end
 
-      sig { override.params(node: Prism::ConstantPathWriteNode).void }
+      # @override
+      #: (Prism::ConstantPathWriteNode node) -> void
       def visit_constant_path_write_node(node)
         @last_node = node
         visit_constant_assign(node)
         @last_node = nil
       end
 
-      sig { params(node: T.any(Prism::ConstantWriteNode, Prism::ConstantPathWriteNode)).void }
+      #: ((Prism::ConstantWriteNode | Prism::ConstantPathWriteNode) node) -> void
       def visit_constant_assign(node)
         struct = parse_struct(node)
 
@@ -253,7 +244,8 @@ module RBI
         end
       end
 
-      sig { override.params(node: Prism::DefNode).void }
+      # @override
+      #: (Prism::DefNode node) -> void
       def visit_def_node(node)
         @last_node = node
 
@@ -274,7 +266,8 @@ module RBI
         @last_node = nil
       end
 
-      sig { override.params(node: Prism::ModuleNode).void }
+      # @override
+      #: (Prism::ModuleNode node) -> void
       def visit_module_node(node)
         @last_node = node
         scope = Module.new(
@@ -292,7 +285,8 @@ module RBI
         @last_node = nil
       end
 
-      sig { override.params(node: Prism::ProgramNode).void }
+      # @override
+      #: (Prism::ProgramNode node) -> void
       def visit_program_node(node)
         @last_node = node
         super
@@ -303,7 +297,8 @@ module RBI
         @last_node = nil
       end
 
-      sig { override.params(node: Prism::SingletonClassNode).void }
+      # @override
+      #: (Prism::SingletonClassNode node) -> void
       def visit_singleton_class_node(node)
         @last_node = node
         scope = SingletonClass.new(
@@ -320,7 +315,7 @@ module RBI
         @last_node = nil
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def visit_call_node(node)
         @last_node = node
         message = node.name.to_s
@@ -451,11 +446,6 @@ module RBI
                 loc: node_loc(node),
                 comments: node_comments(node),
               )
-            else
-              raise ParseError.new(
-                "Unexpected token `#{node.message}` before `#{last_node&.string&.strip}`",
-                node_loc(node),
-              )
             end
           else
             current_scope << parse_visibility(node.name.to_s, node)
@@ -499,7 +489,7 @@ module RBI
       private
 
       # Collect all the remaining comments within a node
-      sig { params(node: Prism::Node).void }
+      #: (Prism::Node node) -> void
       def collect_dangling_comments(node)
         first_line = node.location.start_line
         last_line = node.location.end_line
@@ -517,7 +507,7 @@ module RBI
       end
 
       # Collect all the remaining comments after visiting the tree
-      sig { void }
+      #: -> void
       def collect_orphan_comments
         last_line = T.let(nil, T.nilable(Integer))
         last_node_end = @tree.nodes.last&.loc&.end_line
@@ -540,19 +530,19 @@ module RBI
         end
       end
 
-      sig { returns(Tree) }
+      #: -> Tree
       def current_scope
         T.must(@scopes_stack.last) # Should never be nil since we create a Tree as the root
       end
 
-      sig { returns(T::Array[Sig]) }
+      #: -> Array[Sig]
       def current_sigs
         sigs = @last_sigs.dup
         @last_sigs.clear
         sigs
       end
 
-      sig { params(sigs: T::Array[Sig]).returns(T::Array[Comment]) }
+      #: (Array[Sig] sigs) -> Array[Comment]
       def detach_comments_from_sigs(sigs)
         comments = T.let([], T::Array[Comment])
 
@@ -564,7 +554,7 @@ module RBI
         comments
       end
 
-      sig { params(node: Prism::Node).returns(T::Array[Comment]) }
+      #: (Prism::Node node) -> Array[Comment]
       def node_comments(node)
         comments = []
 
@@ -582,12 +572,18 @@ module RBI
         comments
       end
 
-      sig { params(node: Prism::Comment).returns(Comment) }
+      #: (Prism::Comment node) -> Comment
       def parse_comment(node)
-        Comment.new(node.location.slice.gsub(/^# ?/, "").rstrip, loc: Loc.from_prism(@file, node.location))
+        loc = Loc.from_prism(@file, node.location)
+        string = node.location.slice
+        if string.start_with?("#:")
+          RBSComment.new(string.gsub(/^#: ?/, "").rstrip, loc: loc)
+        else
+          Comment.new(string.gsub(/^# ?/, "").rstrip, loc: loc)
+        end
       end
 
-      sig { params(node: T.nilable(Prism::Node)).returns(T::Array[Arg]) }
+      #: (Prism::Node? node) -> Array[Arg]
       def parse_send_args(node)
         args = T.let([], T::Array[Arg])
         return args unless node.is_a?(Prism::ArgumentsNode)
@@ -611,7 +607,7 @@ module RBI
         args
       end
 
-      sig { params(node: T.nilable(Prism::Node)).returns(T::Array[Param]) }
+      #: (Prism::Node? node) -> Array[Param]
       def parse_params(node)
         params = []
         return params unless node.is_a?(Prism::ParametersNode)
@@ -685,7 +681,7 @@ module RBI
         params
       end
 
-      sig { params(node: Prism::CallNode).returns(Sig) }
+      #: (Prism::CallNode node) -> Sig
       def parse_sig(node)
         builder = SigBuilder.new(@source, file: @file)
         builder.current.loc = node_loc(node)
@@ -694,7 +690,7 @@ module RBI
         builder.current
       end
 
-      sig { params(node: T.any(Prism::ConstantWriteNode, Prism::ConstantPathWriteNode)).returns(T.nilable(Struct)) }
+      #: ((Prism::ConstantWriteNode | Prism::ConstantPathWriteNode) node) -> Struct?
       def parse_struct(node)
         send = node.value
         return unless send.is_a?(Prism::CallNode)
@@ -722,8 +718,6 @@ module RBI
 
                 keyword_init = val == "true" if key == "keyword_init:"
               end
-            else
-              raise ParseError.new("Unexpected node type `#{arg.class}`", node_loc(arg))
             end
           end
         end
@@ -744,7 +738,7 @@ module RBI
         struct
       end
 
-      sig { params(send: Prism::CallNode).void }
+      #: (Prism::CallNode send) -> void
       def parse_tstruct_field(send)
         args = send.arguments
         return unless args.is_a?(Prism::ArgumentsNode)
@@ -781,7 +775,7 @@ module RBI
         end
       end
 
-      sig { params(name: String, node: Prism::Node).returns(Visibility) }
+      #: (String name, Prism::Node node) -> Visibility
       def parse_visibility(name, node)
         case name
         when "public"
@@ -795,7 +789,7 @@ module RBI
         end
       end
 
-      sig { void }
+      #: -> void
       def separate_header_comments
         current_scope.nodes.dup.each do |child_node|
           break unless child_node.is_a?(Comment) || child_node.is_a?(BlankLine)
@@ -805,7 +799,7 @@ module RBI
         end
       end
 
-      sig { void }
+      #: -> void
       def set_root_tree_loc
         first_loc = tree.nodes.first&.loc
         last_loc = tree.nodes.last&.loc
@@ -819,26 +813,25 @@ module RBI
         )
       end
 
-      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Prism::Node? node) -> bool
       def type_variable_definition?(node)
         node.is_a?(Prism::CallNode) && (node.message == "type_member" || node.message == "type_template")
       end
     end
 
     class SigBuilder < Visitor
-      extend T::Sig
-
-      sig { returns(Sig) }
+      #: Sig
       attr_reader :current
 
-      sig { params(content: String, file: String).void }
+      #: (String content, file: String) -> void
       def initialize(content, file:)
         super
 
         @current = T.let(Sig.new, Sig)
       end
 
-      sig { override.params(node: Prism::CallNode).void }
+      # @override
+      #: (Prism::CallNode node) -> void
       def visit_call_node(node)
         case node.message
         when "sig"
@@ -899,7 +892,8 @@ module RBI
         visit(node.block)
       end
 
-      sig { override.params(node: Prism::AssocNode).void }
+      # @override
+      #: (Prism::AssocNode node) -> void
       def visit_assoc_node(node)
         @current.params << SigParam.new(
           node_string!(node.key).delete_suffix(":"),