rbs 4.0.3 → 4.1.0.pre.1

data/include/rbs/defines.h

@@ -83,4 +83,17 @@
 #define RBS_ATTRIBUTE_UNUSED
 #endif
 
+/**
+ * Nullability annotations for pointer types.
+ * Clang supports _Nullable and _Nonnull to indicate whether a pointer may be NULL.
+ * On other compilers, these expand to nothing.
+ */
+#ifdef __clang__
+#define RBS_NULLABLE _Nullable
+#define RBS_NONNULL _Nonnull
+#else
+#define RBS_NULLABLE
+#define RBS_NONNULL
+#endif
+
 #endif

data/include/rbs/lexer.h

@@ -70,6 +70,7 @@ enum RBSTokenType {
     kATRBS,        /* @rbs */
     kSKIP,         /* skip */
     kRETURN,       /* return */
+    kMODULESELF,   /* module-self */
 
     tLIDENT,    /* Identifiers starting with lower case */
     tUIDENT,    /* Identifiers starting with upper case */

data/lib/rbs/annotate/rdoc_annotator.rb

@@ -13,25 +13,22 @@ module RBS
         @include_filename = true
       end
 
-      def annotate_file(path, preserve:)
-        content = path.read()
+      def annotate_file(path, preserve: true)
+        buffer, _, decls = Parser.parse_signature(path.read())
 
-        _, _, decls = Parser.parse_signature(content)
+        rewriter = Rewriter.new(buffer)
+        annotate_decls(decls, rewriter)
 
-        annotate_decls(decls)
-
-        path.open("w") do |io|
-          Writer.new(out: io).preserve!(preserve: preserve).write(decls)
-        end
+        path.write(rewriter.string)
       end
 
-      def annotate_decls(decls, outer: [])
+      def annotate_decls(decls, rewriter, outer: [])
         decls.each do |decl|
           case decl
           when AST::Declarations::Class, AST::Declarations::Module
-            annotate_class(decl, outer: outer)
+            annotate_class(decl, rewriter, outer: outer)
           when AST::Declarations::Constant
-            annotate_constant(decl, outer: outer)
+            annotate_constant(decl, rewriter, outer: outer)
           end
         end
       end
@@ -244,7 +241,7 @@ module RBS
         end
       end
 
-      def annotate_class(decl, outer:)
+      def annotate_class(decl, rewriter, outer:)
         annots = annotations(decl)
 
         full_name = resolve_name(decl.name, outer: outer)
@@ -252,7 +249,7 @@ module RBS
           text = resolve_doc_source(annots.copy_annotation, tester: annots) { doc_for_class(full_name, tester: annots) }
         end
 
-        replace_comment(decl, text)
+        replace_comment(decl, text, rewriter)
 
         unless annots.skip_all?
           outer_ = outer + [decl.name.to_namespace]
@@ -260,28 +257,28 @@ module RBS
           decl.each_member do |member|
             case member
             when AST::Members::MethodDefinition
-              annotate_method(full_name, member)
+              annotate_method(full_name, member, rewriter)
             when AST::Members::Alias
-              annotate_alias(full_name, member)
+              annotate_alias(full_name, member, rewriter)
             when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
-              annotate_attribute(full_name, member)
+              annotate_attribute(full_name, member, rewriter)
             end
           end
 
-          annotate_decls(decl.each_decl.to_a, outer: outer_)
+          annotate_decls(decl.each_decl.to_a, rewriter, outer: outer_)
         end
       end
 
-      def annotate_constant(const, outer:)
+      def annotate_constant(const, rewriter, outer:)
         annots = Annotations.new([])
 
         full_name = resolve_name(const.name, outer: outer)
         text = doc_for_constant(full_name, tester: annots)
 
-        replace_comment(const, text)
+        replace_comment(const, text, rewriter)
       end
 
-      def annotate_alias(typename, als)
+      def annotate_alias(typename, als, rewriter)
         annots = annotations(als)
 
         unless annots.skip?
@@ -295,7 +292,7 @@ module RBS
           end
         end
 
-        replace_comment(als, text)
+        replace_comment(als, text, rewriter)
       end
 
       def join_docs(docs, separator: "----")
@@ -311,7 +308,7 @@ module RBS
         end
       end
 
-      def annotate_method(typename, method)
+      def annotate_method(typename, method, rewriter)
         annots = annotations(method)
 
         unless annots.skip?
@@ -337,10 +334,10 @@ module RBS
           }
         end
 
