Emit range-based arity check throwing ArgumentsRangeMismatch

[tsapeta]

Why

The synthesized @JS function binding validated arity with an exact arguments.count == <total> guard and threw an ad-hoc Exception(name: "InvalidArgumentCount", ...). That over-rejects an omitted trailing optional, ignores author-written default values, and isn't a typed exception. A function with trailing defaulted or optional parameters accepts a range of arities, not one exact count.

Paired with expo/expo#46901, which adds the public Exceptions.ArgumentsRangeMismatch exception this generated code throws. The two must land together: the code emitted here references that core exception.

How

In DecorateModuleBuilder, compute required (total minus the trailing run of parameters that have a default value or an optional type) and max (total). Emit an exact guard when required == max, otherwise guard arguments.count >= required && arguments.count <= max, both throwing Exceptions.ArgumentsRangeMismatch.

When the trailing run is non-empty, decode the required prefix once and switch on arguments.count:

• an omitted defaulted parameter drops its label from the call so Swift applies the default;
• an omitted optional parameter is passed nil;
• a present slot decodes by its static type in the branch that has it (arguments[i] traps past count, so a slot the caller didn't pass is never indexed).

Also shared isOptionalType via MacroHelpers (removing the private copy in RecordMacro).

Example

A function with a trailing defaulted parameter:

@ExpoModule
final class MyModule: Module {
  @JS
  func resize(width: Int, height: Int = 100) -> Bool { true }
}

now generates a range guard and a per-arity call:

public func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws {
  object.setProperty("resize") { [self] this, arguments in
    guard arguments.count >= 1 && arguments.count <= 2 else {
      throw Exceptions.ArgumentsRangeMismatch((functionName: "resize", received: arguments.count, required: 1, maximum: 2))
    }
    let arg0 = try arguments.unownedValue(at: 0).asInt()
    let result = switch arguments.count {
    case 1:
      self.resize(width: arg0)
    default:
      let arg1 = try arguments.unownedValue(at: 1).asInt()
      self.resize(width: arg0, height: arg1)
    }
    return result.toJavaScriptValue(in: runtime)
  }
}

When every parameter is required the guard collapses to an exact arguments.count == <total> check and the body is a flat decode-then-call (no switch).

Test Plan

swift test, 86 passing, including new expansion cases:

• trailing defaulted parameter (range guard + per-arity switch);
• trailing optional parameter (nil when omitted, Void return path);
• all-omittable signature (required == 0).

Existing exact-arity expectations were updated to the new exception form.