Revision control
Copy as Markdown
Other Tools
use crate::component::*;
use crate::core::{self, ValType};
use crate::kw;
use crate::names::Namespace;
use crate::token::Span;
use crate::token::{Id, Index};
use crate::Error;
/// Resolve the fields of a component and everything nested within it, changing
/// `Index::Id` to `Index::Num` and expanding alias syntax sugar.
pub fn resolve(component: &mut Component<'_>) -> Result<(), Error> {
let fields = match &mut component.kind {
ComponentKind::Text(fields) => fields,
ComponentKind::Binary(_) => return Ok(()),
};
let mut resolver = Resolver::default();
resolver.fields(component.id, fields)
}
impl<'a> From<Alias<'a>> for ComponentField<'a> {
fn from(a: Alias<'a>) -> Self {
Self::Alias(a)
}
}
impl<'a> From<Alias<'a>> for ModuleTypeDecl<'a> {
fn from(a: Alias<'a>) -> Self {
Self::Alias(a)
}
}
impl<'a> From<Alias<'a>> for ComponentTypeDecl<'a> {
fn from(a: Alias<'a>) -> Self {
Self::Alias(a)
}
}
impl<'a> From<Alias<'a>> for InstanceTypeDecl<'a> {
fn from(a: Alias<'a>) -> Self {
Self::Alias(a)
}
}
#[derive(Default)]
struct Resolver<'a> {
stack: Vec<ComponentState<'a>>,
// When a name refers to a definition in an outer scope, we'll need to
// insert an outer alias before it. This collects the aliases to be
// inserted during resolution.
aliases_to_insert: Vec<Alias<'a>>,
}
/// Context structure used to perform name resolution.
#[derive(Default)]
struct ComponentState<'a> {
id: Option<Id<'a>>,
// Namespaces within each component. Note that each namespace carries
// with it information about the signature of the item in that namespace.
// The signature is later used to synthesize the type of a component and
// inject type annotations if necessary.
core_funcs: Namespace<'a>,
core_globals: Namespace<'a>,
core_tables: Namespace<'a>,
core_memories: Namespace<'a>,
core_types: Namespace<'a>,
core_tags: Namespace<'a>,
core_instances: Namespace<'a>,
core_modules: Namespace<'a>,
funcs: Namespace<'a>,
types: Namespace<'a>,
instances: Namespace<'a>,
components: Namespace<'a>,
values: Namespace<'a>,
}
impl<'a> ComponentState<'a> {
fn new(id: Option<Id<'a>>) -> ComponentState<'a> {
ComponentState {
id,
..ComponentState::default()
}
}
fn register_item_sig(&mut self, sig: &ItemSig<'a>) -> Result<u32, Error> {
match &sig.kind {
ItemSigKind::CoreModule(_) => self.core_modules.register(sig.id, "core module"),
ItemSigKind::Func(_) => self.funcs.register(sig.id, "func"),
ItemSigKind::Component(_) => self.components.register(sig.id, "component"),
ItemSigKind::Instance(_) => self.instances.register(sig.id, "instance"),
ItemSigKind::Value(_) => self.values.register(sig.id, "value"),
ItemSigKind::Type(_) => self.types.register(sig.id, "type"),
}
}
}
impl<'a> Resolver<'a> {
fn current(&mut self) -> &mut ComponentState<'a> {
self.stack
.last_mut()
.expect("should have at least one component state")
}
fn fields(
&mut self,
id: Option<Id<'a>>,
fields: &mut Vec<ComponentField<'a>>,
) -> Result<(), Error> {
self.stack.push(ComponentState::new(id));
self.resolve_prepending_aliases(fields, Resolver::field, ComponentState::register)?;
self.stack.pop();
Ok(())
}
fn resolve_prepending_aliases<T>(
&mut self,
fields: &mut Vec<T>,
resolve: fn(&mut Self, &mut T) -> Result<(), Error>,
register: fn(&mut ComponentState<'a>, &T) -> Result<(), Error>,
) -> Result<(), Error>
where
T: From<Alias<'a>>,
{
assert!(self.aliases_to_insert.is_empty());
// Iterate through the fields of the component. We use an index
// instead of an iterator because we'll be inserting aliases
// as we go.
let mut i = 0;
while i < fields.len() {
// Resolve names within the field.
resolve(self, &mut fields[i])?;
// Name resolution may have emitted some aliases. Insert them before
// the current definition.
let amt = self.aliases_to_insert.len();
fields.splice(i..i, self.aliases_to_insert.drain(..).map(T::from));
i += amt;
// Definitions can't refer to themselves or to definitions that appear
// later in the format. Now that we're done resolving this field,
// assign it an index for later definitions to refer to.
register(self.current(), &fields[i])?;
i += 1;
}
Ok(())
}
fn field(&mut self, field: &mut ComponentField<'a>) -> Result<(), Error> {
match field {
ComponentField::CoreModule(m) => self.core_module(m),
ComponentField::CoreInstance(i) => self.core_instance(i),
ComponentField::CoreType(t) => self.core_ty(t),
ComponentField::Component(c) => self.component(c),
ComponentField::Instance(i) => self.instance(i),
ComponentField::Alias(a) => self.alias(a),
ComponentField::Type(t) => self.ty(t),
ComponentField::CanonicalFunc(f) => self.canonical_func(f),
ComponentField::CoreFunc(_) => unreachable!("should be expanded already"),
ComponentField::Func(_) => unreachable!("should be expanded already"),
ComponentField::Start(s) => self.start(s),
ComponentField::Import(i) => self.item_sig(&mut i.item),
ComponentField::Export(e) => {
if let Some(ty) = &mut e.ty {
self.item_sig(&mut ty.0)?;
}
self.export(&mut e.kind)
}
ComponentField::Custom(_) | ComponentField::Producers(_) => Ok(()),
}
}
fn core_module(&mut self, module: &mut CoreModule) -> Result<(), Error> {
match &mut module.kind {
CoreModuleKind::Inline { fields } => {
crate::core::resolve::resolve(fields)?;
}
CoreModuleKind::Import { .. } => {
unreachable!("should be expanded already")
}
}
Ok(())
}
fn component(&mut self, component: &mut NestedComponent<'a>) -> Result<(), Error> {
match &mut component.kind {
NestedComponentKind::Import { .. } => unreachable!("should be expanded already"),
NestedComponentKind::Inline(fields) => self.fields(component.id, fields),
}
}
fn core_instance(&mut self, instance: &mut CoreInstance<'a>) -> Result<(), Error> {
match &mut instance.kind {
CoreInstanceKind::Instantiate { module, args } => {
self.component_item_ref(module)?;
for arg in args {
match &mut arg.kind {
CoreInstantiationArgKind::Instance(i) => {
self.core_item_ref(i)?;
}
CoreInstantiationArgKind::BundleOfExports(..) => {
unreachable!("should be expanded already");
}
}
}
}
CoreInstanceKind::BundleOfExports(exports) => {
for export in exports {
self.core_item_ref(&mut export.item)?;
}
}
}
Ok(())
}
fn instance(&mut self, instance: &mut Instance<'a>) -> Result<(), Error> {
match &mut instance.kind {
InstanceKind::Instantiate { component, args } => {
self.component_item_ref(component)?;
for arg in args {
match &mut arg.kind {
InstantiationArgKind::Item(e) => {
self.export(e)?;
}
InstantiationArgKind::BundleOfExports(..) => {
unreachable!("should be expanded already")
}
}
}
}
InstanceKind::BundleOfExports(exports) => {
for export in exports {
self.export(&mut export.kind)?;
}
}
InstanceKind::Import { .. } => {
unreachable!("should be expanded already")
}
}
Ok(())
}
fn item_sig(&mut self, item: &mut ItemSig<'a>) -> Result<(), Error> {
match &mut item.kind {
// Here we must be explicit otherwise the module type reference will
// be assumed to be in the component type namespace
ItemSigKind::CoreModule(t) => self.core_type_use(t),
ItemSigKind::Func(t) => self.component_type_use(t),
ItemSigKind::Component(t) => self.component_type_use(t),
ItemSigKind::Instance(t) => self.component_type_use(t),
ItemSigKind::Value(t) => self.component_val_type(&mut t.0),
ItemSigKind::Type(b) => match b {
TypeBounds::Eq(i) => self.resolve_ns(i, Ns::Type),
TypeBounds::SubResource => Ok(()),
},
}
}
fn export(&mut self, kind: &mut ComponentExportKind<'a>) -> Result<(), Error> {
match kind {
// Here we do *not* have to be explicit as the item ref is to a core module
ComponentExportKind::CoreModule(r) => self.component_item_ref(r),
ComponentExportKind::Func(r) => self.component_item_ref(r),
ComponentExportKind::Value(r) => self.component_item_ref(r),
ComponentExportKind::Type(r) => self.component_item_ref(r),
ComponentExportKind::Component(r) => self.component_item_ref(r),
ComponentExportKind::Instance(r) => self.component_item_ref(r),
}
}
fn start(&mut self, start: &mut Start<'a>) -> Result<(), Error> {
self.resolve_ns(&mut start.func, Ns::Func)?;
for arg in start.args.iter_mut() {
self.component_item_ref(arg)?;
}
Ok(())
}
fn outer_alias<T: Into<Ns>>(
&mut self,
outer: &mut Index<'a>,
index: &mut Index<'a>,
kind: T,
span: Span,
) -> Result<(), Error> {
// Short-circuit when both indices are already resolved as this
// helps to write tests for invalid modules where wasmparser should
// be the one returning the error.
if let Index::Num(..) = outer {
if let Index::Num(..) = index {
return Ok(());
}
}
// Resolve `outer`, and compute the depth at which to look up
// `index`.
let depth = match outer {
Index::Id(id) => {
let mut depth = 0;
for resolver in self.stack.iter().rev() {
if resolver.id == Some(*id) {
break;
}
depth += 1;
}
if depth as usize == self.stack.len() {
return Err(Error::new(
span,
format!("outer component `{}` not found", id.name()),
));
}
depth
}
Index::Num(n, _span) => *n,
};
if depth as usize >= self.stack.len() {
return Err(Error::new(
span,
format!("outer count of `{}` is too large", depth),
));
}
*outer = Index::Num(depth, span);
// Resolve `index` within the computed scope depth.
let computed = self.stack.len() - 1 - depth as usize;
self.stack[computed].resolve(kind.into(), index)?;
Ok(())
}
fn alias(&mut self, alias: &mut Alias<'a>) -> Result<(), Error> {
match &mut alias.target {
AliasTarget::Export {
instance,
name: _,
kind: _,
} => self.resolve_ns(instance, Ns::Instance),
AliasTarget::CoreExport {
instance,
name: _,
kind: _,
} => self.resolve_ns(instance, Ns::CoreInstance),
AliasTarget::Outer { outer, index, kind } => {
self.outer_alias(outer, index, *kind, alias.span)
}
}
}
fn canonical_func(&mut self, func: &mut CanonicalFunc<'a>) -> Result<(), Error> {
let opts = match &mut func.kind {
CanonicalFuncKind::Lift { ty, info } => {
self.component_type_use(ty)?;
self.core_item_ref(&mut info.func)?;
&mut info.opts
}
CanonicalFuncKind::Lower(info) => {
self.component_item_ref(&mut info.func)?;
&mut info.opts
}
CanonicalFuncKind::ResourceNew(info) => return self.resolve_ns(&mut info.ty, Ns::Type),
CanonicalFuncKind::ResourceRep(info) => return self.resolve_ns(&mut info.ty, Ns::Type),
CanonicalFuncKind::ResourceDrop(info) => {
return self.resolve_ns(&mut info.ty, Ns::Type)
}
};
for opt in opts {
match opt {
CanonOpt::StringUtf8 | CanonOpt::StringUtf16 | CanonOpt::StringLatin1Utf16 => {}
CanonOpt::Memory(r) => self.core_item_ref(r)?,
CanonOpt::Realloc(r) | CanonOpt::PostReturn(r) => self.core_item_ref(r)?,
}
}
Ok(())
}
fn core_type_use<T>(&mut self, ty: &mut CoreTypeUse<'a, T>) -> Result<(), Error> {
let item = match ty {
CoreTypeUse::Ref(r) => r,
CoreTypeUse::Inline(_) => {
unreachable!("inline type-use should be expanded by now")
}
};
self.core_item_ref(item)
}
fn component_type_use<T>(&mut self, ty: &mut ComponentTypeUse<'a, T>) -> Result<(), Error> {
let item = match ty {
ComponentTypeUse::Ref(r) => r,
ComponentTypeUse::Inline(_) => {
unreachable!("inline type-use should be expanded by now")
}
};
self.component_item_ref(item)
}
fn defined_type(&mut self, ty: &mut ComponentDefinedType<'a>) -> Result<(), Error> {
match ty {
ComponentDefinedType::Primitive(_) => {}
ComponentDefinedType::Flags(_) => {}
ComponentDefinedType::Enum(_) => {}
ComponentDefinedType::Record(r) => {
for field in r.fields.iter_mut() {
self.component_val_type(&mut field.ty)?;
}
}
ComponentDefinedType::Variant(v) => {
// Namespace for case identifier resolution
let mut ns = Namespace::default();
for case in v.cases.iter_mut() {
let index = ns.register(case.id, "variant case")?;
if let Some(ty) = &mut case.ty {
self.component_val_type(ty)?;
}
if let Some(refines) = &mut case.refines {
if let Refinement::Index(span, idx) = refines {
let resolved = ns.resolve(idx, "variant case")?;
if resolved == index {
return Err(Error::new(
*span,
"variant case cannot refine itself".to_string(),
));
}
*refines = Refinement::Resolved(resolved);
}
}
}
}
ComponentDefinedType::List(l) => {
self.component_val_type(&mut l.element)?;
}
ComponentDefinedType::Tuple(t) => {
for field in t.fields.iter_mut() {
self.component_val_type(field)?;
}
}
ComponentDefinedType::Option(o) => {
self.component_val_type(&mut o.element)?;
}
ComponentDefinedType::Result(r) => {
if let Some(ty) = &mut r.ok {
self.component_val_type(ty)?;
}
if let Some(ty) = &mut r.err {
self.component_val_type(ty)?;
}
}
ComponentDefinedType::Own(t) | ComponentDefinedType::Borrow(t) => {
self.resolve_ns(t, Ns::Type)?;
}
}
Ok(())
}
fn component_val_type(&mut self, ty: &mut ComponentValType<'a>) -> Result<(), Error> {
match ty {
ComponentValType::Ref(idx) => self.resolve_ns(idx, Ns::Type),
ComponentValType::Inline(ComponentDefinedType::Primitive(_)) => Ok(()),
ComponentValType::Inline(_) => unreachable!("should be expanded by now"),
}
}
fn core_ty(&mut self, field: &mut CoreType<'a>) -> Result<(), Error> {
match &mut field.def {
CoreTypeDef::Def(_) => {}
CoreTypeDef::Module(t) => {
self.stack.push(ComponentState::new(field.id));
self.module_type(t)?;
self.stack.pop();
}
}
Ok(())
}
fn ty(&mut self, field: &mut Type<'a>) -> Result<(), Error> {
match &mut field.def {
TypeDef::Defined(t) => {
self.defined_type(t)?;
}
TypeDef::Func(f) => {
for param in f.params.iter_mut() {
self.component_val_type(&mut param.ty)?;
}
for result in f.results.iter_mut() {
self.component_val_type(&mut result.ty)?;
}
}
TypeDef::Component(c) => {
self.stack.push(ComponentState::new(field.id));
self.component_type(c)?;
self.stack.pop();
}
TypeDef::Instance(i) => {
self.stack.push(ComponentState::new(field.id));
self.instance_type(i)?;
self.stack.pop();
}
TypeDef::Resource(r) => {
match &mut r.rep {
ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => {}
ValType::Ref(r) => match &mut r.heap {
core::HeapType::Abstract { .. } => {}
core::HeapType::Concrete(id) => {
self.resolve_ns(id, Ns::Type)?;
}
},
}
if let Some(dtor) = &mut r.dtor {
self.core_item_ref(dtor)?;
}
}
}
Ok(())
}
fn component_type(&mut self, c: &mut ComponentType<'a>) -> Result<(), Error> {
self.resolve_prepending_aliases(
&mut c.decls,
|resolver, decl| match decl {
ComponentTypeDecl::Alias(alias) => resolver.alias(alias),
ComponentTypeDecl::CoreType(ty) => resolver.core_ty(ty),
ComponentTypeDecl::Type(ty) => resolver.ty(ty),
ComponentTypeDecl::Import(import) => resolver.item_sig(&mut import.item),
ComponentTypeDecl::Export(export) => resolver.item_sig(&mut export.item),
},
|state, decl| {
match decl {
ComponentTypeDecl::Alias(alias) => {
state.register_alias(alias)?;
}
ComponentTypeDecl::CoreType(ty) => {
state.core_types.register(ty.id, "core type")?;
}
ComponentTypeDecl::Type(ty) => {
state.types.register(ty.id, "type")?;
}
ComponentTypeDecl::Export(e) => {
state.register_item_sig(&e.item)?;
}
ComponentTypeDecl::Import(i) => {
state.register_item_sig(&i.item)?;
}
}
Ok(())
},
)
}
fn instance_type(&mut self, c: &mut InstanceType<'a>) -> Result<(), Error> {
self.resolve_prepending_aliases(
&mut c.decls,
|resolver, decl| match decl {
InstanceTypeDecl::Alias(alias) => resolver.alias(alias),
InstanceTypeDecl::CoreType(ty) => resolver.core_ty(ty),
InstanceTypeDecl::Type(ty) => resolver.ty(ty),
InstanceTypeDecl::Export(export) => resolver.item_sig(&mut export.item),
},
|state, decl| {
match decl {
InstanceTypeDecl::Alias(alias) => {
state.register_alias(alias)?;
}
InstanceTypeDecl::CoreType(ty) => {
state.core_types.register(ty.id, "core type")?;
}
InstanceTypeDecl::Type(ty) => {
state.types.register(ty.id, "type")?;
}
InstanceTypeDecl::Export(export) => {
state.register_item_sig(&export.item)?;
}
}
Ok(())
},
)
}
fn core_item_ref<K>(&mut self, item: &mut CoreItemRef<'a, K>) -> Result<(), Error>
where
K: CoreItem + Copy,
{
// Check for not being an instance export reference
if item.export_name.is_none() {
self.resolve_ns(&mut item.idx, item.kind.ns())?;
return Ok(());
}
// This is a reference to a core instance export
let mut index = item.idx;
self.resolve_ns(&mut index, Ns::CoreInstance)?;
// Record an alias to reference the export
let span = item.idx.span();
let alias = Alias {
span,
id: None,
name: None,
target: AliasTarget::CoreExport {
instance: index,
name: item.export_name.unwrap(),
kind: item.kind.ns().into(),
},
};
index = Index::Num(self.current().register_alias(&alias)?, span);
self.aliases_to_insert.push(alias);
item.idx = index;
item.export_name = None;
Ok(())
}
fn component_item_ref<K>(&mut self, item: &mut ItemRef<'a, K>) -> Result<(), Error>
where
K: ComponentItem + Copy,
{
// Check for not being an instance export reference
if item.export_names.is_empty() {
self.resolve_ns(&mut item.idx, item.kind.ns())?;
return Ok(());
}
// This is a reference to an instance export
let mut index = item.idx;
self.resolve_ns(&mut index, Ns::Instance)?;
let span = item.idx.span();
for (pos, export_name) in item.export_names.iter().enumerate() {
// Record an alias to reference the export
let alias = Alias {
span,
id: None,
name: None,
target: AliasTarget::Export {
instance: index,
name: export_name,
kind: if pos == item.export_names.len() - 1 {
item.kind.ns().into()
} else {
ComponentExportAliasKind::Instance
},
},
};
index = Index::Num(self.current().register_alias(&alias)?, span);
self.aliases_to_insert.push(alias);
}
item.idx = index;
item.export_names = Vec::new();
Ok(())
}
fn resolve_ns(&mut self, idx: &mut Index<'a>, ns: Ns) -> Result<(), Error> {
// Perform resolution on a local clone walking up the stack of components
// that we have. Note that a local clone is used since we don't want to use
// the parent's resolved index if a parent matches, instead we want to use
// the index of the alias that we will automatically insert.
let mut idx_clone = *idx;
for (depth, resolver) in self.stack.iter_mut().rev().enumerate() {
let depth = depth as u32;
let found = match resolver.resolve(ns, &mut idx_clone) {
Ok(idx) => idx,
// Try the next parent
Err(_) => continue,
};
// If this is the current component then no extra alias is necessary, so
// return success.
if depth == 0 {
*idx = idx_clone;
return Ok(());
}
let id = match idx {
Index::Id(id) => *id,
Index::Num(..) => unreachable!(),
};
// When resolution succeeds in a parent then an outer alias is
// automatically inserted here in this component.
let span = idx.span();
let alias = Alias {
span,
id: Some(id),
name: None,
target: AliasTarget::Outer {
outer: Index::Num(depth, span),
index: Index::Num(found, span),
kind: ns.into(),
},
};
let local_index = self.current().register_alias(&alias)?;
self.aliases_to_insert.push(alias);
*idx = Index::Num(local_index, span);
return Ok(());
}
// If resolution in any parent failed then simply return the error from our
// local namespace
self.current().resolve(ns, idx)?;
unreachable!()
}
fn module_type(&mut self, ty: &mut ModuleType<'a>) -> Result<(), Error> {
return self.resolve_prepending_aliases(
&mut ty.decls,
|resolver, decl| match decl {
ModuleTypeDecl::Alias(alias) => resolver.alias(alias),
ModuleTypeDecl::Type(_) => Ok(()),
ModuleTypeDecl::Import(import) => resolve_item_sig(resolver, &mut import.item),
ModuleTypeDecl::Export(_, item) => resolve_item_sig(resolver, item),
},
|state, decl| {
match decl {
ModuleTypeDecl::Alias(alias) => {
state.register_alias(alias)?;
}
ModuleTypeDecl::Type(ty) => {
state.core_types.register(ty.id, "type")?;
}
// Only the type namespace is populated within the module type
// namespace so these are ignored here.
ModuleTypeDecl::Import(_) | ModuleTypeDecl::Export(..) => {}
}
Ok(())
},
);
fn resolve_item_sig<'a>(
resolver: &Resolver<'a>,
sig: &mut core::ItemSig<'a>,
) -> Result<(), Error> {
match &mut sig.kind {
core::ItemKind::Func(ty) | core::ItemKind::Tag(core::TagType::Exception(ty)) => {
let idx = ty.index.as_mut().expect("index should be filled in");
resolver
.stack
.last()
.unwrap()
.core_types
.resolve(idx, "type")?;
}
core::ItemKind::Memory(_)
| core::ItemKind::Global(_)
| core::ItemKind::Table(_) => {}
}
Ok(())
}
}
}
impl<'a> ComponentState<'a> {
fn resolve(&mut self, ns: Ns, idx: &mut Index<'a>) -> Result<u32, Error> {
match ns {
Ns::CoreFunc => self.core_funcs.resolve(idx, "core func"),
Ns::CoreGlobal => self.core_globals.resolve(idx, "core global"),
Ns::CoreTable => self.core_tables.resolve(idx, "core table"),
Ns::CoreMemory => self.core_memories.resolve(idx, "core memory"),
Ns::CoreType => self.core_types.resolve(idx, "core type"),
Ns::CoreTag => self.core_tags.resolve(idx, "core tag"),
Ns::CoreInstance => self.core_instances.resolve(idx, "core instance"),
Ns::CoreModule => self.core_modules.resolve(idx, "core module"),
Ns::Func => self.funcs.resolve(idx, "func"),
Ns::Type => self.types.resolve(idx, "type"),
Ns::Instance => self.instances.resolve(idx, "instance"),
Ns::Component => self.components.resolve(idx, "component"),
Ns::Value => self.values.resolve(idx, "value"),
}
}
/// Assign an index to the given field.
fn register(&mut self, item: &ComponentField<'a>) -> Result<(), Error> {
match item {
ComponentField::CoreModule(m) => self.core_modules.register(m.id, "core module")?,
ComponentField::CoreInstance(i) => {
self.core_instances.register(i.id, "core instance")?
}
ComponentField::CoreType(t) => self.core_types.register(t.id, "core type")?,
ComponentField::Component(c) => self.components.register(c.id, "component")?,
ComponentField::Instance(i) => self.instances.register(i.id, "instance")?,
ComponentField::Alias(a) => self.register_alias(a)?,
ComponentField::Type(t) => self.types.register(t.id, "type")?,
ComponentField::CanonicalFunc(f) => match &f.kind {
CanonicalFuncKind::Lift { .. } => self.funcs.register(f.id, "func")?,
CanonicalFuncKind::Lower(_)
| CanonicalFuncKind::ResourceNew(_)
| CanonicalFuncKind::ResourceRep(_)
| CanonicalFuncKind::ResourceDrop(_) => {
self.core_funcs.register(f.id, "core func")?
}
},
ComponentField::CoreFunc(_) | ComponentField::Func(_) => {
unreachable!("should be expanded already")
}
ComponentField::Start(s) => {
for r in &s.results {
self.values.register(*r, "value")?;
}
return Ok(());
}
ComponentField::Import(i) => self.register_item_sig(&i.item)?,
ComponentField::Export(e) => match &e.kind {
ComponentExportKind::CoreModule(_) => {
self.core_modules.register(e.id, "core module")?
}
ComponentExportKind::Func(_) => self.funcs.register(e.id, "func")?,
ComponentExportKind::Instance(_) => self.instances.register(e.id, "instance")?,
ComponentExportKind::Value(_) => self.values.register(e.id, "value")?,
ComponentExportKind::Component(_) => self.components.register(e.id, "component")?,
ComponentExportKind::Type(_) => self.types.register(e.id, "type")?,
},
ComponentField::Custom(_) | ComponentField::Producers(_) => return Ok(()),
};
Ok(())
}
fn register_alias(&mut self, alias: &Alias<'a>) -> Result<u32, Error> {
match alias.target {
AliasTarget::Export { kind, .. } => match kind {
ComponentExportAliasKind::CoreModule => {
self.core_modules.register(alias.id, "core module")
}
ComponentExportAliasKind::Func => self.funcs.register(alias.id, "func"),
ComponentExportAliasKind::Value => self.values.register(alias.id, "value"),
ComponentExportAliasKind::Type => self.types.register(alias.id, "type"),
ComponentExportAliasKind::Component => {
self.components.register(alias.id, "component")
}
ComponentExportAliasKind::Instance => self.instances.register(alias.id, "instance"),
},
AliasTarget::CoreExport { kind, .. } => match kind {
core::ExportKind::Func => self.core_funcs.register(alias.id, "core func"),
core::ExportKind::Table => self.core_tables.register(alias.id, "core table"),
core::ExportKind::Memory => self.core_memories.register(alias.id, "core memory"),
core::ExportKind::Global => self.core_globals.register(alias.id, "core global"),
core::ExportKind::Tag => self.core_tags.register(alias.id, "core tag"),
},
AliasTarget::Outer { kind, .. } => match kind {
ComponentOuterAliasKind::CoreModule => {
self.core_modules.register(alias.id, "core module")
}
ComponentOuterAliasKind::CoreType => {
self.core_types.register(alias.id, "core type")
}
ComponentOuterAliasKind::Type => self.types.register(alias.id, "type"),
ComponentOuterAliasKind::Component => {
self.components.register(alias.id, "component")
}
},
}
}
}
#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
enum Ns {
CoreFunc,
CoreGlobal,
CoreTable,
CoreMemory,
CoreType,
CoreTag,
CoreInstance,
CoreModule,
Func,
Type,
Instance,
Component,
Value,
}
trait ComponentItem {
fn ns(&self) -> Ns;
}
trait CoreItem {
fn ns(&self) -> Ns;
}
macro_rules! component_item {
($kw:path, $kind:ident) => {
impl ComponentItem for $kw {
fn ns(&self) -> Ns {
Ns::$kind
}
}
};
}
macro_rules! core_item {
($kw:path, $kind:ident) => {
impl CoreItem for $kw {
fn ns(&self) -> Ns {
Ns::$kind
}
}
};
}
component_item!(kw::func, Func);
component_item!(kw::r#type, Type);
component_item!(kw::r#instance, Instance);
component_item!(kw::component, Component);
component_item!(kw::value, Value);
component_item!(kw::module, CoreModule);
core_item!(kw::func, CoreFunc);
core_item!(kw::memory, CoreMemory);
core_item!(kw::r#type, CoreType);
core_item!(kw::r#instance, CoreInstance);
impl From<Ns> for ComponentExportAliasKind {
fn from(ns: Ns) -> Self {
match ns {
Ns::CoreModule => Self::CoreModule,
Ns::Func => Self::Func,
Ns::Type => Self::Type,
Ns::Instance => Self::Instance,
Ns::Component => Self::Component,
Ns::Value => Self::Value,
_ => unreachable!("not a component exportable namespace"),
}
}
}
impl From<Ns> for ComponentOuterAliasKind {
fn from(ns: Ns) -> Self {
match ns {
Ns::CoreModule => Self::CoreModule,
Ns::CoreType => Self::CoreType,
Ns::Type => Self::Type,
Ns::Component => Self::Component,
_ => unreachable!("not an outer alias namespace"),
}
}
}
impl From<Ns> for core::ExportKind {
fn from(ns: Ns) -> Self {
match ns {
Ns::CoreFunc => Self::Func,
Ns::CoreTable => Self::Table,
Ns::CoreGlobal => Self::Global,
Ns::CoreMemory => Self::Memory,
Ns::CoreTag => Self::Tag,
_ => unreachable!("not a core exportable namespace"),
}
}
}
impl From<ComponentOuterAliasKind> for Ns {
fn from(kind: ComponentOuterAliasKind) -> Self {
match kind {
ComponentOuterAliasKind::CoreModule => Self::CoreModule,
ComponentOuterAliasKind::CoreType => Self::CoreType,
ComponentOuterAliasKind::Type => Self::Type,
ComponentOuterAliasKind::Component => Self::Component,
}
}
}
impl CoreItem for core::ExportKind {
fn ns(&self) -> Ns {
match self {
Self::Func => Ns::CoreFunc,
Self::Table => Ns::CoreTable,
Self::Global => Ns::CoreGlobal,
Self::Memory => Ns::CoreMemory,
Self::Tag => Ns::CoreTag,
}
}
}