-        replace_comment(method, text)
+        replace_comment(method, text, rewriter)
       end
 
-      def annotate_attribute(typename, attr)
+      def annotate_attribute(typename, attr, rewriter)
         annots = annotations(attr)
 
         unless annots.skip?
@@ -368,18 +365,17 @@ module RBS
           end
         end
 
-        replace_comment(attr, text)
+        replace_comment(attr, text, rewriter)
       end
 
-      def replace_comment(commented, string)
+      def replace_comment(commented, string, rewriter)
         if string
           if string.empty?
-            commented.instance_variable_set(:@comment, nil)
+            rewriter.delete_comment(commented.comment) if commented.comment
+          elsif commented.comment
+            rewriter.replace_comment(commented.comment, content: string)
           else
-            commented.instance_variable_set(
-              :@comment,
-              AST::Comment.new(location: nil, string: string)
-            )
+            rewriter.add_comment(commented.location || raise, *commented.annotations.filter_map(&:location), content: string)
           end
         end
       end

data/lib/rbs/ast/ruby/annotations.rb

@@ -353,6 +353,48 @@ module RBS
           end
         end
 
+        class ModuleSelfAnnotation < Base
+          attr_reader :keyword_location, :colon_location, :name, :args, :open_bracket_location, :close_bracket_location, :args_comma_locations, :comment_location
+
+          def initialize(location:, prefix_location:, keyword_location:, colon_location:, name:, args:, open_bracket_location:, close_bracket_location:, args_comma_locations:, comment_location:)
+            super(location, prefix_location)
+            @keyword_location = keyword_location
+            @colon_location = colon_location
+            @name = name
+            @args = args
+            @open_bracket_location = open_bracket_location
+            @close_bracket_location = close_bracket_location
+            @args_comma_locations = args_comma_locations
+            @comment_location = comment_location
+          end
+
+          def map_type_name
+            mapped_args = args.map { |type| type.map_type_name { yield _1 } }
+
+            self.class.new(
+              location:,
+              prefix_location:,
+              keyword_location:,
+              colon_location:,
+              name: yield(name),
+              args: mapped_args,
+              open_bracket_location:,
+              close_bracket_location:,
+              args_comma_locations:,
+              comment_location:
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/module_self",
+              name.to_s,
+              args.map(&:to_s),
+              comment_location&.source
+            ]
+          end
+        end
+
         class BlockParamTypeAnnotation < Base
           attr_reader :ampersand_location, :name_location, :colon_location, :question_location, :type_location, :type, :comment_location
 

data/lib/rbs/ast/ruby/declarations.rb

@@ -137,7 +137,17 @@ module RBS
 
           def type_params = []
 
-          def self_types = []
+          def self_types
+            members.filter_map do |member|
+              if member.is_a?(Members::ModuleSelfMember)
+                AST::Declarations::Module::Self.new(
+                  name: member.name,
+                  args: member.args,
+                  location: member.location
+                )
+              end
+            end
+          end
 
           def location
             rbs_location(node.location)

data/lib/rbs/ast/ruby/members.rb

@@ -717,6 +717,34 @@ module RBS
             ]
           end
         end
+
+        class ModuleSelfMember < Base
+          attr_reader :annotation
+
+          def initialize(buffer, annotation)
+            super(buffer)
+            @annotation = annotation
+          end
+
+          def name
+            annotation.name
+          end
+
+          def args
+            annotation.args
+          end
+
+          def location
+            annotation.location
+          end
+
+          def type_fingerprint
+            [
+              "members/module_self",
+              annotation.type_fingerprint
+            ]
+          end
+        end
       end
     end
   end

data/lib/rbs/cli.rb

@@ -962,8 +962,6 @@ Options:
       source = RBS::Annotate::RDocSource.new()
       annotator = RBS::Annotate::RDocAnnotator.new(source: source)
 
