watr 3.2.0 → 3.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "Ligth & fast WAT compiler",
   "main": "watr.js",
   "exports": {

package/src/compile.js

@@ -39,32 +39,46 @@ export default function watr(nodes) {
   // scopes are aliased by key as well, eg. section.func.$name = section[SECTION.func] = idx
   const ctx = []
   for (let kind in SECTION) (ctx[SECTION[kind]] = ctx[kind] = []).name = kind
-  ctx._ = {} // implicit types
-
-  let subc // current subtype count
-
-  // prepare/normalize nodes
-  while (nodes.length) {
-    let [kind, ...node] = nodes.shift()
-    let imported // if node needs to be imported
-    let rec // number of subtypes under rec type
 
+  // initialize types
+  nodes.filter(([kind, ...node]) => {
     // (rec (type $a (sub final? $sup* (func ...))...) (type $b ...)) -> save subtypes
     if (kind === 'rec') {
       // node contains a list of subtypes, (type ...) or (type (sub final? ...))
       // convert rec type into regular type (first subtype) with stashed subtypes length
       // add rest of subtypes as regular type nodes with subtype flag
-      if (node.length > 1) rec = subc = node.length, nodes.unshift(...node), node = nodes.shift(), kind = node.shift()
-      else kind = (node = node[0]).shift()
+      for (let i = 0; i < node.length; i++) {
+        let [,...subnode] = node[i]
+        alias(subnode, ctx.type);
+        (subnode = typedef(subnode, ctx)).push(i ? true : [ctx.type.length, node.length])
+        ctx.type.push(subnode)
+      }
+    }
+    // (type (func param* result*))
+    // (type (array (mut i8)))
+    // (type (struct (field a)*)
+    // (type (sub final? $nm* (struct|array|func ...)))
+    else if (kind === 'type') {
+      alias(node, ctx.type);
+      ctx.type.push(typedef(node, ctx));
     }
+    // other sections may have id
+    else if (kind === 'start' || kind === 'export') ctx[kind].push(node)
+
+    else return true
+  })
+
+  // prepare/normalize nodes
+  .forEach(([kind, ...node]) => {
+    let imported // if node needs to be imported
 
     // import abbr
     // (import m n (table|memory|global|func id? type)) -> (table|memory|global|func id? (import m n) type)
-    else if (kind === 'import') [kind, ...node] = (imported = node).pop()
+    if (kind === 'import') [kind, ...node] = (imported = node).pop()
 
     // index, alias
     let items = ctx[kind];
-    let name = alias(node, items)
+    let name = alias(node, items);
 
     // export abbr
     // (table|memory|global|func id? (export n)* ...) -> (table|memory|global|func id ...) (export n (table|memory|global|func id))
@@ -91,37 +105,13 @@ export default function watr(nodes) {
       node = [m, m]
     }
 
-    // keep start name
-    else if (kind === 'start') name && node.push(name)
-
-    // normalize type definition to (func|array|struct dfn) form
-    // (type (func param* result*))
-    // (type (array (mut i8)))
-    // (type (struct (field a)*)
-    // (type (sub final? $nm* (struct|array|func ...)))
-    else if (kind === 'type') {
-      let [dfn] = node
-      let issub = subc-- > 0
-      let subkind = issub && 'subfinal', supertypes = []
-      if (dfn[0] === 'sub') {
-        subkind = dfn.shift(), dfn[0] === 'final' && (subkind += dfn.shift())
-        dfn = (supertypes = dfn).pop() // last item is definition
-      }
-
-      let ckind = dfn.shift() // composite type kind
-      if (ckind === 'func') dfn = paramres(dfn), ctx.type['$' + dfn.join('>')] ??= ctx.type.length
-      else if (ckind === 'struct') dfn = fieldseq(dfn, 'field', true)
-      else if (ckind === 'array') dfn = dfn.shift()
-
-      node = [ckind, dfn, subkind, supertypes, rec ? [ctx.type.length, rec] : issub]
-    }
-
     // dupe to code section, save implicit type
     else if (kind === 'func') {
       let [idx, param, result] = typeuse(node, ctx);
-      idx ?? (ctx._[idx = '$' + param + '>' + result] = [param, result]);
+      idx ??= regtype(param, result, ctx)
+
       // we save idx because type can be defined after
-      !imported && nodes.push(['code', [idx, param, result], ...plain(node, ctx)]) // pass param since they may have names
+      !imported && ctx.code.push([[idx, param, result], ...plain(node, ctx)]) // pass param since they may have names
       node.unshift(['type', idx])
     }
 
@@ -129,14 +119,7 @@ export default function watr(nodes) {
     if (imported) ctx.import.push([...imported, [kind, ...node]]), node = null
 
     items.push(node)
-  }
-
-  // add implicit types - main types receive aliases, implicit types are added if no explicit types exist
-  for (let n in ctx._) ctx.type[n] ??= (ctx.type.push(['func', ctx._[n]]) - 1)
-
-  // patch datacount if data === 0
-  // FIXME: let's try to return empty in datacount builder, since we filter after builder as well
-  // if (!ctx.data.length) ctx.datacount.length = 0
+  })
 
   // convert nodes to bytes
   const bin = (kind, count = true) => {
@@ -175,6 +158,103 @@ const alias = (node, list) => {
   return name
 }
 
+// (type $id? (func param* result*))
+// (type $id? (array (mut i8)))
+// (type $id? (struct (field a)*)
+// (type $id? (sub final? $nm* (struct|array|func ...)))
+const typedef = ([dfn], ctx) => {
+  let subkind = 'subfinal', supertypes = [], compkind
+  if (dfn[0] === 'sub') {
+    subkind = dfn.shift(), dfn[0] === 'final' && (subkind += dfn.shift())
+    dfn = (supertypes = dfn).pop() // last item is definition
+  }
+
+  [compkind, ...dfn] = dfn // composite type kind
+
+  if (compkind === 'func') dfn = paramres(dfn), ctx.type['$' + dfn.join('>')] ??= ctx.type.length
+  else if (compkind === 'struct') dfn = fieldseq(dfn, 'field', true)
+  else if (compkind === 'array') [dfn] = dfn
+
+  return [compkind, dfn, subkind, supertypes]
+}
+
+// register (implicit) type
+const regtype = (param, result, ctx, idx='$' + param + '>' + result) => (
+  (ctx.type[idx] ??= ctx.type.push(['func', [param, result]]) - 1),
+  idx
+)
+
+// consume typeuse nodes, return type index/params, or null idx if no type
+// https://webassembly.github.io/spec/core/text/modules.html#type-uses
+const typeuse = (nodes, ctx, names) => {
+  let idx, param, result
+
+  // explicit type (type 0|$name)
+  if (nodes[0]?.[0] === 'type') {
+    [, idx] = nodes.shift();
+    [param, result] = paramres(nodes, names);
+
+    const [,srcParamRes] = ctx.type[id(idx, ctx.type)] ?? err(`Unknown type ${idx}`)
+
+    // check type consistency (excludes forward refs)
+    if ((param.length || result.length) && srcParamRes.join('>') !== param + '>' + result) err(`Type ${idx} mismatch`)
+
+    return [idx, ...srcParamRes]
+  }
+
+  // implicit type (param i32 i32)(result i32)
+  return [idx, ...paramres(nodes, names)]
+}
+
+// consume (param t+)* (result t+)* sequence
+const paramres = (nodes, names = true) => {
+  // let param = [], result = []
+
+  // collect param (param i32 i64) (param $x? i32)
+  let param = fieldseq(nodes, 'param', names)
+
+  // collect result eg. (result f64 f32)(result i32)
+  let result = fieldseq(nodes, 'result')
+
+  if (nodes[0]?.[0] === 'param') err(`Unexpected param`)
+
+  return [param, result]
+}
+
+// collect sequence of field, eg. (param a) (param b c), (field a) (field b c) or (result a b) (result c)
+// optionally allow or not names
+const fieldseq = (nodes, field, names = false) => {
+  let seq = []
+  // collect field eg. (field f64 f32)(field i32)
+  while (nodes[0]?.[0] === field) {
+    let [, ...args] = nodes.shift()
+    let name = args[0]?.[0] === '$' && args.shift()
+    // expose name refs, if allowed
+    if (name) {
+      if (names) name in seq ? err(`Duplicate ${field} ${name}`) : seq[name] = seq.length
+      else err(`Unexpected ${field} name ${name}`)
+    }
+    seq.push(...args)
+  }
+  return seq
+}
+
+// consume blocktype - makes sure either type or single result is returned
+const blocktype = (nodes, ctx) => {
+  let [idx, param, result] = typeuse(nodes, ctx, 0)
+
+  // get type - can be either idx or valtype (numtype | reftype)
+  if (!param.length && !result.length) return
+
+  // (result i32) - doesn't require registering type
+  if (!param.length && result.length === 1) return ['result', ...result]
+
+  // register implicit type
+  idx ??= regtype(param, result, ctx)
+
+  return ['type', idx]
+}
+
 // abbr blocks, loops, ifs; collect implicit types via typeuses; resolve optional immediates
 // https://webassembly.github.io/spec/core/text/instructions.html#folded-instructions
 const plain = (nodes, ctx) => {
@@ -211,7 +291,7 @@ const plain = (nodes, ctx) => {
       else if (node.endsWith('call_indirect')) {
         let tableidx = nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0
         let [idx, param, result] = typeuse(nodes, ctx, 0)
-        out.push(tableidx, ['type', idx ?? (ctx._[idx = '$' + param + '>' + result] = [param, result], idx)])
+        out.push(tableidx, ['type', idx ?? regtype(param, result, ctx)])
       }
 
       // mark datacount section as required
@@ -267,80 +347,6 @@ const plain = (nodes, ctx) => {
   return out
 }
 
-// consume typeuse nodes, return type index/params, or null idx if no type
-// https://webassembly.github.io/spec/core/text/modules.html#type-uses
-const typeuse = (nodes, ctx, names) => {
-  let idx, param, result
-
-  // explicit type (type 0|$name)
-  if (nodes[0]?.[0] === 'type') {
-    [, idx] = nodes.shift();
-    [param, result] = paramres(nodes, names);
-
-    // check type consistency (excludes forward refs)
-    if ((param.length || result.length) && idx in ctx.type)
-      if (ctx.type[id(idx, ctx.type)][1].join('>') !== param + '>' + result) err(`Type ${idx} mismatch`)
-
-    return [idx]
-  }
-
-  // implicit type (param i32 i32)(result i32)
-  [param, result] = paramres(nodes, names)
-
-  return [, param, result]
-}
-
-// consume (param t+)* (result t+)* sequence
-const paramres = (nodes, names = true) => {
-  // let param = [], result = []
-
-  // collect param (param i32 i64) (param $x? i32)
-  let param = fieldseq(nodes, 'param', names)
-
-  // collect result eg. (result f64 f32)(result i32)
-  let result = fieldseq(nodes, 'result')
-
-  if (nodes[0]?.[0] === 'param') err(`Unexpected param`)
-
-  return [param, result]
-}
-
-// collect sequence of field, eg. (param a) (param b c), (field a) (field b c) or (result a b) (result c)
-// optionally allow or not names
-const fieldseq = (nodes, field, names = false) => {
-  let seq = []
-  // collect field eg. (field f64 f32)(field i32)
-  while (nodes[0]?.[0] === field) {
-    let [, ...args] = nodes.shift()
-    let name = args[0]?.[0] === '$' && args.shift()
-    // expose name refs, if allowed
-    if (name) {
-      if (names) name in seq ? err(`Duplicate ${field} ${name}`) : seq[name] = seq.length
-      else err(`Unexpected ${field} name ${name}`)
-    }
-    seq.push(...args)
-  }
-  return seq
-}
-
-// consume blocktype - makes sure either type or single result is returned
-const blocktype = (nodes, ctx) => {
-  let [idx, param, result] = typeuse(nodes, ctx, 0)
-
-  // direct idx (no params/result needed)
-  if (idx != null) return ['type', idx]
-
-  // get type - can be either idx or valtype (numtype | reftype)
-  if (!param.length && !result.length) return
-
-  // (result i32) - doesn't require registering type
-  if (!param.length && result.length === 1) return ['result', ...result]
-
-  // (param i32 i32)? (result i32 i32) - implicit type
-  ctx._[idx = '$' + param + '>' + result] = [param, result]
-  return ['type', idx]
-}
-
 
 // build section binary [by section codes] (non consuming)
 const build = [,
@@ -354,7 +360,6 @@ const build = [,
     let details
     // (rec (sub ...)*)
     if (rec) {
-      // FIXME: rec of one type
       kind = 'rec'
       let [from, length] = rec, subtypes = Array.from({ length }, (_, i) => build[SECTION.type](ctx.type[from + i].slice(0, 4), ctx))
       details = vec(subtypes)
@@ -378,7 +383,7 @@ const build = [,
     return [DEFTYPE[kind], ...details]
   },
 
-  // (import "math" "add" (func|table|global|memory typedef?))
+  // (import "math" "add" (func|table|global|memory dfn?))
   ([mod, field, [kind, ...dfn]], ctx) => {
     let details
 
@@ -635,14 +640,12 @@ const instr = (nodes, ctx) => {
     }
     // ref.test|cast (ref null? $t|heaptype)
     else if (code >= 20 && code <= 23) {
-      // FIXME: normalizer is supposed to resolve this
       let ht = reftype(nodes.shift(), ctx)
       if (ht[0] !== REFTYPE.ref) immed.push(code = immed.pop()+1) // ref.test|cast (ref null $t) is next op
       if (ht.length > 1) ht.shift() // pop ref
       immed.push(...ht)
     }
     // br_on_cast[_fail] $l? (ref null? ht1) (ref null? ht2)
-    // FIXME: normalizer should resolve anyref|etc to (ref null any|etc)
     else if (code === 24 || code === 25) {
       let i = blockid(nodes.shift(), ctx.block),
         ht1 = reftype(nodes.shift(), ctx),
@@ -744,7 +747,6 @@ const instr = (nodes, ctx) => {
     ctx.block.push(code)
 
     // (block $x) (loop $y) - save label pointer
-    // FIXME: do in normalizer
     if (nodes[0]?.[0] === '$') ctx.block[nodes.shift()] = ctx.block.length
 
     let t = nodes.shift();
@@ -754,13 +756,8 @@ const instr = (nodes, ctx) => {
     // (result i32) - doesn't require registering type
     // FIXME: Make sure it is signed positive integer (leb, not uleb) https://webassembly.github.io/gc/core/binary/instructions.html#control-instructions
     else if (t[0] === 'result') immed.push(...reftype(t[1], ctx))
-    else {
-      let typeidx = id(t[1], ctx.type), [param, result] = ctx.type[typeidx][1]
-      // (type $idx (func (result i32)))
-      if (!param?.length && result.length === 1) immed.push(...reftype(result[0], ctx))
-      // (type idx)
-      else immed.push(...uleb(typeidx))
-    }
+    // (type idx)
+    else immed.push(...uleb(id(t[1], ctx.type)))
   }
   // else
   else if (code === 5) { }