rubocop-on-rbs 0.2.0

data/lib/rubocop/cop/rbs/layout/extra_spacing.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   def   foo:   ()   ->   void
+        #
+        #   # good
+        #   def foo: () -> void
+        class ExtraSpacing < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          MSG = 'Unnecessary spacing detected.'
+
+          def on_rbs_new_investigation
+            aligned_comments = aligned_locations()
+            tokens = processed_rbs_source.tokens.reject { |t| t.type == :tTRIVIA }
+            tokens.each_cons(2) do |a, b|
+              next unless a&.location
+              next unless b&.location
+
+              if (b.type == :tCOMMENT || b.type == :tLINECOMMENT)
+                next if aligned_comments.include?(b.location.start_line)
+              end
+              next if a.location.end_line != b.location.start_line
+              next if a.location.end_pos + 1 >= b.location.start_pos
+
+              space = range_between(a.location.end_pos, b.location.start_pos - 1)
+              add_offense(space) do |corrector|
+                corrector.remove(space)
+              end
+            end
+          end
+
+          def aligned_locations
+            comments = processed_rbs_source.tokens.select(&:comment?)
+            Set.new.tap do |aligned|
+              comments.map(&:location).each_cons(2) do |loc1, loc2|
+                next unless loc1
+                next unless loc2
+
+                if loc1.start_column == loc2.start_column
+                  aligned << loc1.start_line << loc2.start_line
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/layout/indentation_width.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   class Foo
+        #   def foo: () -> void
+        #   end
+        #
+        #   # good
+        #   class Foo
+        #     def foo: () -> void
+        #   end
+        class IndentationWidth < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          def on_rbs_new_investigation
+            @first_char_columns = processed_source.raw_source.each_line.map do |line|
+              line.index(/[^[:space:]]/) || 0
+            end
+            processed_rbs_source.decls.each do |decl|
+              check_indentation(decl, expect: 0)
+            end
+          end
+
+          def check_indentation(decl, expect:)
+            if decl.respond_to?(:members)
+              check(decl, expect: expect)
+              decl.members.each do |member|
+                check_indentation(member, expect: expect + 2)
+              end
+            else
+              check(decl, expect: expect)
+            end
+          end
+
+          def check(decl, expect:)
+            line_start_pos = line_start_pos(decl)
+            actual = @first_char_columns[decl.location.start_line - 1]
+            if actual != expect
+              range = range_between(line_start_pos, line_start_pos + actual)
+              message = "Use #{expect} (not #{actual}) spaces for indentation."
+              add_offense(range, message: message) do |corrector|
+                corrector.replace(range, ' ' * expect)
+              end
+            end
+          end
+
+          def line_start_pos(decl)
+            rindex = processed_source.raw_source.rindex(/\R/, decl.location.start_pos)
+            if rindex
+              rindex + 1
+            else
+              0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/layout/overload_indentation.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   def foo: () -> String | () -> (Integer)
+        #
+        #   # bad
+        #   def foo: () -> String
+        #       | () -> (Integer)
+        #
+        #   # bad
+        #   def foo: () -> String |
+        #            () -> (Integer)
+        #
+        #   # good
+        #   def foo: () -> String
+        #          | () -> Integer
+        class OverloadIndentation < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          def on_rbs_def(decl)
+            base_pos = decl.location.start_pos
+            base_col = decl.location.start_column
+            overload_starts = decl.overloads.map { |overload| overload.method_type.location.start_pos }
+            tokens = ::RBS::Parser.lex(decl.location.source).value.reject { |t| t.type == :tTRIVIA }
+            first_colon_column = base_col + tokens.find { |t| t.type == :pCOLON }&.location&.start_column
+            ([nil] + tokens).each_cons(3) do |before, bar, after|
+              next unless before
+              next unless bar
+              next unless after
+              next unless bar&.type == :pBAR
+
+              loc = bar&.location
+              next unless loc
+              next unless overload_starts.include?(base_pos + after.location.start_pos)
+
+              if before.location.end_line == bar.location.start_line
+                range = range_between(base_pos + bar.location.start_pos, base_pos + bar.location.end_pos)
+                add_offense(range, message: "Insert newline before `|`") do |corrector|
+                  space = range_between(base_pos + before.location.end_pos, base_pos + bar.location.start_pos)
+                  corrector.replace(space, "\n#{' ' * first_colon_column}")
+                end
+              end
+
+              if bar.location.end_line != after.location.start_line
+                range = range_between(base_pos + bar.location.start_pos, base_pos + bar.location.end_pos)
+                add_offense(range, message: "Remove newline after `|`") do |corrector|
+                  space = range_between(base_pos + bar.location.end_pos, base_pos + after.location.start_pos)
+                  corrector.replace(space, ' ')
+                end
+              elsif bar.location.start_column != first_colon_column
+                range = range_between(base_pos + bar.location.start_pos, base_pos + bar.location.end_pos)
+                add_offense(range, message: 'Indent the `|` to the first `:`') do |corrector|
+                  space = range_between(base_pos + bar.location.start_pos - bar.location.start_column,
+                                        base_pos + bar.location.start_pos)
+                  corrector.replace(space, ' ' * first_colon_column)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/layout/space_around_arrow.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   def foo: ()->void
+        #
+        #   # bad
+        #   def bar: () { ()->void } -> void
+        #
+        #   # good
+        #   def foo: () -> void
+        #
+        #   # good
+        #   def bar: () { () -> void } -> void
+        class SpaceAroundArrow < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          MSG_BEFORE = 'Use one space before `->`.'
+          MSG_AFTER = 'Use one space after `->`.'
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            base = decl.location.start_pos
+            tokens = ::RBS::Parser.lex(decl.location.source).value.reject { |t| t.type == :tTRIVIA }
+            ([nil] + tokens).each_cons(3) do |before, token, after|
+              next unless token&.type == :pARROW
+
+              loc = token&.location
+              next unless loc
+
+              if before && (before.location.end_pos + 1 != loc.start_pos)
+                arrow = location_to_range(loc).adjust(begin_pos: base, end_pos: base)
+                add_offense(arrow, message: MSG_BEFORE) do |corrector|
+                  range = range_between(before.location.end_pos, loc.start_pos)
+                  corrector.replace(range.adjust(begin_pos: base, end_pos: base), ' ')
+                end
+              end
+
+              if loc.end_pos + 1 != after.location.start_pos
+                arrow = location_to_range(loc).adjust(begin_pos: base, end_pos: base)
+                add_offense(arrow, message: MSG_AFTER) do |corrector|
+                  range = range_between(loc.end_pos, after.location.start_pos)
+                  corrector.replace(range.adjust(begin_pos: base, end_pos: base), ' ')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/layout/space_around_braces.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   def bar: (){() -> void}-> void
+        #
+        #   # good
+        #   def bar: () { () -> void } -> void
+        class SpaceAroundBraces < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            paren_level = 0
+            tokens = ::RBS::Parser.lex(decl.location.source).value.reject { |t| t.type == :tTRIVIA }
+            ([nil] + tokens).each_cons(3) do |before, token, after|
+              case token.type
+              when :pLPAREN # '('
+                paren_level += 1
+              when :pRPAREN # ')'
+                paren_level -= 1
+              when :pLBRACE # '{'
+                next unless before&.type != :pQUESTION # '?'
+                next unless (after.type == :pLPAREN || after.type == :pARROW)
+                next unless paren_level == 0
+
+                check_around_space(decl.location, before, token, after)
+              when :pRBRACE # '}'
+                next unless after.type == :pARROW
+                next unless paren_level == 0
+
+                check_around_space(decl.location, before, token, after)
+              end
+            end
+          end
+
+          def check_around_space(base_loc, before, token, after)
+            return unless before.nil? || before.location.end_line == token.location.start_line
+            return unless token.location.end_line == after.location.start_line
+
+            if before && (before.location.end_pos + 1 != token.location.start_pos)
+              brace = range_between(
+                base_loc.start_pos + token.location.start_pos,
+                base_loc.start_pos + token.location.end_pos,
+              )
+              add_offense(brace, message: "Use one space before `#{token.location.source}`.") do |corrector|
+                range = range_between(
+                  base_loc.start_pos + before.location.end_pos,
+                  base_loc.start_pos + token.location.start_pos
+                )
+                corrector.replace(range, ' ')
+              end
+            end
+
+            if token.location.end_pos + 1 != after.location.start_pos
+              brace = range_between(
+                base_loc.start_pos + token.location.start_pos,
+                base_loc.start_pos + token.location.end_pos,
+              )
+              add_offense(brace, message: "Use one space after `#{token.location.source}`.") do |corrector|
+                range = range_between(
+                  base_loc.start_pos + token.location.end_pos,
+                  base_loc.start_pos + after.location.start_pos
+                )
+                corrector.replace(range, ' ')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/layout/space_before_colon.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   def foo : () -> void
+        #
+        #   # good
+        #   def foo: () -> void
+        class SpaceBeforeColon < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          MSG = 'Avoid using spaces before `:`.'
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            source = processed_source.raw_source
+            loc = decl.location
+            colon_start_pos = source.index(':', loc.start_pos)
+            return unless colon_start_pos
+
+            word_before_colon_pos = source.rindex(/[^\s]/, colon_start_pos - 1)
+            return unless word_before_colon_pos
+
+            if word_before_colon_pos + 1 != colon_start_pos
+              colon = range_between(colon_start_pos, colon_start_pos + 1)
+              add_offense(colon) do |corrector|
+                range = range_between(
+                  word_before_colon_pos + 1,
+                  colon_start_pos,
+                )
+                corrector.remove(range)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/layout/space_before_overload.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   def foo:() -> void
+        #          |  () -> void
+        #
+        #   # good
+        #   def foo: () -> void
+        #          | () -> void
+        class SpaceBeforeOverload < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          MSG = 'Use one space before overload.'
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            source = processed_source.raw_source
+            decl.overloads.each_with_index do |overload, i|
+              loc = overload.method_type.location
+              overload_char = i == 0 ? ':' : '|'
+
+              char_start_pos = source.rindex(overload_char, loc.start_pos)
+              next unless char_start_pos
+
+              word_after_char_pos = source.index(/[^\s]/, char_start_pos + 1)
+              next unless word_after_char_pos
+
+              if char_start_pos + 2 != word_after_char_pos
+                char = range_between(char_start_pos, char_start_pos + 1)
+                add_offense(char) do |corrector|
+                  range = range_between(char_start_pos + 1, word_after_char_pos)
+                  corrector.replace(range, ' ')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/layout/trailing_whitespace.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Layout
+        # @example default
+        #   # bad
+        #   class Foo[:space:]
+        #     def foo: () -> void[:space:]
+        #   end[:space:]
+        #
+        #   # good
+        #   class Foo
+        #     def foo: () -> void
+        #   end
+        class TrailingWhitespace < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          MSG = "Trailing whitespace detected."
+
+          def on_rbs_new_investigation
+            total = 0
+            processed_source.raw_source.each_line do |line|
+              total += line.bytesize
+              chomped = line.chomp
+              next unless chomped.end_with?(' ', "\t")
+
+              range = range_between(
+                total - line.bytesize + chomped.rstrip.bytesize,
+                total - line.bytesize + chomped.bytesize,
+              )
+              add_offense(range) do |corrector|
+                corrector.remove(range)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/lint/syntax.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Lint
+        # Just only for syntax error
+        class Syntax < RuboCop::RBS::CopBase
+          def on_rbs_parsing_error
+            e = processed_rbs_source.error or raise
+            message = "#{e.error_message}, token=`#{e.location.source}` (#{e.token_type})"
+            add_offense(location_to_range(e.location), message:, severity: :fatal)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/lint/type_params_arity.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Lint
+        # This cop checks the arity of type parameters arity.
+        # You can add expect settings in your .rubocop.yml.
+        #
+        # @example Expects settings
+        #   RBS/Lint/TypeParamsArity:
+        #     Expects:
+        #       Your::Class: 1
+        #
+        # @example default
+        #   # bad
+        #   type a = Array[Integer, String, Symbol]
+        #
+        #   # bad
+        #   class Foo
+        #     include Enumerable
+        #   end
+        class TypeParamsArity < RuboCop::RBS::CopBase
+          Types = ::RBS::Types
+
+          def on_rbs_module(decl)
+            check_type_params(decl)
+            decl.self_types.each do |self_type|
+              check(
+                name: self_type.name,
+                args: self_type.args,
+                location: self_type.location
+              )
+            end
+            check_each_mixin(decl)
+          end
+
+          def on_rbs_class(decl)
+            check_type_params(decl)
+            if decl.super_class
+              check(
+                name: decl.super_class.name,
+                args: decl.super_class.args,
+                location: decl.super_class.location
+              )
+            end
+            check_each_mixin(decl)
+          end
+
+          def on_rbs_interface(decl)
+            check_type_params(decl)
+            check_each_mixin(decl)
+          end
+
+          def on_rbs_constant(const)
+            check_type(const.type)
+          end
+
+          def on_rbs_global(global)
+            check_type(global.type)
+          end
+
+          def on_rbs_type_alias(decl)
+            check_type_params(decl)
+            check_type(decl.type)
+            decl.type.each_type do |type|
+              check_type(type)
+            end
+          end
+
+          def on_rbs_def(member)
+            member.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                check_type(type)
+              end
+            end
+          end
+
+          def on_rbs_attribute(attr)
+            check_type(attr.type)
+          end
+
+          def check_each_mixin(decl)
+            decl.each_mixin do |mixin|
+              check(
+                name: mixin.name,
+                args: mixin.args,
+                location: mixin.location
+              )
+            end
+          end
+
+          def check_type_params(decl)
+            decl.type_params.each do |type_param|
+              if type_param.upper_bound
+                check(
+                  name: type_param.upper_bound.name,
+                  args: type_param.upper_bound.args,
+                  location: type_param.upper_bound.location
+                )
+              end
+            end
+          end
+
+          def check_type(type)
+            case type
+            when Types::Record,
+                 Types::Tuple,
+                 Types::Union,
+                 Types::Intersection,
+                 Types::Optional,
+                 Types::Proc
+              type.each_type.each do |t|
+                check_type(t)
+              end
+            when Types::Interface,
+                 Types::Alias,
+                 Types::ClassInstance
+              check(
+                name: type.name,
+                args: type.args,
+                location: type.location,
+              )
+            end
+          end
+
+          def check(name:, args:, location:)
+            return unless name.absolute?
+            return unless location
+
+            expect_size = expects[name.to_s]
+            return unless expect_size
+            return unless expect_size != args.size
+
+            message = if args.size == 0
+                        "Type `#{name}` is generic but used as a non generic type."
+                      else
+                        "Type `#{name}` expects #{expect_size} arguments, but #{args.size} arguments are given."
+                      end
+            add_offense(
+              location_to_range(location),
+              message: message,
+              severity: :error
+            )
+          end
+
+          def expects
+            @expects ||= begin
+              expects = cop_config['Expects']
+              raise "Expects must be a hash" unless expects.is_a?(Hash)
+
+              unless expects.all? { |k, _| k.is_a?(String) }
+                raise "[RBS/Lint/TypeParamsArity] Keys of Expects must be strings"
+              end
+              unless expects.all? { |_, v| v.is_a?(Integer) }
+                raise "[RBS/Lint/TypeParamsArity] Values of Expects must be integers"
+              end
+
+              expects.transform_keys! do |k|
+                k.start_with?('::') ? k : "::#{k}"
+              end
+
+              expects
+            end
+          end
+        end
+      end
+    end
+  end
+end