rbi 0.2.2 → 0.3.3

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,46 +122,66 @@ 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))
+        node_string(node) #: as !nil
+      end
+
+      #: (Prism::Node node) -> Prism::Location
+      def adjust_prism_location_for_heredoc(node)
+        visitor = HeredocLocationVisitor.new(
+          node.location.send(:source),
+          node.location.start_offset,
+          node.location.end_offset,
+        )
+        visitor.visit(node)
+        visitor.location
+      end
+
+      #: (Prism::Node? node) -> bool
+      def self?(node)
+        node.is_a?(Prism::SelfNode)
+      end
+
+      #: (Prism::Node? node) -> bool
+      def t_sig_without_runtime?(node)
+        !!(node.is_a?(Prism::ConstantPathNode) && node_string(node) =~ /(::)?T::Sig::WithoutRuntime/)
       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)
 
-        @comments_by_line = T.let(comments.to_h { |c| [c.location.start_line, c] }, T::Hash[Integer, Prism::Comment])
-        @tree = T.let(Tree.new, Tree)
+        @comments_by_line = comments.to_h { |c| [c.location.start_line, c] } #: Hash[Integer, Prism::Comment]
+        @tree = Tree.new #: Tree
 
-        @scopes_stack = T.let([@tree], T::Array[Tree])
-        @last_node = T.let(nil, T.nilable(Prism::Node))
-        @last_sigs = T.let([], T::Array[RBI::Sig])
+        @scopes_stack = [@tree] #: Array[Tree]
+        @last_node = nil #: Prism::Node?
+        @last_sigs = [] #: 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,54 +216,78 @@ 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)
 
         current_scope << if struct
           struct
-        elsif type_variable_definition?(node.value)
-          TypeMember.new(
+        elsif t_enum_value?(node)
+          TEnumValue.new(
             case node
             when Prism::ConstantWriteNode
               node.name.to_s
             when Prism::ConstantPathWriteNode
               node_string!(node.target)
             end,
-            node_string!(node.value),
             loc: node_loc(node),
             comments: node_comments(node),
           )
         else
-          Const.new(
-            case node
-            when Prism::ConstantWriteNode
-              node.name.to_s
-            when Prism::ConstantPathWriteNode
-              node_string!(node.target)
-            end,
-            node_string!(node.value),
-            loc: node_loc(node),
-            comments: node_comments(node),
+          adjusted_node_location = adjust_prism_location_for_heredoc(node)
+
+          adjusted_value_location = Prism::Location.new(
+            node.value.location.send(:source),
+            node.value.location.start_offset,
+            adjusted_node_location.end_offset - node.value.location.start_offset,
           )
+
+          if type_variable_definition?(node.value)
+            TypeMember.new(
+              case node
+              when Prism::ConstantWriteNode
+                node.name.to_s
+              when Prism::ConstantPathWriteNode
+                node_string!(node.target)
+              end,
+              adjusted_value_location.slice,
+              loc: Loc.from_prism(@file, adjusted_node_location),
+              comments: node_comments(node),
+            )
+          else
+            Const.new(
+              case node
+              when Prism::ConstantWriteNode
+                node.name.to_s
+              when Prism::ConstantPathWriteNode
+                node_string!(node.target)
+              end,
+              adjusted_value_location.slice,
+              loc: Loc.from_prism(@file, adjusted_node_location),
+              comments: node_comments(node),
+            )
+          end
         end
       end
 
-      sig { override.params(node: Prism::DefNode).void }
+      # @override
+      #: (Prism::DefNode node) -> void
       def visit_def_node(node)
         @last_node = node
 
@@ -274,7 +308,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 +327,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 +339,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 +357,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 +488,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)
@@ -483,6 +515,10 @@ module RBI
             comments: node_comments(node),
           )
         when "sig"
+          unless node.receiver.nil? || self?(node.receiver) || t_sig_without_runtime?(node.receiver)
+            @last_node = nil
+            return
+          end
           @last_sigs << parse_sig(node)
         else
           current_scope << Send.new(
@@ -499,7 +535,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,9 +553,9 @@ 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_line = nil #: Integer?
         last_node_end = @tree.nodes.last&.loc&.end_line
 
         @comments_by_line.each do |line, comment|
@@ -540,21 +576,21 @@ 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
+        @scopes_stack.last #: as !nil # 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])
+        comments = [] #: Array[Comment]
 
         sigs.each do |sig|
           comments += sig.comments.dup
@@ -564,7 +600,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,14 +618,22 @@ 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
+        # We also ignore RDoc directives such as `:nodoc:`
+        # See https://ruby.github.io/rdoc/RDoc/MarkupReference.html#class-RDoc::MarkupReference-label-Directives
+        if string.start_with?("#:") && !(string =~ /^#:[a-z_]+:/)
+          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])
+        args = [] #: Array[Arg]
         return args unless node.is_a?(Prism::ArgumentsNode)
 
         node.arguments.each do |arg|
