rigortype 0.3.8 → 0.4.0

data/docs/handbook/04-tuples-and-shapes.md

@@ -184,23 +184,25 @@ final = { **defaults, **overrides }
 ## Pattern matching destructuring
 
 `case x in [a, b, c]` narrows `a` / `b` / `c` per-position
-exactly like multiple-assignment:
+exactly like multiple-assignment: the pattern binds against the
+subject's type, so a tuple subject hands each slot its element and
+an `Array[T]` subject hands each slot `T`.
 
 ```ruby
 case [10, 20, 30]
 in [first, _, third]
-  assert_type("Dynamic[top]", first)   # pattern bindings are not constant-folded
-  assert_type("Dynamic[top]", third)
+  assert_type("10", first)
+  assert_type("30", third)
 end
 ```
 
-Hash patterns work the same way:
+Hash patterns read the subject's own `deconstruct_keys` projection:
 
 ```ruby
 case { name: "Alice", age: 30 }
 in { name:, age: }
-  assert_type("Dynamic[top]", name)   # pattern bindings are not constant-folded
-  assert_type("Dynamic[top]", age)
+  assert_type("\"Alice\"", name)
+  assert_type("30", age)
 end
 ```
 

data/docs/handbook/05-methods-and-blocks.md

@@ -21,7 +21,7 @@ first one that produces a result:
 2. **Shape dispatch.** The receiver carries a `Tuple` /
    `HashShape` / `IntegerRange` / refinement and the method
    has a per-shape rule. `Tuple[A, B, C].size` →
-   `Constant<3>`; `int<0, max>.zero?` → `Constant<true> |
+   `Constant<3>`; `Integer[0..].zero?` → `Constant<true> |
    Constant<false>`.
 3. **RBS dispatch.** The class has an RBS sig for the method.
    Argument types are checked against the parameter contract

data/docs/handbook/06-classes.md

@@ -113,11 +113,11 @@ class Counter
   end
 
   def bump
-    @count += 1   # @count rebound to int<1, max>
+    @count += 1   # @count rebound to Integer[1..]
   end
 
   def value
-    @count        # int<0, max>  (union of seen writes)
+    @count        # Integer[0..]  (union of seen writes)
   end
 end
 ```

data/docs/handbook/07-rbs-and-extended.md

@@ -128,7 +128,8 @@ A short reference:
 | Family | Names |
 | --- | --- |
 | Empty / non-empty | `non-empty-string`, `non-empty-array[T]`, `non-empty-hash[K, V]` |
-| Integer ranges | `positive-int`, `non-negative-int`, `negative-int`, `non-positive-int`, `non-zero-int`, `int<min, max>` |
+| Integer ranges | `positive-int`, `non-negative-int`, `negative-int`, `non-positive-int`, `non-zero-int`, `Integer[min..max]` |
+| Float ranges | `Float[0.0..1.0]`, `Float[0.0...1.0]`, `Float[0.0..]`, `non-nan-float`, `finite-float` |
 | String predicates | `lowercase-string`, `uppercase-string`, `numeric-string`, `decimal-int-string`, `octal-int-string`, `hex-int-string`, `literal-string` |
 | Paired complements | `non-lowercase-string`, `non-uppercase-string`, `non-numeric-string` |
 | Composed | `non-empty-lowercase-string`, `non-empty-uppercase-string`, `non-empty-literal-string` |
@@ -465,6 +466,23 @@ Notes:
   `source-rbs-synthesis-failed` `:info` diagnostic; the file
   falls back to no inline-RBS contribution and analysis
   continues.
+- When a method is declared **both** in `sig/` and by an
+  inline annotation, Rigor compares the two and one of them
+  binds. If one refines the other — `Symbol` in `sig/`,
+  `:asc | :desc` inline — the more precise one binds and
+  nothing is reported; `untyped` and `void` are consistent
+  with anything. If they contradict — a `String` parameter
+  against an `Integer` one — the `.rbs` binds and the run
+  reports `rbs.contradicting-signature`, an error, at the
+  `sig/` line: usually a stale generated signature. If Rigor
+  cannot tell, the `.rbs` binds and the dropped inline
+  signature is reported as a `source-rbs-annotation-not-honoured`
+  `:info` naming both files. Only the overlapping member is
+  affected; every other annotation in the file still binds,
+  and the class keeps its method surface. rbs and Steep merge
+  the two sources without ranking them, so left to collide
+  they fail the class's definition build and every call on it
+  — real methods and typos alike — reads `Dynamic[top]`.
 
 Full plugin documentation, configuration options (including
 the `require_magic_comment: false` host-context override the

data/docs/handbook/10-sorbet.md

@@ -277,8 +277,9 @@ warnings until the engine's case narrowing improves.
 
 ## Tier ordering — what wins on conflict
 
-When a method has both a Sorbet `sig` and an RBS sig, RBS
-wins. Sorbet sigs sit at Rigor's plugin tier:
+When a method has both a Sorbet `sig` and an RBS sig, the
+Sorbet `sig` types the call site. Sorbet sigs sit at Rigor's
+plugin tier, which answers before RBS dispatch:
 
 1. **Precision tiers** — constant fold, shape dispatch,
    block fold, etc.
@@ -289,14 +290,12 @@ wins. Sorbet sigs sit at Rigor's plugin tier:
 4. **Dependency-source inference** (ADR-10's opt-in walker).
 5. **User-class fallback** (`Object` / `Class` ancestors).
 
-The contribution merger (a v0.1.0 substrate documented in
-[`docs/internal-spec/flow-contribution-merger.md`](../internal-spec/flow-contribution-merger.md))
-keeps RBS authoritative on conflict — the Sorbet sig is
-allowed to refine but not contradict it. Users who want
-their Sorbet sig to override should remove the conflicting
-RBS, not the other way around. The reverse direction
-(Sorbet wins) would let third-party-DSL annotations
-override authored RBS, which inverts the trust model.
+A plugin's return type replaces the RBS return with no
+diagnostic ([ADR-2](../adr/2-extension-api.md) § "Amendment
+2026-09-26"), so where the two sigs disagree, callers see the
+Sorbet return. The RBS still binds the method's body, which
+is checked against the declared return. Keep the two
+signatures in agreement; remove the one you no longer mean.
 
 ## Migration patterns