rubydex 0.4.0 → 0.4.2

data/lib/rubydex/mcp_server/tools/get_file_declarations_tool.rb

@@ -4,10 +4,10 @@ module Rubydex
   module MCPServer
     class GetFileDeclarationsTool < BaseTool
       tool_name "get_file_declarations"
-      description "List all Ruby classes, modules, methods, and constants defined in a specific file. Returns a structural overview with names, kinds, and line numbers. Use this to understand a file's structure before reading it, or to see what a file contributes to the codebase. Accepts relative or absolute paths."
+      description "List Ruby declarations defined in an indexed file."
       input_schema(
         properties: {
-          file_path: { type: "string", description: "File path (relative or absolute) to list declarations for" },
+          file_path: { type: "string", description: "Absolute path or path relative to the workspace root" },
         },
         required: ["file_path"],
       )

data/lib/rubydex/mcp_server/tools/search_declarations_tool.rb

@@ -4,14 +4,14 @@ module Rubydex
   module MCPServer
     class SearchDeclarationsTool < BaseTool
       tool_name "search_declarations"
-      description 'Search for Ruby classes, modules, methods, or constants by name. Use this INSTEAD OF Grep when you know part of a Ruby identifier name and want to find its definition. Returns fully qualified names, kinds, and file locations. Use the `kind` filter ("Class", "Module", "Method", "Constant") to narrow results. Set `match_mode` to "exact" for precise substring matching or "fuzzy" for LSP-style workspace symbol search (default). Results are paginated: the response includes `total` (the full count of matches). If `total` exceeds the number of returned results, use `offset` to fetch subsequent pages.'
+      description "Find definitions of Ruby classes, modules, methods, or constants by full or partial name."
       input_schema(
         properties: {
-          query: { type: "string", description: "Search query to match against declaration names" },
-          kind: { type: "string", description: "Filter by declaration kind: Class, Module, Method, Constant, etc." },
-          match_mode: { type: "string", description: 'Matching mode: "fuzzy" (default) for LSP-style workspace symbol search, or "exact" for precise substring matching' },
-          limit: { type: "integer", description: "Maximum number of results to return (default 50, max 100)" },
-          offset: { type: "integer", description: "Number of results to skip for pagination (default 0)" },
+          query: { type: "string", description: "Text to match against fully qualified names. An empty string matches all declarations." },
+          kind: { type: "string", description: "Case-insensitive declaration kind, such as Class, Module, Method, or Constant" },
+          match_mode: { type: "string", description: '"fuzzy" (default) matches characters in order, ignoring ASCII case. "exact" matches a case-sensitive substring.' },
+          limit: { type: "integer", description: "Page size (default 50, capped at 100)" },
+          offset: { type: "integer", description: "Number of results to skip (default 0)" },
         },
         required: ["query"],
       )

data/lib/rubydex/mcp_server.rb

