rubocop-on-rbs 0.2.0

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Lint
+        # Notice useless overload type parameters.
+        #
+        # @example default
+        #   # bad
+        #   def foo: [T] () -> void
+        #
+        #   # bad
+        #   def bar: [T, U] (T) -> void
+        #
+        #   # good
+        #   def foo: [T] (Array[T]) -> T
+        class UselessOverloadTypeParams < RuboCop::RBS::CopBase
+          MSG = 'Useless overload type variable - `%<variable>s`.'
+
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              next if overload.method_type.type_params.empty?
+
+              type_params = overload.method_type.type_params
+
+              overload.method_type.each_type do |type|
+                used_variable_in_type(type) do |var|
+                  type_params.delete_if { |type_param| type_param.name == var.name }
+                end
+              end
+              next if type_params.empty?
+
+              type_params.each do |type_param|
+                next unless type_param.location
+
+                t = location_to_range(type_param.location[:name])
+                add_offense(t, message: format(MSG, variable: type_param.name), severity: :warning)
+              end
+            end
+          end
+
+          def used_variable_in_type(type, &block)
+            case type
+            when ::RBS::Types::Variable
+              yield type
+            else
+              type.each_type do |t|
+                used_variable_in_type(t, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Lint
+        # This cop checks the WillSyntaxError in RBS.
+        # RBS with this diagnostics will fail in `rbs validate` command.
+        #
+        # @example default
+        #   # bad
+        #   def foo: (void) -> void
+        #
+        #   # bad
+        #   CONST: self
+        class WillSyntaxError < RuboCop::RBS::CopBase
+          # @rbs!
+          #    module Types = ::RBS::Types
+          #    module AST = ::RBS::AST
+
+          # @rbs skip
+          AST = ::RBS::AST
+          # @rbs skip
+          Types = ::RBS::Types
+
+          def on_rbs_class(decl)
+            if super_class = decl.super_class
+              super_class.args.each do |arg|
+                void_type_context_validator(arg, true)
+                no_self_type_validator(arg)
+                no_classish_type_validator(arg)
+              end
+            end
+            check_module_or_class(decl)
+          end
+
+          def on_rbs_module(decl)
+            decl.self_types.each do |self_type|
+              self_type.args.each do |arg|
+                void_type_context_validator(arg, true)
+                no_self_type_validator(arg)
+                no_classish_type_validator(arg)
+              end
+            end
+            check_module_or_class(decl)
+          end
+
+          def check_module_or_class(decl)
+            decl.type_params.each do |param|
+              if ub = param.upper_bound
+                void_type_context_validator(ub)
+                no_self_type_validator(ub)
+                no_classish_type_validator(ub)
+              end
+            end
+
+            decl.each_member do |member|
+              case member
+              when AST::Members::MethodDefinition
+                member.overloads.each do |ov|
+                  void_type_context_validator(ov.method_type)
+                end
+              when AST::Members::Attribute
+                void_type_context_validator(member.type)
+              when AST::Members::Mixin
+                member.args.each do |arg|
+                  no_self_type_validator(arg)
+                  unless arg.is_a?(Types::Bases::Void)
+                    void_type_context_validator(arg, true)
+                  end
+                end
+              when AST::Members::Var
+                void_type_context_validator(member.type)
+                if member.is_a?(AST::Members::ClassVariable)
+                  no_self_type_validator(member.type)
+                end
+              end
+            end
+          end
+
+          def on_rbs_interface(decl)
+            decl.members.each do |member|
+              case member
+              when AST::Members::MethodDefinition
+                member.overloads.each do |ov|
+                  void_type_context_validator(ov.method_type)
+                  no_classish_type_validator(ov.method_type)
+                end
+              end
+            end
+          end
+
+          def on_rbs_constant(decl)
+            no_self_type_validator(decl.type)
+            no_classish_type_validator(decl.type)
+            void_type_context_validator(decl.type)
+          end
+          alias on_rbs_global on_rbs_constant
+          alias on_rbs_type_alias on_rbs_constant
+
+          private
+
+          # @rbs type: ::RBS::Types::t
+          def no_self_type_validator(type)
+            case type
+            when ::RBS::MethodType,
+                 Types::Record,
+                 Types::Tuple,
+                 Types::Union,
+                 Types::Intersection,
+                 Types::Optional,
+                 Types::ClassInstance,
+                 Types::Proc
+              type.each_type do |t|
+                no_self_type_validator(t)
+              end
+            else
+              if type.has_self_type?
+                offence(type, "`self` type is not allowed in this context")
+              end
+            end
+          end
+
+          # @rbs type: ::RBS::MethodType | ::RBS::Types::t
+          def no_classish_type_validator(type)
+            case type
+            when ::RBS::MethodType,
+                 Types::Record,
+                 Types::Tuple,
+                 Types::Union,
+                 Types::Intersection,
+                 Types::Optional,
+                 Types::ClassInstance,
+                 Types::Proc
+              type.each_type do |t|
+                no_classish_type_validator(t)
+              end
+            when Types::Bases::Instance
+              offence(type, "`instance` type is not allowed in this context")
+            when Types::Bases::Class
+              offence(type, "`class` type is not allowed in this context")
+            else
+              if type.has_classish_type?
+                offence(type, "`instance` or `class` type is not allowed in this context")
+              end
+            end
+          end
+
+          # @rbs type: ::RBS::MethodType | ::RBS::Types::Function | ::RBS::Types::t
+          # @rbs allowed_here: bool
+          def void_type_context_validator(type, allowed_here = false)
+            return if type.is_a?(Types::UntypedFunction)
+
+            case type
+            when ::RBS::MethodType
+              void_type_context_validator(type.type)
+            when Types::Function
+              type.each_param do |param|
+                void_type_context_validator(param.type)
+              end
+              case type.return_type
+              when Types::Bases::Void
+                # `() -> void` is allowed
+              else
+                void_type_context_validator(type.return_type, true)
+              end
+            when Types::Proc
+              void_type_context_validator(type.type)
+              if type.block
+                void_type_context_validator(type.block.type)
+                void_type_context_validator(type.block.self_type) if type.block.self_type
+              end
+            when Types::ClassInstance
+              type.args.each do |arg|
+                next if arg.is_a?(Types::Bases::Void)
+
+                void_type_context_validator(arg)
+              end
+            when Types::Record,
+                 Types::Tuple,
+                 Types::Union,
+                 Types::Intersection,
+                 Types::Optional
+              type.each_type do |t|
+                void_type_context_validator(t)
+              end
+            else
+              if allowed_here
+                return if type.is_a?(Types::Bases::Void)
+              end
+              if type.with_nonreturn_void?
+                offence(type, "`void` type is only allowed in return type or generics parameter")
+              end
+            end
+          end
+
+          def offence(decl, message)
+            range = location_to_range(decl.location)
+            add_offense(range, message: message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/block_return_boolish.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: () { () -> bool } -> void
+        #
+        #   # good
+        #   def foo: () { () -> boolish } -> void
+        class BlockReturnBoolish < RuboCop::RBS::CopBase
+          extend AutoCorrector
+          MSG = 'Use `boolish` instead of `bool` in block return type.'
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              next unless overload.method_type.block
+
+              return_type = overload.method_type.block.type.return_type
+              next unless return_type.is_a?(::RBS::Types::Bases::Bool)
+
+              range = location_to_range(return_type.location)
+              add_offense(range) do |corrector|
+                corrector.replace(range, 'boolish')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/classic_type.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: () -> TrueClass
+        #
+        #   # bad
+        #   def bar: () -> NilClass
+        #
+        #   # good
+        #   def foo: () -> true
+        #
+        #   # good
+        #   def bar: () -> nil
+        class ClassicType < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          Types = ::RBS::Types
+
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                check_type(type)
+              end
+            end
+          end
+
+          # @rbs type: ::RBS::Types::t
+          def check_type(type)
+            find_replacement(type) do |t, replaced|
+              range = location_to_range(t.location)
+              add_offense(range, message: "Use `#{replaced}` instead of `#{t}`") do |corrector|
+                corrector.replace(range, replaced)
+              end
+            end
+          end
+
+          def find_replacement(type, &block)
+            case type
+            when Types::Record,
+                 Types::Tuple,
+                 Types::Union,
+                 Types::Intersection,
+                 Types::Optional,
+                 Types::Proc,
+                 Types::Alias,
+                 Types::Interface
+              type.each_type do |t|
+                find_replacement(t, &block)
+              end
+            when Types::ClassInstance
+              case type.name.to_s
+              when 'TrueClass', '::TrueClass'
+                block.call([type, 'true'])
+              when 'FalseClass', '::FalseClass'
+                block.call([type, 'false'])
+              when 'NilClass', '::NilClass'
+                block.call([type, 'nil'])
+              end
+              type.each_type do |arg|
+                find_replacement(arg, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/duplicated_type.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: (Integer | Integer) -> void
+        #
+        #   # bad
+        #   def foo: (Integer & Integer) -> void
+        #
+        #   # good
+        #   def foo: (Integer) -> void
+        class DuplicatedType < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                check_type(type)
+              end
+            end
+          end
+
+          # @rbs type: ::RBS::Types::t
+          def check_type(type)
+            case type
+            when ::RBS::Types::Record,
+                 ::RBS::Types::Tuple,
+                 ::RBS::Types::Optional,
+                 ::RBS::Types::ClassInstance,
+                 ::RBS::Types::Proc
+              type.each_type do |t|
+                check_type(t)
+              end
+            when ::RBS::Types::Union,
+                 ::RBS::Types::Intersection
+              set = Set.new
+              type.types.each do |t|
+                if set.include?(t)
+                  if t.location
+                    range = location_to_range(t.location)
+                    add_offense(range, message: "Duplicated type `#{t}`.")
+                  end
+                else
+                  set.add(t)
+                end
+              end
+              type.each_type do |t|
+                check_type(t)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/initialize_return_type.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def initialize: () -> untyped
+        #
+        #   # bad
+        #   def initialize: () -> nil
+        #
+        #   # good
+        #   def initialize: () -> void
+        class InitializeReturnType < RuboCop::RBS::CopBase
+          extend AutoCorrector
+          MSG = '`#initialize` method should return `void`'
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            return unless decl.name == :initialize
+            return unless decl.kind == :instance
+            return unless decl.overloading == false
+
+            decl.overloads.each do |overload|
+              return_type = overload.method_type.type.return_type
+              next if return_type.is_a?(::RBS::Types::Bases::Void)
+
+              range = location_to_range(return_type.location)
+              add_offense(range) do |corrector|
+                corrector.replace(range, 'void')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/merge_untyped.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: (untyped?) -> untyped?
+        #
+        #   # bad
+        #   def foo: (Integer | untyped) -> (Integer | untyped)
+        #
+        #   # bad
+        #   def foo: (Integer & untyped) -> (Integer & untyped)
+        #
+        #   # good
+        #   def foo: (untyped) -> untyped
+        class MergeUntyped < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              overload.method_type.type.tap do |fun|
+                fun.each_param do |param|
+                  check_type(param.type)
+                end
+                check_type(fun.return_type)
+              end
+            end
+          end
+
+          def check_type(type)
+            find_replacement(type) do |method, t, replaced|
+              case method
+              when :replace
+                range = location_to_range(t.location)
+                add_offense(range, message: "Use `#{replaced}` instead of `#{t}`") do |corrector|
+                  corrector.replace(range, replaced.to_s)
+                end
+              when :remove
+                range = t
+                add_offense(range, message: "Remove `?` in Optional") do |corrector|
+                  corrector.remove(range)
+                end
+              end
+            end
+          end
+
+          def find_replacement(type, &block)
+            case type
+            when ::RBS::Types::Optional
+              case type.type
+              when ::RBS::Types::Bases::Any,
+                   ::RBS::Types::Bases::Nil,
+                   ::RBS::Types::Bases::Void,
+                   ::RBS::Types::Bases::Top,
+                   ::RBS::Types::Bases::Bottom
+                # untyped? => untyped
+                block.call([:replace, type, type.type])
+              when ::RBS::Types::Optional
+                # (Integer?)? => Integer?
+                range = Parser::Source::Range.new(processed_source.buffer, type.type.location.end_pos - 1,
+                                                  type.type.location.end_pos)
+                block.call([:remove, range])
+                find_replacement(type.type, &block)
+              when ::RBS::Types::Union, ::RBS::Types::Intersection
+                find_replacement(type.type, &block)
+              end
+            when ::RBS::Types::Union, ::RBS::Types::Intersection
+              # (untyped | Integer) => untyped
+              # (untyped & Integer) => untyped
+              if type.types.any? { |t| t.is_a?(::RBS::Types::Bases::Any) }
+                block.call([:replace, type, 'untyped'])
+              end
+
+              uniqed = type.types.uniq
+              if uniqed.size < type.types.size
+                block.call([:replace, type, type.class.new(types: uniqed, location: nil)])
+              end
+              type.types.each do |t|
+                find_replacement(t, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/optional_nil.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: (nil?) -> void
+        #
+        #   # good
+        #   def foo: (nil) -> void
+        class OptionalNil < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                find_replacement(type) do |t, replaced|
+                  range = location_to_range(t.location)
+                  add_offense(range, message: "Use `#{replaced}` instead of `#{t}`") do |corrector|
+                    corrector.replace(range, replaced.to_s)
+                  end
+                end
+              end
+            end
+          end
+
+          # @rbs type: ::RBS::Types::t
+          def find_replacement(type, &block)
+            case type
+            when ::RBS::Types::Optional
+              case type.type
+              when ::RBS::Types::Bases::Nil
+                block.call([type, ::RBS::Types::Bases::Nil.new(location: nil)])
+              else
+                find_replacement(type.type, &block)
+              end
+            else
+              type.each_type do |type|
+                find_replacement(type, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rbs/style/true_false.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RBS
+      module Style
+        # @example default
+        #   # bad
+        #   def foo: (true | false) -> (true | false)
+        #
+        #   # bad
+        #   def foo: (TrueClass | FalseClass) -> (TrueClass | FalseClass)
+        #
+        #   # good
+        #   def foo: (bool) -> bool
+        class TrueFalse < RuboCop::RBS::CopBase
+          extend AutoCorrector
+
+          # @sig decl: ::RBS::AST::Members::MethodDefinition
+          def on_rbs_def(decl)
+            decl.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                find_replacement(type) do |t, replaced|
+                  range = location_to_range(t.location)
+                  add_offense(range, message: "Use `#{replaced}` instead of `#{t}`") do |corrector|
+                    corrector.replace(range, replaced.to_s)
+                  end
+                end
+              end
+            end
+          end
+
+          # @rbs type: ::RBS::Types::t
+          def find_replacement(type, &block)
+            case type
+            when ::RBS::Types::Union
+              has_true = has_false = false
+              type.types.each do |t|
+                case t
+                when ::RBS::Types::Literal
+                  has_true = true if t.literal == true
+                  has_false = true if t.literal == false
+                when ::RBS::Types::ClassInstance
+                  case t.name.to_s
+                  when 'TrueClass', '::TrueClass'
+                    has_true = true
+                  when 'FalseClass', '::FalseClass'
+                    has_false = true
+                  end
+                end
+              end
+              if has_true && has_false
+                replaced = type.types.dup
+                first_index = nil
+                i = -1
+                replaced.delete_if do |t|
+                  i += 1
+                  case t
+                  when ::RBS::Types::Literal
+                    (t.literal == true || t.literal == false).tap do |r|
+                      first_index ||= i if r
+                    end
+                  when ::RBS::Types::ClassInstance
+                    t.name.to_s.then do |s|
+                      s == 'TrueClass' || s == '::TrueClass' || s == 'FalseClass' || s == '::FalseClass'
+                    end.tap do |r|
+                      first_index ||= i if r
+                    end
+                  end
+                end
+                replaced.insert(first_index || 0, ::RBS::Types::Bases::Bool.new(location: nil))
+                block.call([type, ::RBS::Types::Union.new(types: replaced, location: nil)])
+              end
+            else
+              type.each_type do |type|
+                find_replacement(type, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end