-      preserve = true
-
       OptionParser.new do |opts|
         opts.banner = <<-EOB
 Usage: rbs annotate [options...] [files...]
@@ -984,7 +982,7 @@ Options:
         opts.on("-d", "--dir DIRNAME", "Load RDoc from DIRNAME") {|d| source.extra_dirs << Pathname(d) }
         opts.on("--[no-]arglists", "Generate arglists section (defaults to true)") {|b| annotator.include_arg_lists = b }
         opts.on("--[no-]filename", "Include source file name in the documentation (defaults to true)") {|b| annotator.include_filename = b }
-        opts.on("--[no-]preserve", "Try preserve the format of the original file (defaults to true)") {|b| preserve = b }
+        opts.on("--[no-]preserve", "[Deprecated] It always preserves the format") { stdout.puts "The `--preserve` option is deprecated. The tool always preserves the format of RBS files." }
       end.parse!(args)
 
       source.load()
@@ -994,11 +992,11 @@ Options:
         if path.directory?
           Pathname.glob((path + "**/*.rbs").to_s).each do |path|
             stdout.puts "Processing #{path}..."
-            annotator.annotate_file(path, preserve: preserve)
+            annotator.annotate_file(path)
           end
         else
           stdout.puts "Processing #{path}..."
-          annotator.annotate_file(path, preserve: preserve)
+          annotator.annotate_file(path)
         end
       end
 

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -21,6 +21,17 @@ module RBS
           "pstore" => nil,
         }
 
+        NONGEM_STDLIBS = Set[
+          "cgi-escape",
+          "coverage",
+          "monitor",
+          "objspace",
+          "pathname",
+          "pty",
+          "ripper",
+          "socket",
+        ]
+
         class GemfileLockMismatchError < StandardError
           def initialize(expected:, actual:)
             @expected = expected
@@ -168,7 +179,9 @@ module RBS
               end
             end
           else
-            RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
+            unless NONGEM_STDLIBS.include?(name)
+              RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
+            end
           end
         end
 

data/lib/rbs/environment.rb

@@ -854,6 +854,12 @@ module RBS
           member.buffer,
           resolved_annotation
         )
