rubocop-yard 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35f55b03315d73095819182351a19278528a8d91f5fb71f9644e39734ef0aa89
-  data.tar.gz: 731f21ea908307e87b59e36dae70fc9da5ced99157cdc53d0084c077673fd496
+  metadata.gz: e5f138fd3b5b0c5eb5550b368164986ba104280ebb40af21d7b8fe843105dad3
+  data.tar.gz: 2a237052e98046b9ac7ffcd72100fd1d96ad90164d8075e8f997981c73a78f98
 SHA512:
-  metadata.gz: 378e7d10ff7f50c807a1fe0fe6266e7163ebcece3bc6a4cf340cf98baade320a4785d2520c42aa9319bc20e20642dc46b39311088b58e521f57ee0ce15fab48b
-  data.tar.gz: a33bc93f4cb7712b0c73c259d3ecb7f94409973ec73c897494e723c33f5879b7686deba726e7a1f871da20aae3abd46554641c8d1ea29d5c58124cc66646213e
+  metadata.gz: fe3818daae4c2d4597a86ad8f1e1e6785a56e5c34e5e96b0b78be0b52b7cb219ce4d9f390ebac30af9ec844d5f2add8f4c7dfa7d5d4e6496543a0ab6a880980d
+  data.tar.gz: fd20c16153f50987d92fe2c5a6af00ecf1fd274d29205d57e63c8c176a314555de9f9e926ae1bad5b7c5b18bf3d1e7adcca26e8ead35b0f8eacc55744fb4cabb

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.6.0] - 2023-10-10
+
+- Split cop from `YARD/TagType` to
+    - `YARD/TagTypeSyntax`
+    - `YARD/CollectionType`
+
 ## [0.4.0] - 2023-09-19
 
 - Add new cop `YARD/MeaninglessTag`

data/README.md

@@ -6,15 +6,63 @@ You can check YARD format in Ruby code comment by RuboCop.
 
 ## Features
 
-### `YARD/TagType`
+### `YARD/TagTypeSyntax`
 
 Check tag type syntax error.
 
 ```
 # @param [Symbol|String]
-          ^^^^^^^^^^^^^ SyntaxError as YARD tag type
+          ^^^^^^^^^^^^^ (SyntaxError) invalid character at |
 ```
 
+### `YARD/CollectionStyle`
+
+`EnforcedStyle long (default)`
+
+```
+# bad
+# @param [{KeyType => ValueType}]
+
+# bad
+# @param [(String)]
+
+# bad
+# @param [<String>]
+
+# good
+# @param [Hash{KeyType => ValueType}]
+
+# good
+# @param [Array(String)]
+
+# good
+# @param [Array<String>]
+```
+
+`EnforcedStyle short`
+
+```
+# bad
+# @param [Hash{KeyType => ValueType}]
+
+# bad
+# @param [Array(String)]
+
+# bad
+# @param [Array<String>]
+
+# good
+# @param [{KeyType => ValueType}]
+
+# good
+# @param [(String)]
+
+# good
+# @param [<String>]
+```
+
+### `YARD/CollectionType`
+
 ```
 # @param [Hash<Symbol, String>]
           ^^^^^^^^^^^^^^^^^^^^ `<Type>` is the collection type syntax. Did you mean `{KeyType => ValueType}` or `Hash{KeyType => ValueType}`
@@ -25,6 +73,12 @@ Check tag type syntax error.
 Check `@param` and `@option` name with method definition.
 
 ```rb
+# @param [String]
+^^^^^^^^^^^^^^^^^ No tag name is supplied in `@param`
+
+# @param string
+^^^^^^^^^^^^^^^ No types are associated with the tag in `@param`
+
 # @param [String] string
                   ^^^^^^ `string` is not found in method arguments
 # @option opt bar [String]

data/config/default.yml

@@ -3,10 +3,28 @@ YARD/MeaninglessTag:
   Enabled: true
   VersionAdded: '0.4.0'
 
-YARD/TagType:
+YARD/TagTypeSyntax:
   Description: 'Check syntax for yard tag type'
   Enabled: true
