separate RefType

src/init_expr.rs

@@ -3,7 +3,7 @@
 use crate::emit::EmitContext;
 use crate::ir::Value;
 use crate::parse::IndicesToIds;
-use crate::ValType;
+use crate::RefType;
 use crate::{FunctionId, GlobalId, Result};
 use anyhow::bail;
 
@@ -16,7 +16,7 @@ pub enum InitExpr {
     /// A constant value referenced by the global specified
     Global(GlobalId),
     /// A null reference
-    RefNull(ValType),
+    RefNull(RefType),
     /// A function initializer
     RefFunc(FunctionId),
 }
@@ -35,11 +35,15 @@ impl InitExpr {
             RefNull { hty } => {
                 let val_type = match hty {
                     wasmparser::HeapType::Abstract { shared: _, ty } => match ty {
-                        wasmparser::AbstractHeapType::Func => ValType::Funcref,
-                        wasmparser::AbstractHeapType::Extern => ValType::Externref,
-                        _ => bail!("invalid constant expression"),
+                        wasmparser::AbstractHeapType::Func => RefType::Funcref,
+                        wasmparser::AbstractHeapType::Extern => RefType::Externref,
+                        other => bail!(
+                            "unsupported abstract heap type in constant expression: {other:?}"
+                        ),
                     },
-                    wasmparser::HeapType::Concrete(_) => bail!("invalid constant expression"),
+                    wasmparser::HeapType::Concrete(_) => {
+                        bail!("unsupported concrete heap type in constant expression")
+                    }
                 };
                 InitExpr::RefNull(val_type)
             }
@@ -67,15 +71,14 @@ impl InitExpr {
                 wasm_encoder::ConstExpr::global_get(cx.indices.get_global_index(*g))
             }
             InitExpr::RefNull(ty) => wasm_encoder::ConstExpr::ref_null(match ty {
-                ValType::Externref => wasm_encoder::HeapType::Abstract {
+                RefType::Externref => wasm_encoder::HeapType::Abstract {
                     shared: false,
                     ty: wasm_encoder::AbstractHeapType::Extern,
                 },
-                ValType::Funcref => wasm_encoder::HeapType::Abstract {
+                RefType::Funcref => wasm_encoder::HeapType::Abstract {
                     shared: false,
                     ty: wasm_encoder::AbstractHeapType::Func,
                 },
-                _ => unreachable!(),
             }),
             InitExpr::RefFunc(f) => {
                 wasm_encoder::ConstExpr::ref_func(cx.indices.get_func_index(*f))

src/ir/mod.rs

@@ -8,8 +8,8 @@ mod traversals;
 pub use self::traversals::*;
 
 use crate::{
-    DataId, ElementId, FunctionId, GlobalId, LocalFunction, MemoryId, ModuleTypes, TableId, TypeId,
-    ValType,
+    DataId, ElementId, FunctionId, GlobalId, LocalFunction, MemoryId, ModuleTypes, RefType,
+    TableId, TypeId, ValType,
 };
 use id_arena::Id;
 use std::fmt;
@@ -532,7 +532,7 @@ pub enum Instr {
     RefNull {
         /// The type of null that we're producing
         #[walrus(skip_visit)]
-        ty: ValType,
+        ty: RefType,
     },
 
     /// `ref.is_null`

src/lib.rs

@@ -38,4 +38,4 @@ pub use crate::init_expr::InitExpr;
 pub use crate::ir::{Local, LocalId};
 pub use crate::module::*;
 pub use crate::parse::IndicesToIds;
-pub use crate::ty::{Type, TypeId, ValType};
+pub use crate::ty::{RefType, Type, TypeId, ValType};

src/module/elements.rs

@@ -3,7 +3,7 @@
 use crate::emit::{Emit, EmitContext};
 use crate::parse::IndicesToIds;
 use crate::tombstone_arena::{Id, Tombstone, TombstoneArena};
-use crate::{ir::Value, FunctionId, InitExpr, Module, Result, TableId, ValType};
+use crate::{ir::Value, FunctionId, InitExpr, Module, RefType, Result, TableId, ValType};
 use anyhow::{bail, Context};
 
 /// A passive element segment identifier
@@ -44,7 +44,7 @@ pub enum ElementItems {
     /// This element contains function indices.
     Functions(Vec<FunctionId>),
     /// This element contains constant expressions used to initialize the table.
-    Expressions(ValType, Vec<InitExpr>),
+    Expressions(RefType, Vec<InitExpr>),
 }
 
 impl Element {
@@ -134,8 +134,8 @@ impl Module {
                 }
                 wasmparser::ElementItems::Expressions(ref_type, items) => {
                     let ty = match ref_type {
-                        wasmparser::RefType::FUNCREF => ValType::Funcref,
-                        wasmparser::RefType::EXTERNREF => ValType::Externref,
+                        wasmparser::RefType::FUNCREF => RefType::Funcref,
+                        wasmparser::RefType::EXTERNREF => RefType::Externref,
                         _ => bail!("unsupported ref type in element segment {}", i),
                     };
                     let mut init_exprs = Vec::with_capacity(items.count() as usize);
@@ -211,9 +211,8 @@ impl Emit for ModuleElements {
                 }
                 ElementItems::Expressions(ty, init_exprs) => {
                     let ref_type = match ty {
-                        ValType::Funcref => wasm_encoder::RefType::FUNCREF,
-                        ValType::Externref => wasm_encoder::RefType::EXTERNREF,
-                        _ => unreachable!(),
+                        RefType::Funcref => wasm_encoder::RefType::FUNCREF,
+                        RefType::Externref => wasm_encoder::RefType::EXTERNREF,
                     };
                     let const_exprs = init_exprs
                         .iter()

src/module/functions/local_function/emit.rs

@@ -1,8 +1,8 @@
 use crate::emit::IdsToIndices;
-use crate::ir::*;
 use crate::map::IdHashMap;
 use crate::module::functions::LocalFunction;
 use crate::module::memories::MemoryId;
+use crate::{ir::*, RefType};
 use wasm_encoder::Instruction;
 
 pub(crate) fn run(
@@ -775,15 +775,14 @@ impl<'instr> Visitor<'instr> for Emit<'_> {
             TableSize(e) => Instruction::TableSize(self.indices.get_table_index(e.table)),
             TableFill(e) => Instruction::TableFill(self.indices.get_table_index(e.table)),
             RefNull(e) => Instruction::RefNull(match &e.ty {
-                crate::ValType::Externref => wasm_encoder::HeapType::Abstract {
+                RefType::Externref => wasm_encoder::HeapType::Abstract {
                     shared: false,
                     ty: wasm_encoder::AbstractHeapType::Extern,
                 },
-                crate::ValType::Funcref => wasm_encoder::HeapType::Abstract {
+                RefType::Funcref => wasm_encoder::HeapType::Abstract {
                     shared: false,
                     ty: wasm_encoder::AbstractHeapType::Func,
                 },
-                _ => unreachable!(),
             }),
             RefIsNull(_) => Instruction::RefIsNull,
             RefFunc(e) => Instruction::RefFunc(self.indices.get_func_index(e.func)),

src/module/functions/local_function/mod.rs

@@ -5,9 +5,9 @@ mod emit;
 
 use self::context::ValidationContext;
 use crate::emit::IdsToIndices;
-use crate::ir::*;
 use crate::map::{IdHashMap, IdHashSet};
 use crate::parse::IndicesToIds;
+use crate::{ir::*, RefType};
 use crate::{Data, DataId, FunctionBuilder, FunctionId, MemoryId, Module, Result, TypeId, ValType};
 use std::collections::BTreeMap;
 use std::ops::Range;
@@ -1001,9 +1001,11 @@ fn append_instruction<'context>(
         Operator::RefNull { hty } => {
             let ty = match hty {
                 wasmparser::HeapType::Abstract { shared: _, ty } => match ty {
-                    wasmparser::AbstractHeapType::Func => ValType::Funcref,
-                    wasmparser::AbstractHeapType::Extern => ValType::Externref,
-                    _ => panic!("unsupported abstract heap type for ref.null"),
+                    wasmparser::AbstractHeapType::Func => RefType::Funcref,
+                    wasmparser::AbstractHeapType::Extern => RefType::Externref,
+                    other => {
+                        panic!("unsupported abstract heap type for ref.null: {:?}", other)
+                    }
                 },
                 wasmparser::HeapType::Concrete(_) => {
                     panic!("unsupported concrete heap type for ref.null")

src/module/imports.rs

@@ -1,12 +1,14 @@
 //! A wasm module's imports.
 
+use std::convert::TryInto;
+
 use anyhow::{bail, Context};
 
 use crate::emit::{Emit, EmitContext};
 use crate::parse::IndicesToIds;
 use crate::tombstone_arena::{Id, Tombstone, TombstoneArena};
 use crate::{FunctionId, GlobalId, MemoryId, Result, TableId};
-use crate::{Module, TypeId, ValType};
+use crate::{Module, RefType, TypeId, ValType};
 
 /// The id of an import.
 pub type ImportId = Id<Import>;
@@ -159,14 +161,13 @@ impl Module {
                     ids.push_func(id.0);
                 }
                 wasmparser::TypeRef::Table(t) => {
-                    let ty = ValType::parse(&wasmparser::ValType::Ref(t.element_type))?;
                     let id = self.add_import_table(
                         entry.module,
                         entry.name,
                         t.table64,
                         t.initial,
                         t.maximum,
-                        ty,
+                        t.element_type.try_into()?,
                     );
                     ids.push_table(id.0);
                 }
@@ -242,7 +243,7 @@ impl Module {
         table64: bool,
         initial: u64,
         maximum: Option<u64>,
-        ty: ValType,
+        ty: RefType,
     ) -> (TableId, ImportId) {
         let import = self.imports.arena.next_id();
         let table = self
@@ -295,9 +296,8 @@ impl Emit for ModuleImports {
                         let table = cx.module.tables.get(id);
                         wasm_encoder::EntityType::Table(wasm_encoder::TableType {
                             element_type: match table.element_ty {
-                                ValType::Externref => wasm_encoder::RefType::EXTERNREF,
-                                ValType::Funcref => wasm_encoder::RefType::FUNCREF,
-                                _ => panic!("Unexpected table type"),
+                                RefType::Externref => wasm_encoder::RefType::EXTERNREF,
+                                RefType::Funcref => wasm_encoder::RefType::FUNCREF,
                             },
                             table64: table.table64,
                             minimum: table.initial,

src/module/tables.rs

@@ -1,10 +1,12 @@
 //! Tables within a wasm module.
 
+use std::convert::TryInto;
+
 use crate::emit::{Emit, EmitContext};
 use crate::map::IdHashSet;
 use crate::parse::IndicesToIds;
 use crate::tombstone_arena::{Id, Tombstone, TombstoneArena};
-use crate::{Element, ImportId, Module, Result, ValType};
+use crate::{Element, ImportId, Module, RefType, Result};
 use anyhow::bail;
 
 /// The id of a table.
@@ -21,7 +23,7 @@ pub struct Table {
     /// The maximum size of this table
     pub maximum: Option<u64>,
     /// The type of the elements in this table
-    pub element_ty: ValType,
+    pub element_ty: RefType,
     /// Whether or not this table is imported, and if so what imports it.
     pub import: Option<ImportId>,
     /// Active data segments that will be used to initialize this memory.
@@ -54,7 +56,7 @@ impl ModuleTables {
         table64: bool,
         initial: u64,
         maximum: Option<u64>,
-        element_ty: ValType,
+        element_ty: RefType,
         import: ImportId,
     ) -> TableId {
         let id = self.arena.next_id();
@@ -77,7 +79,7 @@ impl ModuleTables {
         table64: bool,
         initial: u64,
         maximum: Option<u64>,
-        element_ty: ValType,
+        element_ty: RefType,
     ) -> TableId {
         let id = self.arena.next_id();
         let id2 = self.arena.alloc(Table {
@@ -128,7 +130,7 @@ impl ModuleTables {
     ///
     /// Returns an error if there are two function tables in this module
     pub fn main_function_table(&self) -> Result<Option<TableId>> {
-        let mut tables = self.iter().filter(|t| t.element_ty == ValType::Funcref);
+        let mut tables = self.iter().filter(|t| t.element_ty == RefType::Funcref);
         let id = match tables.next() {
             Some(t) => t.id(),
             None => return Ok(None),
@@ -159,7 +161,7 @@ impl Module {
                 t.ty.table64,
                 t.ty.initial,
                 t.ty.maximum,
-                ValType::parse(&wasmparser::ValType::Ref(t.ty.element_type))?,
+                t.ty.element_type.try_into()?,
             );
             ids.push_table(id);
         }
@@ -187,9 +189,8 @@ impl Emit for ModuleTables {
                 minimum: table.initial,
                 maximum: table.maximum,
                 element_type: match table.element_ty {
-                    ValType::Externref => wasm_encoder::RefType::EXTERNREF,
-                    ValType::Funcref => wasm_encoder::RefType::FUNCREF,
-                    _ => unreachable!(),
+                    RefType::Externref => wasm_encoder::RefType::EXTERNREF,
+                    RefType::Funcref => wasm_encoder::RefType::FUNCREF,
                 },
             });
         }

src/passes/used.rs

@@ -1,7 +1,7 @@
 use crate::ir::*;
 use crate::map::IdHashSet;
 use crate::{ActiveDataLocation, Data, DataId, DataKind, Element, ExportItem, Function, InitExpr};
-use crate::{ElementId, ElementItems, ElementKind, Module, Type, TypeId};
+use crate::{ElementId, ElementItems, ElementKind, Module, RefType, Type, TypeId};
 use crate::{FunctionId, FunctionKind, Global, GlobalId};
 use crate::{GlobalKind, Memory, MemoryId, Table, TableId};
 
@@ -209,7 +209,7 @@ impl Used {
                         stack.push_func(*f);
                     });
                 }
-                if let ElementItems::Expressions(crate::ValType::Funcref, items) = &e.items {
+                if let ElementItems::Expressions(RefType::Funcref, items) = &e.items {
                     for item in items {
                         match item {
                             InitExpr::Global(g) => {

src/ty.rs

@@ -5,6 +5,7 @@ use crate::tombstone_arena::Tombstone;
 use anyhow::bail;
 use id_arena::Id;
 use std::cmp::Ordering;
+use std::convert::TryFrom;
 use std::fmt;
 use std::hash;
 
@@ -135,10 +136,32 @@ pub enum ValType {
     F64,
     /// 128-bit vector.
     V128,
-    /// The `externref` opaque value type
-    Externref,
-    /// The `funcref` value type, representing a callable function
+    /// Reference.
+    Ref(RefType),
+}
+
+/// A reference type.
+///
+/// The "function references" and "gc" proposals will add more reference types.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[non_exhaustive]
+pub enum RefType {
+    /// A nullable reference to an untyped function
     Funcref,
+    /// A nullable reference to an extern object
+    Externref,
+}
+
+impl TryFrom<wasmparser::RefType> for RefType {
+    type Error = anyhow::Error;
+
+    fn try_from(ref_type: wasmparser::RefType) -> Result<RefType> {
+        match ref_type {
+            wasmparser::RefType::FUNCREF => Ok(RefType::Funcref),
+            wasmparser::RefType::EXTERNREF => Ok(RefType::Externref),
+            _ => bail!("unsupported ref type {:?}", ref_type),
+        }
+    }
 }
 
 impl ValType {
@@ -154,8 +177,10 @@ impl ValType {
             ValType::F32 => wasm_encoder::ValType::F32,
             ValType::F64 => wasm_encoder::ValType::F64,
             ValType::V128 => wasm_encoder::ValType::V128,
-            ValType::Externref => wasm_encoder::ValType::Ref(wasm_encoder::RefType::EXTERNREF),
-            ValType::Funcref => wasm_encoder::ValType::Ref(wasm_encoder::RefType::FUNCREF),
+            ValType::Ref(ref_type) => match ref_type {
+                RefType::Externref => wasm_encoder::ValType::Ref(wasm_encoder::RefType::EXTERNREF),
+                RefType::Funcref => wasm_encoder::ValType::Ref(wasm_encoder::RefType::FUNCREF),
+            },
         }
     }
 
@@ -167,8 +192,8 @@ impl ValType {
             wasmparser::ValType::F64 => Ok(ValType::F64),
             wasmparser::ValType::V128 => Ok(ValType::V128),
             wasmparser::ValType::Ref(ref_type) => match *ref_type {
-                wasmparser::RefType::EXTERNREF => Ok(ValType::Externref),
-                wasmparser::RefType::FUNCREF => Ok(ValType::Funcref),
+                wasmparser::RefType::EXTERNREF => Ok(ValType::Ref(RefType::Externref)),
+                wasmparser::RefType::FUNCREF => Ok(ValType::Ref(RefType::Funcref)),
                 _ => bail!("unsupported ref type {:?}", ref_type),
             },
         }
@@ -186,8 +211,8 @@ impl fmt::Display for ValType {
                 ValType::F32 => "f32",
                 ValType::F64 => "f64",
                 ValType::V128 => "v128",
-                ValType::Externref => "externref",
-                ValType::Funcref => "funcref",
+                ValType::Ref(RefType::Externref) => "externref",
+                ValType::Ref(RefType::Funcref) => "funcref",
             }
         )
     }