+      when AST::Ruby::Members::ModuleSelfMember
+        resolved_annotation = member.annotation.map_type_name {|name| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::ModuleSelfMember.new(
+          member.buffer,
+          resolved_annotation
+        )
       else
         raise "Unknown member type: #{member.class}"
       end

data/lib/rbs/inline_parser.rb

@@ -119,7 +119,53 @@ module RBS
 
         class_decl = AST::Ruby::Declarations::ClassDecl.new(buffer, class_name, node, super_class)
         insert_declaration(class_decl)
-        push_module_nesting(class_decl) do
+        visit_class_or_module_body(class_decl, node)
+      end
+
+      def visit_module_node(node)
+        return if skip_node?(node)
+
+        unless module_name = constant_as_type_name(node.constant_path)
+          diagnostics << Diagnostic::NonConstantModuleName.new(
+            rbs_location(node.constant_path.location),
+            "Module name must be a constant"
+          )
+          return
+        end
+
+        module_decl = AST::Ruby::Declarations::ModuleDecl.new(buffer, module_name, node)
+
+        if leading_ref = comments.leading_block(node)
+          unused_annotations = [] #: Array[AST::Ruby::CommentBlock::AnnotationSyntaxError | AST::Ruby::Annotations::leading_annotation]
+
+          leading_ref.block.each_paragraph([]) do |paragraph|
+            case paragraph
+            when AST::Ruby::Annotations::ModuleSelfAnnotation
+              module_decl.members << AST::Ruby::Members::ModuleSelfMember.new(buffer, paragraph)
+            when Location
+              # Skip
+            when AST::Ruby::CommentBlock::AnnotationSyntaxError
+              unused_annotations << paragraph
+            when AST::Ruby::Annotations::SkipAnnotation
+              # Already handled by skip_node?
+            else
+              unused_annotations << paragraph
+            end
+          end
+
+          unless unused_annotations.empty?
+            report_unused_annotation(*unused_annotations)
+          end
+
+          leading_ref.associate!
+        end
+
+        insert_declaration(module_decl)
+        visit_class_or_module_body(module_decl, node)
+      end
+
+      def visit_class_or_module_body(decl, node)
+        push_module_nesting(decl) do
           visit_child_nodes(node)
 
           node.child_nodes.each do |child_node|
@@ -137,7 +183,7 @@ module RBS
           block.each_paragraph([]) do |paragraph|
             case paragraph
             when AST::Ruby::Annotations::InstanceVariableAnnotation
-              class_decl.members << AST::Ruby::Members::InstanceVariableMember.new(buffer, paragraph)
+              decl.members << AST::Ruby::Members::InstanceVariableMember.new(buffer, paragraph)
             when Location
               # Skip
             when AST::Ruby::CommentBlock::AnnotationSyntaxError
@@ -150,29 +196,7 @@ module RBS
           report_unused_annotation(*unused_annotations)
         end
 
-        class_decl.members.sort_by! { _1.location.start_line }
-      end
-
-      def visit_module_node(node)
-        return if skip_node?(node)
-
-        unless module_name = constant_as_type_name(node.constant_path)
-          diagnostics << Diagnostic::NonConstantModuleName.new(
-            rbs_location(node.constant_path.location),
-            "Module name must be a constant"
-          )
-          return
-        end
-
-        module_decl = AST::Ruby::Declarations::ModuleDecl.new(buffer, module_name, node)
-        insert_declaration(module_decl)
-        push_module_nesting(module_decl) do
-          visit_child_nodes(node)
-        end
-
-        comments.each_enclosed_block(node) do |block|
-          report_unused_block(block)
-        end
+        decl.members.sort_by! { _1.location.start_line }
       end
 
       def visit_def_node(node)

data/lib/rbs/rewriter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RBS
+  class Rewriter
+    attr_reader :buffer
+
+    def initialize(buffer)
+      raise "Rewriter only supports toplevel buffers" if buffer.parent
+
+      @buffer = buffer
+      @rewrites = []
+    end
+
+    def rewrite(location, string)
+      @rewrites.each do |existing_location, _|
+        if location.start_pos < existing_location.end_pos && existing_location.start_pos < location.end_pos
+          raise "Overlapping rewrites: #{existing_location} and #{location}"
+        end
+      end
+
+      @rewrites << [location, string]
+      self
+    end
+
+    def add_comment(*locations, content:)
+      earliest = locations.min_by(&:start_pos) or raise "At least one location is required"
+      insert_pos = earliest.start_pos
+      indent = " " * earliest.start_column
+
+      formatted = format_comment(content, indent)
+
+      loc = Location.new(buffer, insert_pos, insert_pos)
+      rewrite(loc, "#{formatted}\n#{indent}")
+    end
+
+    def replace_comment(comment, content:)
+      location = comment.location or raise "Comment must have a location"
+      indent = " " * location.start_column
+
+      rewrite(location, format_comment(content, indent))
+    end
+
+    def delete_comment(comment)
+      location = comment.location or raise "Comment must have a location"
+      line_start = location.start_pos - location.start_column
+      line_end = location.end_pos + 1
+      loc = Location.new(buffer, line_start, line_end)
+      rewrite(loc, "")
+    end
+
+    def string
+      result = buffer.content.dup
+
+      @rewrites.sort_by { |location, _| location.start_pos }.reverse_each do |location, replacement|
+        result[location.start_pos...location.end_pos] = replacement
+      end
+
+      result
+    end
+
+    private
+
+    def format_comment(content, indent)
+      content.lines.map do |line|
+        line = line.chomp
+        line.empty? ? "#" : "# #{line}"
+      end.join("\n#{indent}")
+    end
+  end
+end

data/lib/rbs/test/type_check.rb

@@ -356,7 +356,12 @@ module RBS
         when Types::Variable
           true
         when Types::Literal
-          type.literal == val
+          begin
+            type.literal == val
+          rescue NoMethodError
+            raise if defined?(val.==)
+            false
+          end
         when Types::Union
           type.types.any? {|type| value(val, type) }
         when Types::Intersection

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "4.0.3"
+  VERSION = "4.1.0.pre.1"
 end

data/lib/rbs.rb

@@ -51,6 +51,7 @@ require "rbs/resolver/constant_resolver"
 require "rbs/resolver/type_name_resolver"
 require "rbs/ast/comment"
 require "rbs/writer"
+require "rbs/rewriter"
 require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"

data/sig/annotate/rdoc_annotater.rbs

@@ -8,9 +8,10 @@ module RBS
 
       def initialize: (source: RDocSource) -> void
 
-      def annotate_file: (Pathname, preserve: bool) -> void
+      def annotate_file: (Pathname) -> void
+                       | %a{deprecated: it preserves the format by default} (Pathname, preserve: bool) -> void
 
-      def annotate_decls: (Array[AST::Declarations::t], ?outer: Array[Namespace]) -> void
+      def annotate_decls: (Array[AST::Declarations::t], Rewriter, ?outer: Array[Namespace]) -> void
 
       interface _PathTester
         def test_path: (String) -> bool
@@ -50,15 +51,15 @@ module RBS
 
       def resolve_doc_source: (Annotations::Copy?, tester: _PathTester) { () -> String? } -> String?
 
-      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, outer: Array[Namespace]) -> void
+      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, Rewriter, outer: Array[Namespace]) -> void
 
