rubocop-yard 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b62c88ebfb27a008a19460e87ced5cde1352bd778fd7432052606b1220cd82aa
-  data.tar.gz: 11799a04ee4e9944c1303d5daedab3e09eca7ad01262c155ee9022689acb1d73
+  metadata.gz: d4dd27dab805f9450c5043686ad6a530235d31e2a148e1913db76288fa51a39e
+  data.tar.gz: 2820aa0509d5ff6ef0adecbc772168cd8f2b64650109feb4bfb38e810625812a
 SHA512:
-  metadata.gz: 4743f4c79a957b78f28af9639bd78fd06f37c935d52e9123e6a48d2c9280db8132153c2f0f299dba401d0df351858517d5a13b62d4d446042a0ef1419b6aa343
-  data.tar.gz: 5ea7b97be5355401201a0c50692dd9079211c42b5e99b19c4120d2873708e3a5b464747b75f5fa2e1822779169d3d762cd5c5339bade0bb54b6fef9ec6edb886
+  metadata.gz: be2c582e52297d345a8d09f413d98e15c7724b4adbd288fa5bfa38b280e9b5c752dd549885e6ec521bcd4c9dd335a71a9210475ef585d472332c2dd30066350c
+  data.tar.gz: c239f115e44518f79edb4da03cbf54c4c3e6d66659e1ff51ede40047fb5d7af6944dd4a0e08cc8e9bad53c88ae0d7869a4071655105c40704cab44a7eda10620

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.5.0] - 2023-10-9
+
+- Add new cop `YARD/CollectionStyle`
+
+- Split cop from `YARD/TagType` to
+    - `YARD/TagTypeSyntax`
+    - `YARD/CollectionType`
+
+## [0.4.0] - 2023-09-19
+
+- Add new cop `YARD/MeaninglessTag`
+
 ## [0.3.1] - 2023-09-16
 
 Fix config/default.yml

data/README.md

@@ -6,18 +6,66 @@ 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}`
+          ^^^^^^^^^^^^^^^^^^^^ `<Type>` is the collection type syntax. Did you mean `{KeyType => ValueType}` or `Hash{KeyType => ValueType}`
 ```
 
 ### `YARD/MismatchName`
@@ -25,13 +73,32 @@ 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
+                  ^^^^^^ `string` is not found in method arguments
 # @option opt bar [String]
-#         ^^^ `opt` is not found in method arguments
+          ^^^ `opt` is not found in method arguments
 def foo(strings, opts = {})
 ```
 
+### `YARD/MeaninglessTag`
+
+Check `@param` and `@option` with class/module or casgn
+
+```rb
+# @param [String] foo
+^^^^^^^^^^^^^^^^^^^^^ `@param` is meaningless tag on module
+module Foo
+  # @option foo bar [String]
+  ^^^^^^^^^^^^^^^^^^^^^^^^^^ `@option` is meaningless tag on casgn
+  CONST = 1
+```
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/config/default.yml

@@ -1,7 +1,30 @@
-YARD/TagType:
+YARD/MeaninglessTag:
+  Description: 'Check meaningless tag'
+  Enabled: true
+  VersionAdded: '0.4.0'
+
+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_helper.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module YARD
+      module CollectionHelper
+        def extract_tag_types(tag)
+          case tag
+          when ::YARD::Tags::OptionTag
+            tag.pair.types
+          else
+            tag.types
+          end
+        end
+
+        def each_types_explainer(docstring, &block)
+          docstring.tags.each do |tag|
+            types = extract_tag_types(tag)
+
+            begin
+              types_explainers = ::YARD::Tags::TypesExplainer::Parser.parse(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/collection_style.rb

@@ -0,0 +1,91 @@
+# 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::CollectionHelper
+        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 type == 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 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,134 @@
+# 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::CollectionHelper
+        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
+                # `Hash<Key, Value>` pattern is the documented hash specific syntax.
+                message = "`Hash<Key, Value>` is the documented hash specific 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/meaningless_tag.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module YARD
+      # @example meaningless tag
+      #   # bad
+      #   # @param [String] foo
+      #   # @option bar baz [String]
+      #   class Foo
+      #
+      #   # bad
+      #   # @param [String] foo
+      #   # @option bar baz [String]
+      #   CONST = 1
+      #
+      #   # good
+      #   class Foo
+      #
+      #   # good
+      #   CONST = 1
+      class MeaninglessTag < Base
+        include RangeHelp
+        include DocumentationComment
+        extend AutoCorrector
+
+        def on_class(node)
+          check(node)
+        end
+        alias on_module on_class
+        alias on_casgn on_class
+
+        def check(node)
+          preceding_lines = preceding_lines(node)
+          return false unless preceding_comment?(node, preceding_lines.last)
+
+          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'
+
+            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}") do |corrector|
+              corrector.replace(comment, comment.text.gsub("@#{tag.tag_name}", tag.tag_name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module YARD
-      # @example
+      # @example mismatch name
       #   # bad
       #   # @param [void] baz
       #   # @option opt aaa [void]
@@ -12,7 +12,7 @@ module RuboCop
       #
       #   # good
       #   # @param [void] bar
-      #   # @param [Array] argsa
+      #   # @param [Array] arg
       #   # @option opts aaa [void]
       #   def foo(bar, opts = {}, *arg)
       #   end
@@ -28,29 +28,47 @@ 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|
+          docstring.tags.each_with_index do |tag, i|
             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}") }
+            comment = find_by_tag(preceding_lines, tag, i)
             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")
+            unless tag.name && tag.types
+              if tag.name.nil?
+                add_offense(comment, message: "No tag name is supplied in `@#{tag.tag_name}`")
+              elsif tag.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 }
+
+            add_offense_to_tag(comment, tag)
           end
         end
         alias on_defs on_def
-      end
 
-      private
+        private
 
-      # @param [void] aaa
-      # @option opts bbb [void]
-      def dummy(aaa, opts = {}, *)
+        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
       end
     end
   end

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

@@ -0,0 +1,72 @@
+# 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 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_type(tag)
+
+            check_syntax_error(comment) do
+              ::YARD::Tags::TypesExplainer::Parser.parse(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 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

data/lib/rubocop/cop/yard_cops.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
 require 'yard'
-require_relative 'yard/tag_type'
+require_relative 'yard/collection_helper'
+require_relative 'yard/collection_style'
+require_relative 'yard/collection_type'
+require_relative 'yard/meaningless_tag'
 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.3.1"
+    VERSION = "0.5.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.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-16 00:00:00.000000000 Z
+date: 2023-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -51,8 +51,12 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-yard.rb
+- lib/rubocop/cop/yard/collection_helper.rb
+- lib/rubocop/cop/yard/collection_style.rb
+- lib/rubocop/cop/yard/collection_type.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,109 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module YARD
-      # @example
-      #   # 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
-        MSG = ''
-        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|
-            next unless tag.types
-
-            ::YARD::Tags::TypesExplainer::Parser.parse(tag.types.join(', ')).each do |types_explainer|
-              check_mismatch_collection_type(comment, types_explainer)
-            end
-          rescue SyntaxError
-            add_offense(tag_range_for_comment(comment), message: 'SyntaxError as YARD tag type')
-          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 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