-  VersionAdded: '0.2.0'
+  VersionAdded: '0.5.0'
+
+YARD/CollectionStyle:
+  Description: 'Check collection type style'
+  Enabled: true
+  VersionAdded: '0.5.0'
+  EnforcedStyle: long
+  SupportedStyles:
+    - long
+    - short
+
+YARD/CollectionType:
+  Description: 'Check collection type syntax'
+  Enabled: true
+  VersionAdded: '0.5.0'
+  EnforcedStyle: long
+  SupportedStyles:
+    - long
+    - short
 
 YARD/MismatchName:
   Description: 'Check @param and @option name and method parameters'

data/lib/rubocop/cop/yard/collection_style.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module YARD
+      # @example EnforcedStyle short
+      #
+      #   # bad
+      #   # @param [Hash{KeyType => ValueType}]
+      #
+      #   # bad
+      #   # @param [Array(String)]
+      #
+      #   # bad
+      #   # @param [Array<String>]
+      #
+      #   # good
+      #   # @param [{KeyType => ValueType}]
+      #
+      #   # good
+      #   # @param [(String)]
+      #
+      #   # good
+      #   # @param [<String>]
+      #
+      # @example EnforcedStyle long (default)
+      #   # bad
+      #   # @param [{KeyType => ValueType}]
+      #
+      #   # bad
+      #   # @param [(String)]
+      #
+      #   # bad
+      #   # @param [<String>]
+      #
+      #   # good
+      #   # @param [Hash{KeyType => ValueType}]
+      #
+      #   # good
+      #   # @param [Array(String)]
+      #
+      #   # good
+      #   # @param [Array<String>]
+      class CollectionStyle < Base
+        include YARD::Helper
+        include RangeHelp
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next if inline_comment?(comment)
+            next unless include_yard_tag?(comment)
+
+            check(comment)
+          end
+        end
+
+        private
+
+        def check(comment)
+          docstring = ::YARD::DocstringParser.new.parse(comment.text.gsub(/\A#\s*/, ''))
+          each_types_explainer(docstring) do |type, types_explainer|
+            correct_type = styled_string(types_explainer)
+            unless ignore_whitespace(type) == ignore_whitespace(correct_type)
+              add_offense(comment, message: "`#{type}` is using #{bad_style} style syntax") do |corrector|
+                corrector.replace(comment, comment.source.sub(/\[(.*)\]/) { "[#{correct_type}]" })
+              end
+            end
+          end
+        end
+
+        def ignore_whitespace(str)
+          str.tr(' ', '')
+        end
+
+        def bad_style
+          if style == :long
+            :short
+          else
+            :long
+          end
+        end
+
+        def inline_comment?(comment)
+          !comment_line?(comment.source_range.source_line)
+        end
+
+        def include_yard_tag?(comment)
+          comment.source.match?(/@(?:param|return|option|raise|yieldparam|yieldreturn)\s+.*\[.*\]/)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yard/collection_type.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module YARD
+      # @example common
+      #   # bad
+      #   # @param [Hash<Symbol, String>]
+      #
+      #   # bad
+      #   # @param [Hash(String)]
+      #
+      #   # bad
+      #   # @param [Array{Symbol => String}]
+      #
+      #   # good
+      #   # @param [Hash{Symbol => String}]
+      #
+      #   # good
+      #   # @param [Array(String)]
+      #
+      #   # good
+      #   # @param [Hash{Symbol => String}]
+      class CollectionType < Base
+        include YARD::Helper
+        include RangeHelp
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next if inline_comment?(comment)
+            next unless include_yard_tag?(comment)
+
+            docstring = ::YARD::DocstringParser.new.parse(comment.text.gsub(/\A#\s*/, ''))
+            check_mismatch_collection_type(comment, docstring)
+          end
+        end
+
+        private
+
+        def check_mismatch_collection_type(comment, docstring)
+          each_types_explainer(docstring) do |_type, types_explainer|
+            check_mismatch_collection_type_one(comment, types_explainer)
+          end
+        end
+
+        def check_mismatch_collection_type_one(comment, types_explainer)
+          case types_explainer
+          when ::YARD::Tags::TypesExplainer::HashCollectionType
+            case types_explainer.name
+            when 'Hash'
+              types_explainer.key_types.each { |t| check_mismatch_collection_type_one(comment, t) }
+              types_explainer.value_types.each { |t| check_mismatch_collection_type_one(comment, t) }
+            when 'Array'
+              message = "`{KeyType => ValueType}` is the Hash collection type syntax."
+              add_offense(tag_range_for_comment(comment), message: message) do |corrector|
+                types_explainer.name = "Hash"
+                correct_tag_type(corrector, comment, types_explainer)
+              end
+            end
+          when ::YARD::Tags::TypesExplainer::FixedCollectionType
+            case types_explainer.name
+            when 'Hash'
+              if types_explainer.types.length == 2
+                message = "`Hash(Key, Value)` is miswritten of `Hash<Key, Value>` in perhaps"
+                add_offense(tag_range_for_comment(comment), message: message) do |corrector|
+                  hash_type = ::YARD::Tags::TypesExplainer::HashCollectionType.new(
+                    'Hash',
+                    [types_explainer.types[0]],
+                    [types_explainer.types[1]]
+                  )
+                  correct_tag_type(corrector, comment, hash_type)
+                end
+              else
+                message = "`(Type)` is the fixed collection type syntax."
+                add_offense(tag_range_for_comment(comment), message: message) do |corrector|
+                  types_explainer.name = "Array"
+                  correct_tag_type(corrector, comment, types_explainer)
+                end
+              end
+            when 'Array'
+              types_explainer.types.each { |t| check_mismatch_collection_type_one(comment, t) }
+            end
+          when ::YARD::Tags::TypesExplainer::CollectionType
+            case types_explainer.name
+            when 'Hash'
+              if types_explainer.types.length == 2
+                message = "`Hash<Key, Value>` is ambiguous syntax"
+                add_offense(tag_range_for_comment(comment), message: message) do |corrector|
+                  hash_type = ::YARD::Tags::TypesExplainer::HashCollectionType.new(
+                    'Hash',
+                    [types_explainer.types[0]],
+                    [types_explainer.types[1]]
+                  )
+                  correct_tag_type(corrector, comment, hash_type)
+                end
+              else
+                message = "`<Type>` is the collection type syntax."
+                add_offense(tag_range_for_comment(comment), message: message) do |corrector|
+                  types_explainer.name = "Array"
+                  correct_tag_type(corrector, comment, types_explainer)
+                end
+              end
+            when 'Array'
+              types_explainer.types.each { |t| check_mismatch_collection_type_one(comment, t) }
+            end
+          end
+        end
+
+        def correct_tag_type(corrector, comment, types_explainer)
+          corrector.replace(comment, comment.source.sub(/\[(.*)\]/) { "[#{styled_string(types_explainer)}]" })
+        end
+
+        def inline_comment?(comment)
+          !comment_line?(comment.source_range.source_line)
+        end
+
+        def include_yard_tag?(comment)
+          comment.source.match?(/@(?:param|return|option|raise|yieldparam|yieldreturn)\s+.*\[.*\]/)
+        end
+
+        def tag_range_for_comment(comment)
+          start_column = comment.source.index(/\[/) + 1
+          end_column = comment.source.index(/\]/)
+          offense_start = comment.location.column + start_column
+          offense_end = comment.location.column + end_column
+          source_range(processed_source.buffer, comment.location.line, offense_start..offense_end)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yard/helper.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module YARD
+      module Helper
+        def extract_tag_types(tag)
+          case tag
+          when ::YARD::Tags::OptionTag
+            tag.pair.types
+          else
+            tag.types
+          end
+        end
+
+        def parse_type(type)
+          ::YARD::Tags::TypesExplainer::Parser.parse(type)
+        end
+
+        def each_types_explainer(docstring, &block)
+          docstring.tags.each do |tag|
+            types = extract_tag_types(tag)
+
+            begin
+              types_explainers = parse_type(types.join(', '))
+              types.zip(types_explainers).each do |type, types_explainer|
+                block.call(type, types_explainer)
+              end
+            rescue SyntaxError
+            end
+          end
+        end
+
+        def styled_string(types_explainer)
+          case types_explainer
+          when ::YARD::Tags::TypesExplainer::HashCollectionType
+            tname = case [style, types_explainer.name]
+            when [:short, 'Hash']
+              ''
+            when [:long, 'Hash']
+              'Hash'
+            else
+              types_explainer.name
+            end
+            "#{tname}{#{types_explainer.key_types.map { styled_string(_1) }.join(', ')} => #{types_explainer.value_types.map { styled_string(_1) }.join(', ')}}"
+          when ::YARD::Tags::TypesExplainer::FixedCollectionType
+            tname = case [style, types_explainer.name]
+            when [:short, 'Array']
+              ''
+            when [:long, 'Array']
+              'Array'
+            else
+              types_explainer.name
+            end
+            "#{tname}(#{types_explainer.types.map { styled_string(_1) }.join(', ')})"
+          when ::YARD::Tags::TypesExplainer::CollectionType
+            tname = case [style, types_explainer.name]
+            when [:short, 'Array']
+              ''
+            when [:long, 'Array']
+              'Array'
+            else
+              types_explainer.name
+            end
+            "#{tname}<#{types_explainer.types.map { styled_string(_1) }.join(', ')}>"
+          when ::YARD::Tags::TypesExplainer::Type
+            types_explainer.name
+          else
+            raise "#{types_explainer.class} is not supported"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yard/meaningless_tag.rb

@@ -22,6 +22,7 @@ module RuboCop
       class MeaninglessTag < Base
         include RangeHelp
         include DocumentationComment
+        extend AutoCorrector
 
         def on_class(node)
           check(node)
@@ -41,7 +42,9 @@ module RuboCop
             comment = preceding_lines.find { |line| line.text.include?("@#{tag.tag_name}") }
             next unless comment
 
-            add_offense(comment, message: "`@#{tag.tag_name}` is meaningless tag on #{node.type}")
+            add_offense(comment, message: "`@#{tag.tag_name}` is meaningless tag on #{node.type}") do |corrector|
+              corrector.replace(comment, comment.text.gsub("@#{tag.tag_name}", tag.tag_name))
+            end
           end
         end
       end

data/lib/rubocop/cop/yard/mismatch_name.rb

@@ -17,6 +17,7 @@ module RuboCop
       #   def foo(bar, opts = {}, *arg)
       #   end
       class MismatchName < Base
+        include YARD::Helper
         include RangeHelp
         include DocumentationComment
 
@@ -28,29 +29,69 @@ module RuboCop
 
           yard_docstring = preceding_lines.map { |line| line.text.gsub(/\A#\s*/, '') }.join("\n")
           docstring = ::YARD::DocstringParser.new.parse(yard_docstring)
-          docstring.tags.each do |tag|
-            next unless tag.tag_name == 'param' || tag.tag_name == 'option'
-            next unless node.arguments.none? { |arg_node| tag.name.to_sym == arg_node.name }
-
-            tag_name_regexp = Regexp.new("\\b#{Regexp.escape(tag.name)}\\b")
-            comment = preceding_lines.find { |line| line.text.match?(tag_name_regexp) && line.text.include?("@#{tag.tag_name}") }
-            next unless comment
-
-            start_column = comment.source.index(tag_name_regexp)
-            offense_start = comment.location.column + start_column
-            offense_end = offense_start + tag.name.length - 1
-            range = source_range(processed_source.buffer, comment.location.line, offense_start..offense_end)
-            add_offense(range, message: "`#{tag.name}` is not found in method arguments")
+          return false if include_overload_tag?(docstring)
+
+          each_tags_by_docstring(['param', 'option'], docstring) do |tags|
+            tags.each_with_index do |tag, i|
+              comment = find_by_tag(preceding_lines, tag, i)
+              next unless comment
+
+              # YARD::Tags::RefTagList is not has name and types
+              next if tag.instance_of?(::YARD::Tags::RefTagList)
+
+              types = extract_tag_types(tag)
+              unless tag.name && types
+                if tag.name.nil?
+                  add_offense(comment, message: "No tag name is supplied in `@#{tag.tag_name}`")
+                elsif types.nil?
+                  add_offense(comment, message: "No types are associated with the tag in `@#{tag.tag_name}`")
+                end
+
+                next
+              end
+
+              next unless node.arguments.none? { |arg_node| tag.name.to_sym == arg_node.name }
+
+              begin
+                parse_type(types.join(', '))
+              rescue SyntaxError
+                next
+              end
+
+              add_offense_to_tag(comment, tag)
+            end
           end
         end
         alias on_defs on_def
-      end
 
-      private
+        private
 
-      # @param [void] aaa
-      # @option opts bbb [void]
-      def dummy(aaa, opts = {}, *)
+        def each_tags_by_docstring(tag_names, docstring)
+          tag_names.each do |tag_name|
+            yield docstring.tags.select { |tag| tag.tag_name == tag_name }
+          end
+        end
+
+        def find_by_tag(preceding_lines, tag, i)
+          count = -1
+          preceding_lines.find do |line|
+            count += 1 if line.text.include?("@#{tag.tag_name}")
+            count == i
+          end
+        end
+
+        def add_offense_to_tag(comment, tag)
+          tag_name_regexp = Regexp.new("\\b#{Regexp.escape(tag.name)}\\b")
+          start_column = comment.source.index(tag_name_regexp)
+          offense_start = comment.location.column + start_column
+          offense_end = offense_start + tag.name.length - 1
+          range = source_range(processed_source.buffer, comment.location.line, offense_start..offense_end)
+          add_offense(range, message: "`#{tag.name}` is not found in method arguments")
+        end
+
+        def include_overload_tag?(docstring)
+          docstring.tags.any? { |tag| tag.tag_name == "overload" }
+        end
       end
     end
   end

data/lib/rubocop/cop/yard/tag_type_syntax.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module YARD
+      # @example tag type
+      #   # bad
+      #   # @param [Integer String]
+      #
+      #   # good
+      #   # @param [Integer, String]
+      class TagTypeSyntax < Base
+        include YARD::Helper
+        include RangeHelp
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next if inline_comment?(comment)
+            next unless include_yard_tag?(comment)
+
+            check(comment)
+          end
+        end
+
+        private
+
+        def check(comment)
+          docstring = comment.text.gsub(/\A#\s*/, '')
+          ::YARD::DocstringParser.new.parse(docstring).tags.each do |tag|
+            types = extract_tag_types(tag)
+
+            check_syntax_error(comment) do
+              parse_type(types.join(', '))
+            end
+          end
+        end
+
+        def check_syntax_error(comment)
+          begin
+            yield
+          rescue SyntaxError => e
+            add_offense(tag_range_for_comment(comment), message: "(#{e.class}) #{e.message}")
+          end
+        end
+
+        def inline_comment?(comment)
+          !comment_line?(comment.source_range.source_line)
+        end
+
+        def include_yard_tag?(comment)
+          comment.source.match?(/@(?:param|return|option|raise|yieldparam|yieldreturn)\s+.*\[.*\]/)
+        end
+
+        def tag_range_for_comment(comment)
+          start_column = comment.source.index(/\[/) + 1
+          end_column = comment.source.index(/\]/)
+          offense_start = comment.location.column + start_column
+          offense_end = comment.location.column + end_column
+          source_range(processed_source.buffer, comment.location.line, offense_start..offense_end)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/yard_cops.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'yard'
+require_relative 'yard/helper'
+require_relative 'yard/collection_style'
+require_relative 'yard/collection_type'
 require_relative 'yard/meaningless_tag'
-require_relative 'yard/tag_type'
 require_relative 'yard/mismatch_name'
+require_relative 'yard/tag_type_syntax'

data/lib/rubocop/yard/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module YARD
-    VERSION = "0.4.0"
+    VERSION = "0.6.0"
   end
 end

data/sig/rubocop/yard.rbs

@@ -5,7 +5,7 @@ module RuboCop
   end
   module Cop
     module YARD
-      class TagType
+      class CollectionType
         type t = YARD::Tags::TypesExplainer::Type
                | ::YARD::Tags::TypesExplainer::CollectionType
                | ::YARD::Tags::TypesExplainer::FixedCollectionType

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-yard
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-19 00:00:00.000000000 Z
+date: 2023-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -51,9 +51,12 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-yard.rb
+- lib/rubocop/cop/yard/collection_style.rb
+- lib/rubocop/cop/yard/collection_type.rb
+- lib/rubocop/cop/yard/helper.rb
 - lib/rubocop/cop/yard/meaningless_tag.rb
 - lib/rubocop/cop/yard/mismatch_name.rb
-- lib/rubocop/cop/yard/tag_type.rb
+- lib/rubocop/cop/yard/tag_type_syntax.rb
 - lib/rubocop/cop/yard_cops.rb
 - lib/rubocop/yard.rb
 - lib/rubocop/yard/inject.rb

data/lib/rubocop/cop/yard/tag_type.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module YARD
-      # @example tag type
-      #   # bad
-      #   # @param [Integer String]
-      #
-      #   # bad
-      #   # @param [Hash<Symbol, String>]
-      #
-      #   # bad
-      #   # @param [Hash(String)]
-      #
-      #   # bad
-      #   # @param [Array{Symbol => String}]
-      #
-      #   # good
-      #   # @param [Integer, String]
-      #
-      #   # good
-      #   # @param [<String>]
-      #   # @param [Array<String>]
-      #   # @param [List<String>]
-      #   # @param [Array<(String, Fixnum, Hash)>]
-      #
-      #   # good
-      #   # @param [(String)]
-      #   # @param [Array(String)]
-      #
-      #   # good
-      #   # @param [{KeyType => ValueType}]
-      #   # @param [Hash{KeyType => ValueType}]
-      class TagType < Base
-        include RangeHelp # @return [void,]
-
-        def on_new_investigation
-          processed_source.comments.each do |comment|
-            next if inline_comment?(comment)
-            next unless include_yard_tag?(comment)
-
-            check(comment)
-          end
-        end
-
-        private
-
-        def check(comment)
-          docstring = comment.text.gsub(/\A#\s*/, '')
-          ::YARD::DocstringParser.new.parse(docstring).tags.each do |tag|
-            types = extract_tag_type(tag)
-
-            check_syntax_error(comment) do
-              types_explainers = ::YARD::Tags::TypesExplainer::Parser.parse(types.join(', '))
-              types_explainers.each do |types_explainer|
-                check_mismatch_collection_type(comment, types_explainer)
-              end
-            end
-          end
-        end
-
-        def check_syntax_error(comment)
-          begin
-            yield
-          rescue SyntaxError => e
-            add_offense(tag_range_for_comment(comment), message: "(#{e.class}) #{e.message}")
-          end
-        end
-
-        def check_mismatch_collection_type(comment, types_explainer)
-          case types_explainer
-          when ::YARD::Tags::TypesExplainer::HashCollectionType
-            if types_explainer.name == 'Hash'
-              types_explainer.key_types.each { |t| check_mismatch_collection_type(comment, t) }
-              types_explainer.value_types.each { |t| check_mismatch_collection_type(comment, t) }
-            else
-              did_you_mean = types_explainer.name == 'Array' ? 'Did you mean `<Type>` or `Array<Type>`' : ''
-              message = "`{KeyType => ValueType}` is the hash collection type syntax. #{did_you_mean}"
-              add_offense(tag_range_for_comment(comment), message: message)
-            end
-          when ::YARD::Tags::TypesExplainer::FixedCollectionType
-            if types_explainer.name == 'Hash'
-              message = "`(Type)` is the fixed collection type syntax. Did you mean `{KeyType => ValueType}` or `Hash{KeyType => ValueType}`"
-              add_offense(tag_range_for_comment(comment), message: message)
-            else
-              types_explainer.types.each { |t| check_mismatch_collection_type(comment, t) }
-            end
-          when ::YARD::Tags::TypesExplainer::CollectionType
-            if types_explainer.name == 'Hash'
-              message = "`<Type>` is the collection type syntax. `{KeyType => ValueType}` or `Hash{KeyType => ValueType}` is more good"
-              add_offense(tag_range_for_comment(comment), message: message)
-            else
-              types_explainer.types.each { |t| check_mismatch_collection_type(comment, t) }
-            end
-          end
-        end
-
-        def extract_tag_type(tag)
-          case tag
-          when ::YARD::Tags::OptionTag
-            tag.pair.types
-          else
-            tag.types
-          end
-        end
-
-        def inline_comment?(comment)
-          !comment_line?(comment.source_range.source_line)
-        end
-
-        def include_yard_tag?(comment)
-          comment.source.match?(/@(?:param|return|option|raise|yieldparam|yieldreturn)\s+.*\[.*\]/)
-        end
-
-        def tag_range_for_comment(comment)
-          start_column = comment.source.index(/\[/) + 1
-          end_column = comment.source.index(/\]/)
-          offense_start = comment.location.column + start_column
-          offense_end = comment.location.column + end_column
-          source_range(processed_source.buffer, comment.location.line, offense_start..offense_end)
-        end
-      end
-    end
-  end
-end