Better name validation for methods and parameters

lib/tapioca/dsl/compiler.rb

@@ -168,11 +168,6 @@ def as_nilable_type(type)
           "T.nilable(#{type})"
         end
       end
-
-      sig { params(name: String).returns(T::Boolean) }
-      def valid_parameter_name?(name)
-        name.match?(/^[[[:alnum:]]_]+$/)
-      end
     end
   end
 end

lib/tapioca/gem/listeners/methods.rb

@@ -7,13 +7,9 @@ module Listeners
       class Methods < Base
         extend T::Sig
 
+        include RBIHelper
         include Runtime::Reflection
 
-        SPECIAL_METHOD_NAMES = T.let([
-          "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
-          "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",
-        ], T::Array[String])
-
         private
 
         sig { override.params(event: ScopeNodeAdded).void }
@@ -184,18 +180,6 @@ def struct_method?(constant, method_name)
             .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
-        sig { params(name: String).returns(T::Boolean) }
-        def valid_method_name?(name)
-          return true if SPECIAL_METHOD_NAMES.include?(name)
-
-          !!name.match(/^[[:word:]]+[?!=]?$/)
-        end
-
-        sig { params(name: String).returns(T::Boolean) }
-        def valid_parameter_name?(name)
-          name.match?(/^[[[:alnum:]]_]+$/)
-        end
-
         sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
         def initialize_method_for(constant)
           constant.instance_method(:initialize)

lib/tapioca/helpers/rbi_helper.rb

@@ -6,6 +6,7 @@ module RBIHelper
     extend T::Sig
     include SorbetHelper
     extend SorbetHelper
+    extend self
 
     sig { params(name: String, type: String).returns(RBI::TypedParam) }
     def create_param(name, type:)
@@ -89,5 +90,15 @@ def self.serialize_type_variable(type, variance, fixed, upper, lower)
       serialized << " { { #{block.join(", ")} } }" unless block.empty?
       serialized
     end
+
+    sig { params(name: String).returns(T::Boolean) }
+    def valid_method_name?(name)
+      !name.to_sym.inspect.start_with?(':"', ":@", ":$")
+    end
+
+    sig { params(name: String).returns(T::Boolean) }
+    def valid_parameter_name?(name)
+      /^([[:lower:]]|_|[^[[:ascii:]]])([[:alnum:]]|_|[^[[:ascii:]]])*$/.match?(name)
+    end
   end
 end

lib/tapioca/rbi_ext/model.rb

@@ -86,7 +86,7 @@ def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: n
       ).void
     end
     def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new)
-      return unless valid_method_name?(name)
+      return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sig = RBI::Sig.new(return_type: return_type)
       method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method, visibility: visibility)
@@ -99,19 +99,6 @@ def create_method(name, parameters: [], return_type: "T.untyped", class_method:
 
     private
 
-    SPECIAL_METHOD_NAMES = T.let(
-      ["!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^", "<", "<=", "=>", ">", ">=",
-       "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",].freeze,
-      T::Array[String]
-    )
-
-    sig { params(name: String).returns(T::Boolean) }
-    def valid_method_name?(name)
-      return true if SPECIAL_METHOD_NAMES.include?(name)
-
-      !!name.match(/^[a-zA-Z_][[:word:]]*[?!=]?$/)
-    end
-
     sig { returns(T::Hash[String, RBI::Node]) }
     def nodes_cache
       T.must(@nodes_cache ||= T.let({}, T.nilable(T::Hash[String, Node])))

spec/tapioca/helpers/rbi_helper_spec.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "spec_helper"
+
+class Tapioca::RBIHelperSpec < Minitest::Spec
+  include Tapioca::RBIHelper
+
+  describe Tapioca::RBIHelper do
+    it "accepts valid method names" do
+      [
+        "f", "foo", "_foo", "foo_", "fOO", "f00", "foo!", "foo=", "foo?", "Foo", "éxéctôr", "❨╯°□°❩╯︵┻━┻",
+        "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
+        "<", "<=", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",
+      ].each do |name|
+        assert(valid_method_name?(name))
+      end
+    end
+
+    it "rejects invalid method names" do
+      ["", "42", "42foo", "!foo", "-@foo", "foo-", "foo-bar", "foo.bar", "=>"].each do |name|
+        refute(valid_method_name?(name))
+      end
+    end
+
+    it "accepts valid parameter names" do
+      ["f", "foo", "_foo", "foo_", "fOO", "f00", "éxéctôr", "❨╯°□°❩╯︵┻━┻"].each do |name|
+        assert(valid_parameter_name?(name))
+      end
+    end
+
+    it "rejects invalid parameter names" do
+      [
+        "", "42", "42foo", "foo!", "foo=", "foo?", "Foo", "!foo", "-@foo", "foo-", "foo-bar", "foo.bar",
+        "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
+        "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",
+      ].each do |name|
+        refute(valid_parameter_name?(name))
+      end
+    end
+  end
+end