But no space before func opening paren to match convention

Author: lukewagner

design/mvp/CanonicalABI.md

@@ -1432,14 +1432,14 @@ Function and value types are recursively mangled into
 [`wit`](WIT.md)-compatible syntax:
 ```python
 def mangle_funcname(name, ft):
-  return '{name}: func {params} -> {results}'.format(
+  return '{name}: func{params} -> {results}'.format(
            name = name,
-           params = mangle_funcvec(ft.params),
-           results = mangle_funcvec(ft.results))
+           params = mangle_funcvec(ft.params, pre_space = False),
+           results = mangle_funcvec(ft.results, pre_space = True))
 
-def mangle_funcvec(es):
+def mangle_funcvec(es, pre_space):
   if len(es) == 1 and isinstance(es[0], ValType):
-    return mangle_valtype(es[0])
+    return (' ' if not pre_space else '') + mangle_valtype(es[0])
   assert(all(type(e) == tuple and len(e) == 2 for e in es))
   mangled_elems = (e[0] + ': ' + mangle_valtype(e[1]) for e in es)
   return '(' + ', '.join(mangled_elems) + ')'
@@ -1508,19 +1508,19 @@ As an example, given a component type:
     (export "bar" (func (param "x" u32) (param "y" u32) (result u32)))
   ))
   (import "v1" (value string))
-  (export "baz" (func (result string)))
+  (export "baz" (func (param string) (result string)))
   (export "v2" (value list<list<string>>))
 )
 ```
 the `canonical_module_type` would be:
 ```wasm
 (module
-  (import "" "foo: func () -> ()" (func))
-  (import "" "a.bar: func (x: u32, y: u32) -> u32" (func param i32 i32) (result i32))
+  (import "" "foo: func() -> ()" (func))
+  (import "" "a.bar: func(x: u32, y: u32) -> u32" (func param i32 i32) (result i32))
   (export "cabi_memory" (memory 0))
   (export "cabi_realloc" (func (param i32 i32 i32 i32) (result i32)))
   (export "cabi_start{cabi=0.1}: func (v1: string) -> (v2: list<list<string>>)" (func (param i32 i32) (result i32)))
-  (export "baz: func () -> string" (func (result i32)))
+  (export "baz: func string -> string" (func (param i32 i32) (result i32)))
   (export "cabi_post_baz" (func (param i32)))
 )
 ```

design/mvp/canonical-abi/definitions.py

@@ -1079,14 +1079,14 @@ def mangle_instances(xs, path = ''):
 #
 
 def mangle_funcname(name, ft):
-  return '{name}: func {params} -> {results}'.format(
+  return '{name}: func{params} -> {results}'.format(
            name = name,
-           params = mangle_funcvec(ft.params),
-           results = mangle_funcvec(ft.results))
+           params = mangle_funcvec(ft.params, pre_space = False),
+           results = mangle_funcvec(ft.results, pre_space = True))
 
-def mangle_funcvec(es):
+def mangle_funcvec(es, pre_space):
   if len(es) == 1 and isinstance(es[0], ValType):
-    return mangle_valtype(es[0])
+    return (' ' if not pre_space else '') + mangle_valtype(es[0])
   assert(all(type(e) == tuple and len(e) == 2 for e in es))
   mangled_elems = (e[0] + ': ' + mangle_valtype(e[1]) for e in es)
   return '(' + ', '.join(mangled_elems) + ')'

design/mvp/canonical-abi/run_tests.py

@@ -375,11 +375,11 @@ def test_mangle_functype(params, results, expect):
 
 test_mangle_functype([U8()], [U8()], 'func u8 -> u8')
 test_mangle_functype([U8()], [], 'func u8 -> ()')