@@ -600,18 +644,20 @@ module RBI
 
               args << KwArg.new(
                 node_string!(assoc.key).delete_suffix(":"),
-                T.must(node_string(assoc.value)),
+                node_string(assoc.value), #: as !nil
               )
             end
           else
-            args << Arg.new(T.must(node_string(arg)))
+            args << Arg.new(
+              node_string(arg), #: as !nil
+            )
           end
         end
 
         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 +731,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 +740,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)
@@ -705,7 +751,7 @@ module RBI
         return unless node_string(recv) =~ /(::)?Struct/
 
         members = []
-        keyword_init = T.let(false, T::Boolean)
+        keyword_init = false #: bool
 
         args = send.arguments
         if args.is_a?(Prism::ArgumentsNode)
@@ -722,8 +768,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 +788,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)
@@ -757,7 +801,7 @@ module RBI
         type = node_string!(type_arg)
         loc = node_loc(send)
         comments = node_comments(send)
-        default_value = T.let(nil, T.nilable(String))
+        default_value = nil #: String?
 
         rest.each do |arg|
           next unless arg.is_a?(Prism::KeywordHashNode)
@@ -781,7 +825,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 +839,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 +849,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,29 +863,43 @@ 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
+
+      #: (Prism::Node? node) -> bool
+      def t_enum_value?(node)
+        return false unless current_scope.is_a?(TEnumBlock)
+
+        return false unless node.is_a?(Prism::ConstantWriteNode)
+
+        value = node.value
+        return false unless value.is_a?(Prism::CallNode)
+        return false unless value.message == "new"
+
+        true
+      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)
+        @current = 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"
+          @current.without_runtime = t_sig_without_runtime?(node.receiver)
+
           args = node.arguments
           if args.is_a?(Prism::ArgumentsNode)
             args.arguments.each do |arg|
@@ -858,6 +916,22 @@ module RBI
           end
         when "override"
           @current.is_override = true
+
+          args = node.arguments&.arguments
+
+          keywords_hash = args
+            &.grep(Prism::KeywordHashNode)
+            &.first
+
+          allow_incompatible_override = keywords_hash
+            &.elements
+            &.any? do |assoc|
+              assoc.is_a?(Prism::AssocNode) &&
+                node_string(assoc.key) == "allow_incompatible:" &&
+                node_string(assoc.value) == "true"
+            end
+
+          @current.allow_incompatible_override = !!allow_incompatible_override
         when "overridable"
           @current.is_overridable = true
         when "params"
@@ -883,7 +957,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(":"),
@@ -891,5 +966,59 @@ module RBI
         )
       end
     end
+
+    class HeredocLocationVisitor < Prism::Visitor
+      #: (Prism::Source source, Integer begin_offset, Integer end_offset) -> void
+      def initialize(source, begin_offset, end_offset)
+        super()
+        @source = source
+        @begin_offset = begin_offset
+        @end_offset = end_offset
+        @offset_last_newline = false #: bool
+      end
+
+      # @override
+      #: (Prism::StringNode node) -> void
+      def visit_string_node(node)
+        return unless node.heredoc?
+
+        closing_loc = node.closing_loc
+        return unless closing_loc
+
+        handle_string_node(node)
+      end
+
+      # @override
+      #: (Prism::InterpolatedStringNode node) -> void
+      def visit_interpolated_string_node(node)
+        return super unless node.heredoc?
+
+        closing_loc = node.closing_loc
+        return super unless closing_loc
+
+        handle_string_node(node)
+      end
+
+      #: -> Prism::Location
+      def location
+        Prism::Location.new(
+          @source,
+          @begin_offset,
+          @end_offset - @begin_offset - (@offset_last_newline ? 1 : 0),
+        )
+      end
+
+      private
+
+      #: (Prism::StringNode | Prism::InterpolatedStringNode node) -> void
+      def handle_string_node(node)
+        closing_loc = node.closing_loc #: as !nil
+
+        if closing_loc.end_offset > @end_offset
+          @end_offset = closing_loc.end_offset
+          @offset_last_newline = true if node.closing_loc&.slice&.end_with?("\n")
+        end
+      end
+    end
   end
 end