Add Lint/VoidOutsideLib

Author: nobodywasishere

spec/ameba/rule/lint/void_outside_lib_spec.cr

@@ -0,0 +1,97 @@
+require "../../../spec_helper"
+
+module Ameba::Rule::Lint
+  describe VoidOutsideLib do
+    subject = VoidOutsideLib.new
+
+    it "passes if Void is used in a fun def" do
+      expect_no_issues subject, <<-CRYSTAL
+        lib LibFoo
+          fun bar(baz : Void) : Void
+        end
+        CRYSTAL
+    end
+
+    it "passes if `Pointer(Void)` is used as a parameter type restriction" do
+      expect_no_issues subject, <<-CRYSTAL
+        def foo(bar : Pointer(Void))
+        end
+        CRYSTAL
+    end
+
+    it "fails if `Void` is used as a parameter type restriction" do
+      expect_issue subject, <<-CRYSTAL
+        def foo(bar : Void)
+                    # ^^^^ error: `Void` is not allowed in this context
+        end
+        CRYSTAL
+    end
+
+    it "passes if `Pointer(Void)` is used as return type restriction" do
+      expect_no_issues subject, <<-CRYSTAL
+        def foo(bar) : Pointer(Void)
+        end
+        CRYSTAL
+    end
+
+    it "passes if `Pointer(Void) | Nil` is used as return type restriction" do
+      expect_no_issues subject, <<-CRYSTAL
+        def foo(bar) : Pointer(Void) | Nil
+        end
+        CRYSTAL
+    end
+
+    it "fails if `Pointer(Void | Int32)` is used as return type restriction" do
+      expect_issue subject, <<-CRYSTAL
+          def foo(bar) : Pointer(Void | Int32)
+                               # ^^^^ error: `Void` is not allowed in this context
+          end
+          CRYSTAL
+    end
+
+    it "fails if `Array(Void)` is used as return type restriction" do
+      expect_issue subject, <<-CRYSTAL
+          def foo(bar) : Array(Void)
+                             # ^^^^ error: `Void` is not allowed in this context
+          end
+          CRYSTAL
+    end
+
+    it "passes if Void is used as name of a class" do
+      expect_no_issues subject, <<-CRYSTAL
+        class Foo
+          class Void
+          end
+        end
+        CRYSTAL
+    end
+
+    it "fails if Void is inherited from" do
+      expect_issue subject, <<-CRYSTAL
+        struct Foo < Void
+                   # ^^^^ error: `Void` is not allowed in this context
+        end
+        CRYSTAL
+    end
+
+    it "passes if Void is name of alias" do
+      expect_no_issues subject, <<-CRYSTAL
+        alias Void = Foo
+        CRYSTAL
+    end
+
+    it "fails if Void is value of alias" do
+      expect_issue subject, <<-CRYSTAL
+        alias Foo = Void
+                  # ^^^^ error: `Void` is not allowed in this context
+        CRYSTAL
+    end
+
+    it "fails if `Void` is used for an uninitialized var" do
+      expect_issue subject, <<-CRYSTAL
+        var = uninitialized Void
+                          # ^^^^ error: `Void` is not allowed in this context
+        CRYSTAL
+    end
+  end
+end

src/ameba/rule/lint/void_outside_lib.cr

@@ -0,0 +1,76 @@
+module Ameba::Rule::Lint
+  # A rule that disallows uses of `Void` outside C lib bindings.
+  # Usages of these outside of C lib bindings don't make sense,
+  # and can sometimes break the compiler. `Nil` should be used instead in these cases.
+  # `Pointer(Void)` is the only case that's allowed per this rule.
+  #
+  # These are considered invalid:
+  #
+  # ```
+  # def foo(bar : Void) : Slice(Void)?
+  # end
+  #
+  # alias Baz = Void
+  #
+  # struct Qux < Void
+  # end
+  # ```
+  #
+  # YAML configuration example:
+  #
+  # ```
+  # Lint/VoidOutsideLib:
+  #   Enabled: true
+  # ```
+  class VoidOutsideLib < Base
+    properties do
+      since_version "1.7.0"
+      description "Disallows use of `Void` outside C lib bindings and `Pointer(Void)`"
+    end
+
+    MSG = "`Void` is not allowed in this context"
+
+    def test(source)
+      PathGenericUnionVisitor.new self, source, skip: [Crystal::LibDef]
+    end
+
+    def test(source, node : Crystal::Path)
+      return unless node.names.join("::") == "Void"
+
+      issue_for node, MSG
+    end
+
+    def test(source, node : Crystal::Generic)
+      # Specifically only allow `Pointer(Void)`
+      return if (name = node.name).is_a?(Crystal::Path) &&
+                name.names.join("::") == "Pointer" &&
+                node.type_vars.size == 1 &&
+                (var = node.type_vars.first).is_a?(Crystal::Path) &&
+                var.names.join("::") == "Void"
+
+      if (name = node.name).is_a?(Crystal::Path) &&
+         name.names.join("::") == "Void"
+        issue_for node, MSG, prefer_name_location: true
+      end
+
+      node.type_vars.each do |type_var|
+        test(source, type_var)
+      end
+    end
+
+    def test(source, node : Crystal::Union)
+      node.types.each do |type|
+        test(source, type)
+      end
+    end
+
+    private class PathGenericUnionVisitor < AST::NodeVisitor
+      def visit(node : Crystal::Generic | Crystal::Path | Crystal::Union)
+        return false if skip?(node)
+
+        @rule.test @source, node
+        false
+      end
+    end
+  end
+end