Question about instances

[zherczeg]

I am trying to implement a component text/binary parser, and a lot of things are confusing for me. These are validated examples.

(component $C
  (type s32)
  (instance (export "inline" (type 0)))
)

What kind of component does the instance create? $C?

(component
  (type (component
    (import "x" (instance $I (export "f" (func))))
    (alias export $I "f" (func))
  ))
)

For me a type should contain only types or some descriptors, but it seems any mutable objects can be added a to (non-mutable?) type.

The most confusing part is how instances are connected? E.g. the (func (param "X" (list (list s32)))) is the import and export of two components, and the import side wants to call this function. What should happen? How this is represented in core module side? How the data is transferred?

[lukewagner]

What kind of component does the instance create?

The type of that instance in $C would be:

(instance
  (type $t s32)
  (export "inline" (type (eq $t)))
)

For me a type should contain only types or some descriptors, but it seems any mutable objects can be added a to (non-mutable?) type.

Ah, I'm guessing you're commenting on the alias declarator (alias export $I "f" (func)), particularly on the func. Yes agreed that is confusing and indeed Binary.md contains a bullet:

• Validation of instancedecl (currently) only allows the type and instance sorts in alias declarators.

@alexcrichton this second snippet in the OP currently validates in wasm-tools; is that a bug or am I missing something here?

In any case, while that alias declarator binds a new funcidx, I don't think there's anything you can subsequently do with that funcidx (to make it show up in an import/export declarator), so I think it's effectively "dead code" atm, unless, again, I'm confused about something. So great question here and thanks for asking!

What should happen? How this is represented in core module side? How the data is transferred?

For this, let me point you to the Canonical Definitions section of the explainer. Specifically, the exporting component will canon lift a core function into a component-typed function and the importing component will canon lower the imported component-typed function to produce a new core function that can be imported and called by core wasm.

[alexcrichton]

is that a bug or am I missing something here?

That looks like a bug yeah, good catch @zherczeg! I'll try to dig in and see what's going on today.

[syntactically]

(component $C
  (type s32)
  (instance (export "inline" (type 0)))
)

Just in case it's helpful, I started writing a little more detail on this one before Luke responded above. Here we are:

• Defining a concrete component, which we can refer to as $C later and in its body if necessary
• Creating an entry in the type index space of that component, which contains s32
• Creating an entry in the instance index space which contains an instance which exports a type, the exported type being equal to s32.

We have not imported or exported anything from the overall component yet, so if you were to instantiate the component $C, it would create this instance, but nothing particularly interesting would happen. The component's type is (component), or, as written in the formalism $\{\} \to \{\}$, because it has no imports or exports.

You could add something like (export "i" (instance 0)) to the example component. Then, C would export the instance it had just defined, and you would get something like (component (export "i" (instance (export "inline" (type (eq s32)))))) (or, after elaboration, in the formal syntax, something like, $\exists (\tau : (\mathrm{eq}\ s32)). \{\} \to \{ \mathrm{i} : \{ \mathrm{inline} : \tau \} \}$.

(component
  (type (component
    (import "x" (instance $I (export "f" (func))))
    (alias export $I "f" (func))
  ))
)

I agree with you a little bit that the syntax here is a little confusing! As Luke mentioned, I don't think that this has meaning with func as that sort. The reason why we can generally have instances (which are also stateful) in these alias declarators is that it gives us a surface syntax consistent with the rest of the syntax to get at the exported types inside of those instances (which are per-instance, due to generativity), like ensuring that a type that a component exports is the same as one that it imports. Concretely:

(type (component
  (import "x" (instance $I (export "y" (instance (export "t" (type (sub resource)))))))
  (alias export $I "y" (instance $J))
  (alias export $J "t" (type $t))
  (export "z" (instance (export "u" (type (eq $t)))))))

The type here elaborates to something like $\forall (\tau : (\mathrm{sub\ resource})). \{ \mathrm{x} : \{ \mathrm{y} : \{ \mathrm{t} : \tau \} \} \} \to \{ \mathrm{z} : \{ \mathrm{u} : \tau \} \}$. I.e. "This component imports an instance, which itself exports an instance which exports a resource type. This component than exports an instance which exports the same resource type."

You may find this (rather out of date) Menhir parser for the text format from an old draft of the reference interpreter to be a useful reference. There will be a newer reference interpreter sometime soon.

[zherczeg]

Thank you for the explanations!

Creating an entry in the instance index space which contains an instance which exports a type, the exported type being equal to s32.

So the point of these inlined instances is exporting something form their owner component without creating another (helper) component, isn't it? These instances don't have a real source component, only contains a list of (mutable) exports.

How can I declare version suffixes? The explainer says: versionsuffix ::= (versionsuffix "<semversuffix>") but I got a parse error for this:

(component
  (type s32)
  (export "any" (versionsuffix "1.0.0") (type 0))
)

[alexcrichton]

These instances don't have a real source component, only contains a list of (mutable) exports.

Correct, yeah.

How can I declare version suffixes?

I beileve that's not implemented in wasm-tools just yet, which would explain the parse error (assuming that's what you're using)