@@ -10,19 +10,13 @@ Dir[File.join(__dir__, "mcp_server", "tools", "*_tool.rb")].sort.each { |file| r
 module Rubydex
   module MCPServer
     SERVER_INSTRUCTIONS = <<~TEXT
-      Rubydex provides semantic Ruby code intelligence.
-
-      Use these tools for Ruby source files (.rb, .rbi, .rbs) when you need structural information about declarations, locations, hierarchy, references, or codebase composition.
-
-      Use text search instead for literal strings, comments, log messages, non-Ruby files, or content search rather than structural queries.
-
-      Fully qualified name format: "Foo::Bar" for classes/modules/constants, "Foo::Bar#method_name" for instance methods.
-
-      Pagination: tools that may return a high number of results include `total` for pagination. When `total` exceeds the number of returned items, use `offset` to fetch the next page.
+      Tools query a static index of workspace code, available bundle dependencies, and available Ruby core and standard-library RBS definitions.
+      The index is built at server startup and does not track file changes; restart the server to refresh it.
     TEXT
 
     class Server
       WORKER_COUNT = 4
+      SHUTDOWN_JOIN_TIMEOUT = 2
 
       #: (root_path: String, ?transport: StdioTransport) -> void
       def initialize(root_path:, transport: nil)
@@ -34,13 +28,14 @@ module Rubydex
         @outgoing_queue = Thread::Queue.new
         @workers = []
         @outgoing_dispatcher = nil
+        @indexer = nil
       end
 
       attr_reader :root_path
 
       #: -> Thread
       def spawn_indexer
-        Thread.new do
+        @indexer = Thread.new do
           @graph.index_workspace
           @graph.resolve
           @index_finished = true
@@ -150,9 +145,26 @@ module Rubydex
       #: -> void
       def run_shutdown
         @incoming_queue.close unless @incoming_queue.closed?
-        @workers.each(&:join)
+        join_or_kill_all(@workers + [@indexer])
         @outgoing_queue.close unless @outgoing_queue.closed?
-        @outgoing_dispatcher&.join
+        join_or_kill_all([@outgoing_dispatcher])
+      end
+
+      #: (Array[Thread?]) -> void
+      def join_or_kill_all(threads)
+        live_threads = threads.compact.select(&:alive?)
+        return if live_threads.empty?
+
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + SHUTDOWN_JOIN_TIMEOUT
+        live_threads.each do |thread|
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          break if remaining <= 0
+
+          thread.join(remaining)
+        end
+
+        live_threads.select(&:alive?).each(&:kill)
+        live_threads.select(&:alive?).each(&:join)
       end
 
       #: -> Thread

data/lib/rubydex/rules/dynamic_ancestor.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Dynamic ancestor references cannot be reasoned about statically because they depend on runtime values. The
+    # program may still be valid, but the quality of the analysis degrades. In the case of ancestors, since they
+    # influence constant resolution, the degradation may be more impactful than other dynamic references.
+    #
+    # ```ruby
+    # class Foo < var
+    #             ^^^ Dynamic ancestor reference. This might be correct, but it cannot be understood by the analysis.
+    #   include SomeClass.method_call
+    #           ^^^^^^^^^^^^^^^^^^^^^ Dynamic ancestor reference.
+    # end
+    # ```
+    class DynamicAncestor < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/dynamic_constant_reference.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Dynamic constant references cannot be reasoned about statically because they depend on runtime values. The
+    # program may still be valid, but the quality of the analysis degrades.
+    #
+    # ```ruby
+    # var::Foo
+    # ^^^^^^^^ Dynamic constant reference. This might be correct, but it cannot be understood by the analysis.
+    # ```
+    class DynamicConstantReference < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/dynamic_singleton_definition.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Dynamic singleton targets cannot be reasoned about statically because they depend on runtime values. The program
+    # may still be valid, but the quality of the analysis degrades.
+    #
+    # ```ruby
+    # class << var
+    #          ^^^ Dynamic singleton target. This might be correct, but it cannot be understood by the analysis.
+    # end
+    #
+    # def var.bar
+    #     ^^^ Dynamic singleton target.
+    # end
+    # ```
+    class DynamicSingletonDefinition < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/invalid_constant_visibility.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Constant visibility operations that depend on dynamic values cannot be reasoned about statically because they
+    # depend on runtime values. The program may still be valid, but the quality of the analysis degrades.
+    #
+    # ```ruby
+    # var.private_constant :Foo
+    # ^^^ Invalid constant visibility. This might be correct, but it cannot be understood by the analysis.
+    #
+    # private_constant(var)
+    #                  ^^^ Invalid constant visibility.
+    # ```
+    class InvalidConstantVisibility < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/invalid_method_visibility.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Method visibility operations that depend on dynamic values cannot be reasoned about statically because they
+    # depend on runtime values. The program may still be valid, but the quality of the analysis degrades.
+    #
+    # ```ruby
+    # var.private :foo
+    # ^^^ Invalid method visibility. This might be correct, but it cannot be understood by the analysis.
+    #
+    # private(var)
+    #         ^^^ Invalid method visibility.
+    # ```
+    class InvalidMethodVisibility < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/parse_error.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # A parse error represents invalid Ruby syntax and a program that will fail to execute. For example, a missing
+    # `end`, an unterminated string, a missing parenthesis.
+    #
+    # ```ruby
+    # class Foo
+    # ^^^^^ Syntax error. Missing end token
+    # ```
+    class ParseError < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Error
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/parse_warning.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Parse warnings represent code that has valid syntax, but may not do what the developer expects. For example,
+    # local variables that are completely unused or usage in a void context (creating a line of code that does
+    # nothing).
+    #
+    # ```ruby
+    # CONST = 1
+    # CONST
+    # ^^^^^ Constant used in void context (the expression does nothing).
+    # puts CONST + 2
+    # ```
+    class ParseWarning < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/top_level_mixin_self.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # The top level of a Ruby program is the special <main> object. It is not possible to use `include self` or
+    # `extend self` on that object.
+    #
+    # ```ruby
+    # include self
+    #         ^^^^ Cannot include self at the top level
+    # extend self
+    #        ^^^^ Cannot extend self at the top level
+    # ```
+    class TopLevelMixinSelf < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Information
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/undefined_constant_visibility_target.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Undefined constant visibility target means the analysis couldn't find the definition for the constant the code is
+    # attempting to change visibility of. It could be defined through meta-programming or it indeed does not exist.
+    #
+    # ```ruby
+    # class Foo
+    #   private_constant :Bar
+    #                    ^^^ Undefined constant visibility target. The constant `Bar` is not defined.
+    # end
+    # ```
+    class UndefinedConstantVisibilityTarget < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/rules/undefined_method_visibility_target.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This file is generated by `generate_ruby_rules.rs`. Do not edit this manually.
+
+module Rubydex
+  module Rules
+    # Undefined method visibility target means the analysis couldn't find the definition for the method the code is
+    # attempting to change visibility of. It could be defined through meta-programming or it indeed does not exist.
+    #
+    # ```ruby
+    # class Foo
+    #   private :bar
+    #            ^^^ Undefined method visibility target. The method `bar` is not defined.
+    # end
+    # ```
+    class UndefinedMethodVisibilityTarget < Rule
+      class << self
+        # @override
+        #: -> singleton(Severity::Base)
+        def default_severity
+          Severity::Warning
+        end
+      end
+    end
+  end
+end

data/lib/rubydex/skill.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "yaml"
 require "rubydex/errors"
 
 module Rubydex

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.4.0"
+  VERSION = "0.4.2"
 end

data/lib/rubydex.rb

@@ -31,3 +31,5 @@ require "rubydex/graph"
 require "rubydex/declaration"
 require "rubydex/signature"
 require "rubydex/reference"
+
+Dir.glob("#{__dir__}/rubydex/rules/**/*.rb").each { |file| require file }

data/lib/rubydex_linter/rules/rule_structure.rb

@@ -9,7 +9,8 @@ module Rubydex
       # - Each rule subclass outside a test directory is in a rule directory.
       # - Each checked rule subclass is in the `Rubydex::Linter::Rules` namespace.
       #
-      # The rule directories are `rubydex_linter/rules/` and `lib/rubydex_linter/rules/`.
+      # The rule directories are `rubydex_linter/rules/` and `lib/rubydex_linter/rules/`, including
+      # `lib/rubydex_linter/rules/` directories in nested gems.
       # This rule does not report files in those directories that define no rule subclass.
       class RuleStructure < CustomRule
         include Helpers::SourceAccessHelpers
@@ -18,7 +19,7 @@ module Rubydex
         RULE_NAMESPACE = "Rubydex::Linter::Rules" #: String
         RULE_FILE_PATTERNS = [
           "rubydex_linter/rules/**/*.rb",
-          "lib/rubydex_linter/rules/**/*.rb",
+          "**/lib/rubydex_linter/rules/**/*.rb",
         ].freeze #: Array[String]
         TEST_FILE_PATTERNS = ["test/**/*", "**/test/**/*"].freeze #: Array[String]
 
@@ -37,6 +38,8 @@ module Rubydex
           rule_definitions_by_file = {} #: Hash[String, Hash[Rubydex::Class, Definition]]
 
           rules.each do |rule|
+            rule_docs = []
+
             rule.definitions.each do |rule_definition|
               uri = rule_definition.document.uri
               path = path_for_uri(uri)
@@ -48,6 +51,8 @@ module Rubydex
               elsif !test_file?(path)
                 report_wrong_rule_directory(rule.name, rule_definition)
               end
+
+              rule_docs.concat(rule_definition.comments)
             end
 
             rule_definition = rule.definitions.find do |definition|
@@ -55,9 +60,19 @@ module Rubydex
               path_in_workspace?(path) && (rule_file?(path) || !test_file?(path))
             end
             next unless rule_definition
-            next if rule.name.start_with?("#{RULE_NAMESPACE}::")
 
-            report_wrong_rule_namespace(rule.name, rule_definition)
+            rule_name = rule.name
+
+            if rule_docs.empty?
+              add_diagnostic(
+                "`#{rule_name}` is missing documentation.",
+                diagnostic_location(rule_definition),
+              )
+            end
+
+            next if rule_name.start_with?("#{RULE_NAMESPACE}::")
+
+            report_wrong_rule_namespace(rule_name, rule_definition)
           end
 
           rule_definitions_by_file.each do |uri, rule_definitions|

data/rbi/rubydex.rbi

@@ -175,8 +175,17 @@ class Rubydex::AttrAccessorDefinition < Rubydex::Definition; end
 class Rubydex::AttrReaderDefinition < Rubydex::Definition; end
 class Rubydex::AttrWriterDefinition < Rubydex::Definition; end
 class Rubydex::ClassVariableDefinition < Rubydex::Definition; end
-class Rubydex::ConstantAliasDefinition < Rubydex::Definition; end
-class Rubydex::ConstantDefinition < Rubydex::Definition; end
+
+class Rubydex::ConstantAliasDefinition < Rubydex::Definition
+  sig { returns(String) }
+  def raw_name; end
+end
+
+class Rubydex::ConstantDefinition < Rubydex::Definition
+  sig { returns(String) }
+  def raw_name; end
+end
+
 class Rubydex::GlobalVariableAliasDefinition < Rubydex::Definition; end
 class Rubydex::GlobalVariableDefinition < Rubydex::Definition; end
 class Rubydex::InstanceVariableDefinition < Rubydex::Definition; end
@@ -271,6 +280,9 @@ class Rubydex::Signature::BlockParameter < Rubydex::Signature::Parameter; end
 class Rubydex::ModuleDefinition < Rubydex::Definition
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
+
+  sig { returns(String) }
+  def raw_name; end
 end
 
 class Rubydex::SingletonClassDefinition < Rubydex::Definition
@@ -284,6 +296,9 @@ class Rubydex::ClassDefinition < Rubydex::Definition
 
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
+
+  sig { returns(String) }
+  def raw_name; end
 end
 
 class Rubydex::Mixin
@@ -337,80 +352,6 @@ class Rubydex::Rule
   end
 end
 
-module Rubydex::Rules
-  ALL = T.let(T.unsafe(nil), T::Array[T.class_of(Rubydex::Rule)])
-end
-
-class Rubydex::Rules::ParseError < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::ParseWarning < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::DynamicConstantReference < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::DynamicSingletonDefinition < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::DynamicAncestor < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::TopLevelMixinSelf < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::InvalidConstantVisibility < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::InvalidMethodVisibility < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::UndefinedMethodVisibilityTarget < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
-class Rubydex::Rules::UndefinedConstantVisibilityTarget < Rubydex::Rule
-  class << self
-    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
-    def default_severity; end
-  end
-end
-
 class Rubydex::RelatedInformation
   sig { params(message: String, location: Rubydex::Location).void }
   def initialize(message, location); end
@@ -594,58 +535,6 @@ class Rubydex::Linter::Rules::RuleStructure < Rubydex::Linter::CustomRule
   def lint; end
 end
 
-class Rubydex::Linter::RuleTestCase < Minitest::Test
-  DEFAULT_FILE = T.let(T.unsafe(nil), String)
-  ANNOTATION_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-  sig { returns(String) }
-  def workspace_path; end
-
-  sig { params(name: String).void }
-  def initialize(name); end
-
-  sig { void }
-  def teardown; end
-
-  sig { returns(T.class_of(Rubydex::Linter::CustomRule)) }
-  def rule_class; end
-
-  sig { params(sources: T::Hash[String, String]).void }
-  def add_shared_source(sources); end
-
-  sig { returns(T::Array[String]) }
-  def ignored_diagnostic_files; end
-
-  sig { returns(Rubydex::LinterConfig) }
-  def rule_config; end
-
-  sig do
-    params(
-      args: T.any(String, T::Hash[T.any(String, Symbol), String]),
-      rule_builder: T.nilable(T.proc.params(graph: Rubydex::Graph).returns(Rubydex::Linter::CustomRule)),
-    ).returns(T::Array[Rubydex::Diagnostic])
-  end
-  def assert_diagnostics(*args, &rule_builder); end
-
-  sig do
-    params(
-      args: T.any(String, T::Hash[T.any(String, Symbol), String]),
-      rule_builder: T.nilable(T.proc.params(graph: Rubydex::Graph).returns(Rubydex::Linter::CustomRule)),
-    ).returns(T::Array[Rubydex::Diagnostic])
-  end
-  def assert_no_diagnostics(*args, &rule_builder); end
-
-  sig do
-    params(
-      dependency: String,
-      args: T.any(String, T::Hash[T.any(String, Symbol), String]),
-      after_excluding: T::Array[String],
-      rule_builder: T.nilable(T.proc.params(graph: Rubydex::Graph).returns(Rubydex::Linter::CustomRule)),
-    ).void
-  end
-  def assert_handles_missing_required_dependency(dependency, *args, after_excluding: [], &rule_builder); end
-end
-
 class Rubydex::Linter::Runner
   sig do
     params(
@@ -891,8 +780,18 @@ class Rubydex::Graph
   sig { returns(T.self_type) }
   def resolve; end
 
-  sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(Rubydex::Declaration)) }
-  def resolve_constant(name, nesting); end
+  sig do
+    params(
+      name: String,
+      context: T.any(
+        T::Array[String],
+        Rubydex::ClassDefinition,
+        Rubydex::SingletonClassDefinition,
+        Rubydex::ModuleDefinition,
+      ),
+    ).returns(T.nilable(Rubydex::Declaration))
+  end
+  def resolve_constant(name, context); end
 
   sig { params(require_path: String, load_paths: T::Array[String]).returns(T.nilable(Rubydex::Document)) }
   def resolve_require_path(require_path, load_paths); end
@@ -903,6 +802,9 @@ class Rubydex::Graph
   sig { params(queries: String).returns(T::Enumerable[Rubydex::Declaration]) }
   def fuzzy_search(*queries); end
 
+  sig { returns(T::Enumerable[Rubydex::Declaration]) }
+  def dead_code_candidates; end
+
   sig { params(encoding: String).void }
   def encoding=(encoding); end