-      def annotate_constant: (AST::Declarations::Constant, outer: Array[Namespace]) -> void
+      def annotate_constant: (AST::Declarations::Constant, Rewriter, outer: Array[Namespace]) -> void
 
-      def annotate_method: (TypeName, AST::Members::MethodDefinition) -> void
+      def annotate_method: (TypeName, AST::Members::MethodDefinition, Rewriter) -> void
 
-      def annotate_alias: (TypeName, AST::Members::Alias) -> void
+      def annotate_alias: (TypeName, AST::Members::Alias, Rewriter) -> void
 
-      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor) -> void
+      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor, Rewriter) -> void
 
       def annotations: (_Annotated) -> Annotations
 
@@ -70,10 +71,12 @@ module RBS
       # - If empty string is given as `comment`, it deletes the original comment.
       # - If `nil` is given as `comment`, it keeps the original comment.
       #
-      def replace_comment: (Object & _Commented, String? comment) -> void
+      def replace_comment: (_Commented, String?, Rewriter) -> void
 
       interface _Commented
-        def comment: () -> AST::Comment?
+        %a{pure} def comment: () -> AST::Comment?
+        %a{pure} def location: () -> Location[untyped, untyped]?
+        def annotations: () -> Array[AST::Annotation]
       end
 
       def resolve_name: (TypeName, outer: Array[Namespace]) -> TypeName

data/sig/ast/ruby/annotations.rbs

@@ -7,6 +7,7 @@ module RBS
                                 | SkipAnnotation
                                 | ReturnTypeAnnotation
                                 | InstanceVariableAnnotation
+                                | ModuleSelfAnnotation
                                 | ParamTypeAnnotation
                                 | SplatParamTypeAnnotation
                                 | DoubleSplatParamTypeAnnotation
@@ -237,6 +238,54 @@ module RBS
           def type_fingerprint: () -> untyped
         end
 
+        # `@rbs module-self: NAME[ARGS] -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs module-self: _Each[String, Integer] -- comment
+        # ^^^^                                                -- prefix_location
+        #      ^^^^^^^^^^^                                    -- keyword_location
+        #                 ^                                   -- colon_location
+        #                        ^                            -- open_bracket_location
+        #                               ^                     -- args_comma_locations[0]
+        #                                        ^            -- close_bracket_location
+        #                                          ^^^^^^^^^^ -- comment_location
+        # ```
+        #
+        class ModuleSelfAnnotation < Base
+          attr_reader keyword_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader name: TypeName
+
+          attr_reader args: Array[Types::t]
+
+          attr_reader open_bracket_location: Location?
+
+          attr_reader close_bracket_location: Location?
+
+          attr_reader args_comma_locations: Array[Location]
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            keyword_location: Location,
+            colon_location: Location,
+            name: TypeName,
+            args: Array[Types::t],
+            open_bracket_location: Location?,
+            close_bracket_location: Location?,
+            args_comma_locations: Array[Location],
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
         class ParamTypeAnnotation < Base
           attr_reader name_location: Location