bug - Decorator and imported const str arguments are not materialized as str call arguments

[dannymeijer]

Thanks for reporting! Please include a minimal reproduction when possible.

Area

• Compiler (frontend/backend/codegen)

Summary

Expected: an imported pub const TOKEN: str = "token" should be usable anywhere a str argument is accepted, matching same-file constants and string literals. If authors explicitly call TOKEN.to_string(), codegen should emit stable Rust that materializes an owned string on the supported toolchain.

Actual: the typechecker accepts both shapes, but generated Rust fails to compile after module import:

• identity(TOKEN) emits a call where the callee expects String and the imported constant is still &str.
• identity(TOKEN.to_string()) emits TOKEN.as_str().to_string(), which hits unstable Rust str_as_str on the current nightly.

This surfaced while implementing InQL RFC 014 function registry decorators. The InQL workaround is to use String.from(TOKEN) at decorator/test call sites, but that should not be required for ordinary imported str constants.

Reproduction steps

1. Create src/registry.incn:

"""Tiny module exporting one public string constant."""

pub const TOKEN: str = "token"

2. Create tests/test_imported_const_str_argument.incn:

"""Minimal repro for imported public const `str` call-argument materialization."""

from registry import TOKEN


def identity(value: str) -> str:
    """Return the provided string value."""
    return value


def test_imported_const_str_argument_materializes() -> None:
    """Passing an imported const str to a str parameter should compile and preserve the value."""
    assert identity(TOKEN) == "token", "imported const str should be accepted as a str argument"

3. Create tests/test_imported_const_str_to_string.incn:

"""Minimal repro for `to_string()` on imported public const `str` call arguments."""

from registry import TOKEN


def identity(value: str) -> str:
    """Return the provided string value."""
    return value


def test_imported_const_str_to_string_materializes() -> None:
    """Calling `to_string()` on an imported const str should compile on the supported Rust toolchain."""
    assert identity(TOKEN.to_string()) == "token", "imported const str to_string should materialize an owned string"

4. Run:

incan test tests

Output / logs

Direct imported const argument:

error[E0308]: mismatched types
  --> src/lib.rs:14:18
   |
14 |     if (identity(TOKEN)) != ("token") {
   |         -------- ^^^^^ expected `String`, found `&str`
   |         |
   |         arguments to this function are incorrect
   |
note: function defined here
  --> src/lib.rs:8:4
   |
 8 | fn identity(value: String) -> String {
   |    ^^^^^^^^ -------------
help: try using a conversion method
   |
14 |     if (identity(TOKEN.to_string())) != ("token") {
   |                       ++++++++++++

Explicit .to_string() workaround:

error[E0658]: use of unstable library feature `str_as_str`
  --> src/lib.rs:14:24
   |
14 |     if (identity(TOKEN.as_str().to_string())) != ("token") {
   |                        ^^^^^^
   |
   = note: see issue #130366 <https://github.com/rust-lang/rust/issues/130366> for more information

Environment

OS: macOS
Rust: rustc 1.96.0-nightly (362211dc2 2026-03-24)
Incan: 0.3.0-rc7 candidate, observed on commit 3fc6ea7f from PR #637
Command: incan test tests

Blocking status / workaround

Non-blocking for InQL RFC 014. A valid workaround is to materialize imported string constants with String.from(TOKEN) at the call site. That preserves semantics, but it is noisy and should not be required for normal str argument passing.

[dannymeijer]

Additional minimized shape from the InQL RFC 014 implementation: decorator-factory calls have the same materialization problem even with a string literal argument, so @registered("probe.value") expands to generated Rust that calls registered("probe.value") where registered expects String.

Minimal repro:

"""Probe string literal materialization in decorator factory calls."""


def keep_int(func: (int) -> int) -> (int) -> int:
    """Return the decorated function unchanged."""
    return func


def registered(_name: str) -> Callable[(int) -> int, (int) -> int]:
    """Return one identity decorator."""
    return keep_int


@registered("probe.value")
def increment(value: int) -> int:
    """Increment one integer."""
    return value + 1


def test_decorator_literal_argument_materializes() -> None:
    """Assert a decorator literal argument is materialized for a str parameter."""
    assert increment(1) == 2, "decorated function should preserve behavior"

Observed generated Rust failure:

error[E0308]: mismatched types
  --> src/lib.rs:...
   |
   |     registered("probe.value")(__incan_original_increment),
   |                ^^^^^^^^^^^^^ expected `String`, found `&str`

Impact for InQL: the compiling workaround is String.from(...), but API metadata currently treats that decorator argument as an unsupported expression rather than a literal or const reference. That means InQL can verify decorated helper signatures with PR #637, but cannot yet rely on checked API metadata to recover stable function refs from decorator arguments until this materialization/codegen issue is fixed.

[dannymeijer]

Verified PR #639 against InQL RFC 014. The ordinary imported pub const TOKEN: str call-site repro now passes, and same-file/local decorator factory string arguments pass too. The remaining failing shape is narrower: both the decorator factory and the pub const str argument are imported from the same module.

Minimal repro:

# src/registry.incn
"""Tiny module exporting a public decorator factory and public string constant."""

pub const TOKEN: str = "probe.value"


def keep_int(func: (int) -> int) -> (int) -> int:
    """Return the decorated function unchanged."""
    return func


pub def registered(_name: str) -> Callable[(int) -> int, (int) -> int]:
    """Return one identity decorator."""
    return keep_int

# tests/test_decorator_imported_factory_const_str_argument.incn
"""Minimal repro for imported decorator factory and imported const string argument materialization."""

from registry import TOKEN, registered


@registered(TOKEN)
def increment(value: int) -> int:
    """Increment one integer through an imported decorator and imported const."""
    return value + 1


def test_decorator_imported_factory_const_str_argument_materializes() -> None:
    """Assert imported decorator factory string arguments materialize as owned strings."""
    assert increment(1) == 2, "imported decorator should preserve behavior"

Command:

incan test tests

Observed on PR #639 head:

error[E0308]: mismatched types
  --> src/lib.rs:40:16
   |
40 |     registered(TOKEN)(__incan_original_increment),
   |     ---------- ^^^^^ expected `String`, found `&str`
   |     |
   |     arguments to this function are incorrect

This is the exact shape InQL RFC 014 hits with from function_registry import REGISTER_FN, FUNCTION_REF and @REGISTER_FN(FUNCTION_REF). The compile-safe InQL workaround remains String.from(FUNCTION_REF), but then checked API metadata cannot recover the decorator argument as a const reference.