candor 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c57856ee0508cf6514f57073f0b68462e9cd8fc6f14c22bebe338dd3161558a3
-  data.tar.gz: f121e2ff9a2ca75a812f2e24991e10332ce5a81765f842c22572672928d3f32f
+  metadata.gz: 413521a77b9a26be85cbfe5ba7078da7a1c9192cb879da37f8d3be0d7c973ecc
+  data.tar.gz: 7b8a583a71fe52f567b7a9c931d9b46dfa9aae0d4d3f8daf2b412e08201cb7c8
 SHA512:
-  metadata.gz: cdd277bdb4c503f974ead0e2be03da69361ceee33b586eefd187a761d03654b0084bc42a069d016578d174aa91cbf767f18a5885bdb4a7602a628b5c83f5d4af
-  data.tar.gz: e5275d7788db55cb88d258f391c45d10a4807b44616c332ace2f3a28a51a975357632a481d3974406147cd85a39a557145b377253033e23456a178eb5c2c8431
+  metadata.gz: 9f1bf8cc569d1c3924b42ae8d299fb9779c8efef396da6eaa9c95ffe625b97c7aa94ba27077f61decb275b3fd6e58aed98d2e2e39f2b1a512e2211e0a0830b20
+  data.tar.gz: 476fd93d7089c5b2ffc2d276f611dd833dcf468f35014662586d5fb536533cbe0e0ba3558c7632fc64d53bd29bf5b9642492335168ae451488710dd4dc1c3bba

