Rust generate! not deduping interface type with same name as interface

[guybedford]

I was just updating wasi-virt to the lateset WIT definition for terminal:

interface terminal-input {
    /// The input side of a terminal.
    ///
    /// This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
    type terminal-input = u32

    // In the future, this may include functions for disabling echoing,
    // disabling input buffering so that keyboard events are sent through
    // immediately, querying supported features, and so on.

    /// Dispose of the specified terminal-input after which it may no longer
    /// be used.
    drop-terminal-input: func(this: terminal-input)
}

When I use the generate! macro, I get the following type generated:

use crate::exports::wasi::cli::terminal_input::TerminalInput;

where the above is a u32 type and not a trait that can be implemented as expected.

It seems like the interface name and type alias name having the same name is not being deduped properly, when it should probably be a separate crate::exports::wasi::cli::terminal_input::TerminalInput::Terminalnput type I think?

[guybedford]

Ah as far as I can tell, this just is the naming scheme, that the trait has the name of the interface, while all the other types are in a flat shared namespace.

Therefore this means:

• Special casing the trait somehow by default
• Detecting a name clash and handling it specially
• Ban this case entirely and refactor away from sharing the name of a type with its own interface?

Calling everything TerminalInputTrait etc might be a lot though for sure.

[peterhuene]

Indeed the generated code has:

pub type TerminalInput = u32;
pub trait TerminalInput {
    fn drop_terminal_input(this: TerminalInput);
}

which is a redefinition and errors.

Perhaps we should generate a submodule of the interface module to put its types in, e.g.:

pub mod types {
    pub type TerminalInput = u32;
}
pub trait TerminalInput {
    fn drop_terminal_input(this: types::TerminalInput);
}

[guybedford]

That seems like a sensible solution to me.

[pchickey]

Rather than move the datatypes a level down in the module tree, what if the trait was moved a level up?

pub mod cli {
    ...
    pub mod terminal_input {
        pub type TerminalInput = u32;
    }
    pub trait TerminalInput {
        fn drop_terminal_input(this: terminal_input::TerminalInput);
    }
}

[peterhuene]

I think that makes even more sense and can't, on the surface at least, think of a reason that wouldn't work.

[alexcrichton]

Looking into fixing this, there's also the issue of:

world foo {
  record foo {
  }

  export x: func() -> foo
}

generating:

pub struct Foo {
}
// ...
pub trait Foo {
  fn x() -> Foo;
}

which is all at the root level preventing lifting things up a bit.

I might take a leaf out of Wasmtime's book where Wasmtime always generates a trait called "Host" so I might do the same here and always generate a trait called "Guest" and then treat type guest = u32 in WIT as something like type Guest_ = u32 in Rust.

How's that sound to y'all?

[guybedford]

I wonder if top-level namespacing could be an approach here?

use crate::worlds::wasi::cli::Foo;

Edit: (hit send too quickly) Using guest seems fine to me though too.