-test_mangle_functype([], [U8()], 'func () -> u8')
-test_mangle_functype([('x',U8())], [('y',U8())], 'func (x: u8) -> (y: u8)')
+test_mangle_functype([], [U8()], 'func() -> u8')
+test_mangle_functype([('x',U8())], [('y',U8())], 'func(x: u8) -> (y: u8)')
 test_mangle_functype([('a',Bool()),('b',U8()),('c',S16()),('d',U32()),('e',S64())],
                      [('a',S8()),('b',U16()),('c',S32()),('d',U64())],
-                     'func (a: bool, b: u8, c: s16, d: u32, e: s64) -> (a: s8, b: u16, c: s32, d: u64)')
+                     'func(a: bool, b: u8, c: s16, d: u32, e: s64) -> (a: s8, b: u16, c: s32, d: u64)')
 test_mangle_functype([List(List(String()))], [],
                      'func list<list<string>> -> ()')
 test_mangle_functype([Record([Field('x',Record([Field('y',String())])),Field('z',U32())])], [],
@@ -393,7 +393,7 @@ def test_mangle_functype(params, results, expect):
 test_mangle_functype([Option(Bool())],[Option(List(U8()))],
                      'func option<bool> -> option<list<u8>>')
 test_mangle_functype([], [('a',Result(None,None)),('b',Result(U8(),None)),('c',Result(None,U8()))],
-                     'func () -> (a: result<_, _>, b: result<u8, _>, c: result<_, u8>)')
+                     'func() -> (a: result<_, _>, b: result<u8, _>, c: result<_, u8>)')
 
 def test_cabi(ct, expect):
   got = canonical_module_type(ct)
@@ -411,7 +411,7 @@ def test_cabi(ct, expect):
     [CoreImportDecl('','a: func u8 -> u8', CoreFuncType(['i32'],['i32']))],
     [CoreExportDecl('cabi_memory', CoreMemoryType(0, None)),
      CoreExportDecl('cabi_realloc', CoreFuncType(['i32','i32','i32','i32'],['i32'])),
-     CoreExportDecl('cabi_start{cabi=0.1}: func (b: string) -> (d: list<u8>)',
+     CoreExportDecl('cabi_start{cabi=0.1}: func(b: string) -> (d: list<u8>)',
                     CoreFuncType(['i32','i32'],['i32'])),
      CoreExportDecl('c: func s8 -> s8', CoreFuncType(['i32'],['i32']))]
   )
@@ -431,9 +431,9 @@ def test_cabi(ct, expect):
     [CoreImportDecl('','a.b: func u8 -> u8', CoreFuncType(['i32'],['i32']))],
     [CoreExportDecl('cabi_memory', CoreMemoryType(0, None)),
      CoreExportDecl('cabi_realloc', CoreFuncType(['i32','i32','i32','i32'],['i32'])),
-     CoreExportDecl('cabi_start{cabi=0.1}: func (a.c: float32) -> (d.f: float64)',
+     CoreExportDecl('cabi_start{cabi=0.1}: func(a.c: float32) -> (d.f: float64)',
                     CoreFuncType(['f32'],['f64'])),
-     CoreExportDecl('d.e: func () -> list<string>', CoreFuncType([],['i32'])),
+     CoreExportDecl('d.e: func() -> list<string>', CoreFuncType([],['i32'])),
      CoreExportDecl('cabi_post_d.e', CoreFuncType(['i32'],[]))]
   )
 )
@@ -444,17 +444,17 @@ def test_cabi(ct, expect):
        ExternDecl('bar', FuncType([('x', U32()),('y', U32())],[U32()]))
      ])),
      ExternDecl('v1', ValueType(String()))],
-    [ExternDecl('baz', FuncType([], [String()])),
+    [ExternDecl('baz', FuncType([String()], [String()])),
      ExternDecl('v2', ValueType(List(List(String()))))]
   ),
   ModuleType(
-    [CoreImportDecl('','foo: func () -> ()', CoreFuncType([],[])),
-     CoreImportDecl('','a.bar: func (x: u32, y: u32) -> u32', CoreFuncType(['i32','i32'],['i32']))],
+    [CoreImportDecl('','foo: func() -> ()', CoreFuncType([],[])),
+     CoreImportDecl('','a.bar: func(x: u32, y: u32) -> u32', CoreFuncType(['i32','i32'],['i32']))],
     [CoreExportDecl('cabi_memory', CoreMemoryType(0, None)),
      CoreExportDecl('cabi_realloc', CoreFuncType(['i32','i32','i32','i32'],['i32'])),
-     CoreExportDecl('cabi_start{cabi=0.1}: func (v1: string) -> (v2: list<list<string>>)',
+     CoreExportDecl('cabi_start{cabi=0.1}: func(v1: string) -> (v2: list<list<string>>)',
                     CoreFuncType(['i32','i32'],['i32'])),
-     CoreExportDecl('baz: func () -> string', CoreFuncType([],['i32'])),
+     CoreExportDecl('baz: func string -> string', CoreFuncType(['i32','i32'],['i32'])),
      CoreExportDecl('cabi_post_baz', CoreFuncType(['i32'],[]))]
   )
 )