data/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and to [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
 
+## [0.2.0] - 2026-07-10
+
+### Added
+- `Candor.define(..., source_location:)` — the location every fabricated name reports, overriding the body's. A caller whose body is a proc it generated on the user's behalf can now point the wrapper at what the user actually wrote, rather than at the generator. It is also the only way to fabricate from a body carrying no location of its own — a curried proc, a symbol-to-proc, a C-defined method — which is the caller assuming responsibility for the honesty the gem otherwise derives. A `#call` object is not one of them and no `source_location:` rescues it: that refusal is about the kind. A `source_location:` that is not a `[String, Integer]` pair, or whose line is one `eval` will not take, raises `ArgumentError` before the target is touched.
+- `Candor::Signature.source_location!` — the location gate, public beside `method_name!` and `parameters!`. `Signature.compile` calls it, so a consumer installing dispatch itself can no longer forge a location `eval` refuses, nor one it silently misreads. Its line must fit `eval`'s: a C `int`.
+
 ## [0.1.0] - 2026-07-10
 
 ### Added
@@ -13,4 +19,5 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - Fabrication is thread-safe through one global `Monitor`; call-time dispatch takes no lock and never needs one. Re-fabricating a name overwrites the wrapper and the body in place, so it is warning-free under `ruby -w`, leaves no orphaned body, and a concurrent caller sees the old method or the new one, never a `NoMethodError`. A frozen target, an unbindable `Method`/`UnboundMethod` body, a name under the reserved `Candor::BODY_PREFIX`, an uncallable `via:` and a malformed `parameters:` all raise before the target is touched.
 - `sig/` ships RBS for the public API: `Candor.define`, `Candor.body_name`, `BODY_PREFIX`, and `Candor::Signature` with `KINDS` and `KEYWORD_BRANCH_LIMIT`. Everything else is `private_constant`, which RBS cannot express and therefore does not declare.
 
+[0.2.0]: https://github.com/svyatov/candor/releases/tag/v0.2.0
 [0.1.0]: https://github.com/svyatov/candor/releases/tag/v0.1.0

data/README.md

@@ -5,7 +5,7 @@
 [![codecov](https://codecov.io/gh/svyatov/candor/branch/main/graph/badge.svg)](https://codecov.io/gh/svyatov/candor)
 
 **Ruby's missing `functools.wraps`.** Turn a block or a callable into a real method that reports the
-*body's* arity, the *body's* `parameters` and the *body's* `source_location` — and rejects a bad call
+*body's* arity, the *body's* `parameters` and the *body's* `source_location`, and rejects a bad call
 before anything of yours runs.
 
 Zero runtime dependencies. Ruby >= 3.2.
@@ -25,13 +25,13 @@ Greeter.new.greet("bob", grating: "yo")          # => ArgumentError: unknown key
 
 Ruby gives you no way to hand a generated wrapper the signature of the callable it wraps.
 `define_method` accepts only a `Proc`, a `Method` or an `UnboundMethod`, so a wrapper's arity has to
-come from an object that already has it — and the only source of such an object is a literal parameter
+come from an object that already has it. The only source of such an object is a literal parameter
 list, hand-typed or generated as text.
 
 So libraries that wrap user-supplied callables retreat to `|*args, **kwargs, &block|`. The results are
-right; the reflection lies. `arity` is `-1`, `parameters` reads `[[:rest], [:keyrest], [:block]]`, a
-wrong-arity call blows up one frame too deep — inside the wrapper, where the library's own error
-handling can swallow it — and every call allocates an Array and a Hash.
+right; the reflection lies. `arity` is `-1`, `parameters` reads `[[:rest], [:keyrest], [:block]]`, and a
+wrong-arity call blows up one frame too deep: inside the wrapper, where the library's own error
+handling can swallow it. Every call allocates an Array and a Hash.
 
 Candor generates the parameter list as source and `eval`s it, once, at definition time. There is no
 degraded fallback: every shape Ruby can express wraps at full fidelity, including `end:`, `it`, `_1`,
@@ -61,7 +61,7 @@ Formatter.new.pad("x", 3)  # => "x  "
 
 `via:` names a method on the target, resolved per call. Every call routes to it and to it alone. It
 receives the canonical name and the arguments exactly as passed, and reaches the body through
-`Candor.body_name`, so it can also choose *not* to run it — memoize, instrument, short-circuit.
+`Candor.body_name`, so it can also choose *not* to run it: memoize, instrument, short-circuit.
 
 ```ruby
 class Memo
@@ -77,7 +77,7 @@ end
 Candor.define(Memo, :catalog, parameters: [], via: :__call) { Catalog.build }
 ```
 
-A wrong-arity call raises at the wrapper, before `__call` is ever entered — so an interceptor that
+A wrong-arity call raises at the wrapper, before `__call` is ever entered, so an interceptor that
 rescues broadly never sees a caller's mistake as a body's failure. An alias left behind by an *earlier*
 fabrication is the exception: it keeps the wrapper it was built with, so its gate is that fabrication's
 signature and not the current body's. See [Re-fabrication](#the-contract).
@@ -102,13 +102,26 @@ dispatch = Candor::Signature.compile(parameters, name: :greet, via: :__call, sou
 klass.define_method(:greet, &dispatch)
 ```
 
+`compile` gates all three of its inputs. `method_name!`, `parameters!` and `source_location!` are public
+for a consumer that wants to fail earlier than the compile does.
+
 ## The contract
 
-**Body kinds.** A block, a `Proc`, a `Method` or an `UnboundMethod` — the three things `define_method`
-takes. A `#call` object is rejected. So is any body whose `source_location` is `nil`: a curried proc, a
-`Symbol#to_proc`, a C-defined method. Ruby exposes no `curried?` predicate, and a nil `source_location`
-is the one reliable discriminator — without it the honest-`source_location` guarantee cannot be kept, and
-that guarantee is the product. Inside a block body, `self` is the receiver.
+**Body kinds.** A block, a `Proc`, a `Method` or an `UnboundMethod`, the three things `define_method`
+takes. A `#call` object is rejected, and no `source_location:` rescues it: the refusal is about the kind.
+So is any body whose `source_location` is `nil`: a curried proc, a `Symbol#to_proc`, a C-defined method.
+Ruby exposes no `curried?` predicate, and a nil `source_location` is the one reliable discriminator.
+Without it the honest-`source_location` guarantee cannot be kept. An explicit `source_location:` is the
+one way to fabricate from those three, and it is the caller taking responsibility for the honesty the gem
+otherwise derives. Inside a block body, `self` is the receiver.
+
+**Location override.** `source_location:` is what every fabricated name reports, in place of the body's.
+A caller whose body is a proc it generated on the user's behalf points the wrapper at what the user
+actually wrote, rather than at the generator:
+
+```ruby
+Candor.define(App, :fetch, source_location: user_block.source_location, body: proc { ... })
+```
 
 **Reserved prefix.** Compiled bodies are private methods named `#{Candor::BODY_PREFIX}#{name}`.
 Fabricating a name that starts with the prefix raises `ArgumentError`.
@@ -117,8 +130,8 @@ Fabricating a name that starts with the prefix raises `ArgumentError`.
 optional positionals left to right, so `n` of them have `n + 1` states, enumerated as call sites rather
 than accumulated into an Array. Optional keywords are independent, so `n` of them would cost `2**n` call
 sites; past `Candor::Signature::KEYWORD_BRANCH_LIMIT` (2) they go through one Hash instead, and
-dispatch allocates exactly one Hash per call. That shape — three or more optional keywords — is the one
-case where candor is slower than the variadic wrapper it replaces. It is measured, and accepted.
+dispatch allocates exactly one Hash per call. That shape, three or more optional keywords, is the one
+case where candor is slower than the variadic wrapper it replaces. It is measured and accepted.
 
 Those counts are what the *wrapper* adds. A body that declares a **keyrest** (`**kw`) costs Ruby one Hash
 to capture it and one to re-splat it into the body, on any wrapper you could write by hand; candor adds
@@ -136,16 +149,18 @@ method in place rather than removing and reinstalling it, so a caller racing a `
 the old method or the new one, never a `NoMethodError`.
 
 **Failing fast.** A frozen target raises `FrozenError`, an `UnboundMethod` whose owner is not an
-ancestor of the target raises `TypeError`, and a malformed `parameters:` or an uncallable `via:` raises
-`ArgumentError` — all *before* the target is touched. A rejected fabrication leaves the target exactly
-as it was. A hand-written `parameters:` never passed Ruby's parser, so it is compiled before the first
-mutation: a shape whose *combination* is illegal — two rests, a duplicate keyword — is an `ArgumentError`
-too. Nothing ever surfaces as a `SyntaxError` from inside `eval`, which a `rescue` would not catch.
+ancestor of the target raises `TypeError`, and a malformed `parameters:`, a malformed `source_location:`
+or an uncallable `via:` raises `ArgumentError`, all *before* the target is touched. A `source_location:`
+is malformed unless it is a `[String, Integer]` pair whose line `eval` will take. A rejected fabrication
+leaves the target exactly as it was. A hand-written `parameters:` never passed Ruby's parser, so it is
+compiled before the first mutation: a shape whose *combination* is illegal (two rests, a duplicate
+keyword) is an `ArgumentError` too. Nothing ever surfaces as a `SyntaxError` from inside `eval`, which a
+`rescue` would not catch.
 
 **A Ruby 3.4 wrinkle.** On 3.4 alone, a body written with the implicit `it` parameter receives its
-arguments packed into an Array when it is reached through `(name, ...)` forwarding, `send`, or a splat —
-the shape an interceptor is usually written in. Candor's own generated call sites name every
-argument, so direct-forward mode is unaffected; fixed in Ruby 4.0, and `_1` and named parameters never
+arguments packed into an Array when it is reached through `(name, ...)` forwarding, `send`, or a splat,
+which is the shape an interceptor is usually written in. Candor's own generated call sites name every
+argument, so direct-forward mode is unaffected. Ruby 4.0 fixes it, and `_1` and named parameters never
 had it.
 
 **Re-fabrication.** Redefining a name overwrites candor's own prior wrapper and body in place, so a
@@ -168,23 +183,25 @@ optional-argument rows carry a few percent of noise.
 | three optional keywords | 251 ns · 1 alloc | 99 ns · 0 | 46 ns · 0 | 185 ns · 2 |
 
 - **hand-written wrapper** is the ceiling: a real `def` with the same signature forwarding to the same
-  private body, with the defaults hard-coded — what you would write by hand if you knew the shape *and*
-  the default expressions. Candor is within ~10–40% of it, and allocates the same nothing.
+  private body, with the defaults hard-coded. It is what you would write by hand if you knew the shape
+  *and* the default expressions. Candor is within ~10–40% of it, and allocates the same nothing.
 - **bare method** is a single `def` doing the work inline. It is roughly twice as fast as any wrapper,
   because it is one method call rather than two. That is the price of wrapping at all, not of candor.
 - **variadic wrapper** is the `|*args, **kwargs, &block|` retreat: slower than candor on every shape
   below the keyword branch limit, faster on the hashed one, and dishonest about its signature everywhere.
 
-Definition time is ~40 µs per fabricated method — one `eval` — against ~1.3 µs for a bare
+Definition time is ~40 µs per fabricated method (one `eval`) against ~1.3 µs for a bare
 `define_method`. It runs once, at boot.
 
 ## What it is not
 
 Candor routes calls. It does not rescue, memoize, delegate or instrument; it is the method-fabrication
-layer those features stand on. It does not recover an optional's default expression — that is
+layer those features stand on. It does not recover an optional's default expression; that is
 [permanently closed upstream](https://bugs.ruby-lang.org/issues/8629), and dropping the unpassed optional
-so the body defaults is the semantics that replaces it. Fabricated methods are not Ractor-shareable, and
-the gem needs `eval`, so it does not run on eval-restricted platforms.
+so the body defaults is the semantics that replaces it.
+
+Definition must happen on the main Ractor. Calling a fabricated method from a non-main Ractor raises, as
+it does for any `define_method`-installed `Proc`, unless both the dispatch and the body are shareable.
 
 ## Contributing
 

data/lib/candor/definer.rb

@@ -12,8 +12,8 @@ module Candor
   #
   # @api private
   class Definer
-    # The only bodies +define_method+ accepts. A +#call+ object is not one of them, and converting it
-    # would forge a +source_location+ nobody wrote.
+    # The only bodies +define_method+ accepts. A +#call+ object is not one of them, and no
+    # +source_location:+ rescues it: the refusal is about the kind, not the location.
     BODY_KINDS = [Proc, Method, UnboundMethod].freeze
 
     # @param target [Module] the module the method is installed onto
@@ -21,13 +21,15 @@ module Candor
     # @param aliases [Array<Symbol>] further names sharing the one dispatch
     # @param via [Symbol, nil] an interceptor method on +target+, resolved per call
     # @param parameters [Array<Array>, nil] an explicit shape, overriding the body's
+    # @param source_location [Array(String, Integer), nil] a location, overriding the body's
     # @param body [Proc, Method, UnboundMethod]
-    def initialize(target, name, aliases:, via:, parameters:, body:)
+    def initialize(target, name, aliases:, via:, parameters:, source_location:, body:)
       @target = target
       @canonical = name.to_sym
       @names = [@canonical, *aliases.map(&:to_sym)].uniq
       @via = via
       @parameters = parameters
+      @source_location = source_location
       @body = body
       @body_name = Candor.body_name(@canonical)
     end
@@ -56,6 +58,7 @@ module Candor
       raise TypeError, "target must be a Module, got #{@target.inspect}" unless @target.is_a?(Module)
 
       validate_body!
+      validate_location!
       validate_names!
       # Both call-site names are interpolated into `eval`'d source. Without `via` the body's own name is
       # the call site, so the canonical name has to survive being one.
@@ -64,20 +67,37 @@ module Candor
       raise FrozenError.new("can't fabricate a method on frozen #{@target}", receiver: @target) if @target.frozen?
     end
 
-    # +source_location+ is the one reliable discriminator: Ruby exposes no +curried?+ predicate, and a
-    # curried proc, a symbol-to-proc and a C-defined method all report +nil+. R5 cannot be honoured for
-    # any of them, and honouring R5 is the product.
-    #
     # @return [void]
     # @raise [TypeError]
     def validate_body!
-      raise TypeError, body_error unless BODY_KINDS.any? { |kind| @body.is_a?(kind) }
-      raise TypeError, body_error if @body.source_location.nil?
+      raise TypeError, kind_error unless BODY_KINDS.any? { |kind| @body.is_a?(kind) }
       return unless @body.is_a?(Method) || @body.is_a?(UnboundMethod)
       # `define_method` would raise this itself — after the prior wrapper was already removed.
       raise TypeError, "#{@body.owner} is not an ancestor of #{@target}" unless @target <= @body.owner
     end
 
+    # A body's +source_location+ is the one reliable discriminator: Ruby exposes no +curried?+ predicate,
+    # and a curried proc, a symbol-to-proc and a C-defined method all report +nil+. Honouring the body's
+    # location is the product, so a body carrying none is refused — unless the caller names one, which is
+    # the caller assuming responsibility for the honesty. A caller that *rewrites* a location has to be
+    # able to: a wrapper whose body is a proc literal the caller generated should point at what the user
+    # wrote, not at the generator.
+    #
+    # {Signature.compile} gates the location it is handed, but a shape read from the compiled body only
+    # reaches that gate once the body is installed. So an overridden location is gated here too, exactly
+    # as {Signature.method_name!} is: the compiler owns the rule, and the pipeline pays it early enough
+    # that a rejected fabrication still leaves the target untouched.
+    #
+    # @return [void]
+    # @raise [TypeError, ArgumentError]
+    def validate_location!
+      Signature.source_location!(@source_location) if @source_location
+      raise TypeError, no_location_error if location.nil?
+    end
+
+    # @return [Array(String, Integer), nil] the location the fabricated method will report
+    def location = @source_location || @body.source_location
+
     # @return [void]
     # @raise [ArgumentError]
     def validate_names!
@@ -88,9 +108,19 @@ module Candor
     end
 
     # @return [String]
-    def body_error
+    def kind_error
       "body must be a block, a Proc, a Method or an UnboundMethod with a source_location, " \
-        "got #{@body.inspect}; curried procs, `#call` objects and C-defined methods have none"
+        "got #{@body.inspect}; a `#call` object is none of them, and no source_location: rescues it"
+    end
+
+    # Separate from {kind_error} because the remedy differs. Only a body +define_method+ accepts reaches
+    # this, so naming a location really is the fix — where a +#call+ object is refused for its kind, and
+    # naming one buys it nothing.
+    #
+    # @return [String]
+    def no_location_error
+      "#{@body.inspect} carries no source_location: curried procs, symbol-to-procs and C-defined " \
+        "methods have none, so fabricating from one takes an explicit source_location:"
     end
 
     # +define_method+ replaces a method in place, so a re-fabrication is never observable as a missing
@@ -123,8 +153,7 @@ module Candor
     # @return [Proc] the dispatch lambda
     # @raise [ArgumentError] if the shape does not render to legal source
     def compile(shape)
-      Signature.compile(shape, name: @via ? @canonical : @body_name, via: @via,
-                               source_location: @body.source_location)
+      Signature.compile(shape, name: @via ? @canonical : @body_name, via: @via, source_location: location)
     end
 
     # @param dispatch [Proc]

data/lib/candor/signature.rb

@@ -70,12 +70,16 @@ module Candor
     # Names Ruby reserves for the numbered block parameters; +->(_1: 1) {}+ is a +SyntaxError+.
     NUMBERED_PARAMETERS = (1..9).map { |i| "_#{i}" }.freeze
 
+    # The line numbers +eval+ takes: its +lineno+ is a C +int+, and one outside this range is a
+    # +RangeError+ from inside {compile} rather than an +ArgumentError+ from its gate.
+    LINE_RANGE = (-(2**31))...(2**31)
+
     # How the source is spelled, and what the two name gates happen to be spelled as. A consumer builds
-    # against {compile}, {method_name!} and {parameters!} — which raise — not against the patterns and
-    # tables they are written in terms of. Only {KINDS} and {KEYWORD_BRANCH_LIMIT} name something a
-    # caller has to know to use the compiler, so only those two stay public.
+    # against {compile}, {method_name!}, {parameters!} and {source_location!} — which raise — not against
+    # the patterns and tables they are written in terms of. Only {KINDS} and {KEYWORD_BRANCH_LIMIT} name
+    # something a caller has to know to use the compiler, so only those two stay public.
     private_constant :RESERVED_WORDS, :NAMED_KINDS, :OPTIONAL_KINDS, :SUFFIXES, :DECLARATIONS,
-                     :METHOD_NAME, :KEYWORD_NAME, :NUMBERED_PARAMETERS
+                     :METHOD_NAME, :KEYWORD_NAME, :NUMBERED_PARAMETERS, :LINE_RANGE
 
     class << self
       # +eval+'s file and line forge the lambda's — and therefore the compiled method's —
@@ -87,9 +91,10 @@ module Candor
       # @param source_location [Array(String, Integer)] the body's
       # @param via [Symbol, nil] an interceptor method taking +(name, ...)+; omit to call +name+ directly
       # @return [Proc] a lambda taking the body's parameter kinds and forwarding to the call site
-      # @raise [ArgumentError] if the call site's name or the parameter shape is malformed
+      # @raise [ArgumentError] if the call site's name, the parameter shape or the location is malformed
       def compile(parameters, name:, source_location:, via: nil)
-        eval(render(parameters, name: name, via: via), binding, *source_location) # rubocop:disable Security/Eval
+        source = render(parameters, name: name, via: via)
+        eval(source, binding, *source_location!(source_location)) # rubocop:disable Security/Eval
       rescue SyntaxError => e
         # {parameters!} sees one entry at a time; only the parser sees the combination — two rests, a
         # duplicate keyword, a block before a positional. A +SyntaxError+ is a +ScriptError+, which a
@@ -139,6 +144,23 @@ module Candor
         parameters
       end
 
+      # Unlike the two gates above, the location is never interpolated into the generated source: +eval+
+      # takes it as a file and a line, not as code. So this is a shape check rather than a trust boundary
+      # — with one edge that bites. +eval+'s line is a C +int+, and one outside {LINE_RANGE} raises
+      # +RangeError+ from inside {compile}. A consumer reading a shape off an already-installed body only
+      # reaches that compile after installing it, so the range is checked here, where it is still cheap.
+      #
+      # @param source_location [Array(String, Integer)]
+      # @return [Array(String, Integer)] the location
+      # @raise [ArgumentError] unless it is a [String, Integer] pair whose line +eval+ will take
+      def source_location!(source_location)
+        file, line = source_location if source_location.is_a?(Array) && source_location.size == 2
+        return source_location if file.is_a?(String) && line.is_a?(Integer) && LINE_RANGE.cover?(line)
+
+        raise ArgumentError, "malformed source_location: #{source_location.inspect}; " \
+                             "expected a [String, Integer] pair, the line within #{LINE_RANGE}"
+      end
+
       private
 
       # @param entry [Object]

data/lib/candor/version.rb

@@ -2,5 +2,5 @@
 
 module Candor
   # The gem version.
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/candor.rb

@@ -40,17 +40,21 @@ module Candor
     # @param via [Symbol, nil] an interceptor method on +target+, resolved per call
     # @param parameters [Array<Array>, nil] an explicit shape advertised instead of the body's; not
     #   validated against the body, so a mismatch surfaces as the body's own +ArgumentError+
+    # @param source_location [Array(String, Integer), nil] a location reported instead of the body's, for
+    #   a caller whose body is a proc it generated on the user's behalf; also the only way to fabricate
+    #   from a body carrying no location of its own
     # @param body [Proc, Method, UnboundMethod, nil] the body, when it is not given as a block
     # @yield the body, when it is not given as +body+; +self+ inside it is the receiver
     # @return [Symbol] the canonical name
     # @raise [TypeError] if +target+ is not a Module, or the body is neither a block, a Proc, a Method
-    #   nor an UnboundMethod, or its +source_location+ is +nil+, or its owner is not an ancestor of
-    #   +target+
+    #   nor an UnboundMethod, or neither it nor +source_location+ carries a location, or the body's owner
+    #   is not an ancestor of +target+
     # @raise [ArgumentError] if a name starts with {BODY_PREFIX}, or +via+ is not a callable method
-    #   name, or +parameters+ is malformed
+    #   name, or +parameters+ or +source_location+ is malformed
     # @raise [FrozenError] if +target+ is frozen
-    def define(target, name, aliases: [], via: nil, parameters: nil, body: nil, &block)
-      Definer.new(target, name, aliases: aliases, via: via, parameters: parameters, body: body || block).call
+    def define(target, name, aliases: [], via: nil, parameters: nil, source_location: nil, body: nil, &block)
+      Definer.new(target, name, aliases: aliases, via: via, parameters: parameters,
+                                source_location: source_location, body: body || block).call
     end
 
     # The private method holding a fabricated method's body. An interceptor calls it with +send+.

data/sig/candor/signature.rbs

@@ -15,6 +15,7 @@ module Candor
     def self.render: (Array[parameter] parameters, name: Symbol, ?via: Symbol?) -> String
     def self.method_name!: (Symbol | String name) -> Symbol
     def self.parameters!: (untyped parameters) -> Array[parameter]
+    def self.source_location!: (untyped source_location) -> [ String, Integer ]
 
     def initialize: (Array[parameter] parameters, Symbol name, ?Symbol? via) -> void
     def source: () -> String

data/sig/candor.rbs

@@ -21,6 +21,7 @@ module Candor
     ?aliases: Array[Symbol],
     ?via: Symbol?,
     ?parameters: Array[Signature::parameter]?,
+    ?source_location: [ String, Integer ]?,
     ?body: body?
   ) ?{ (?) -> untyped } -> Symbol
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: candor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Leonid Svyatov