More spaces in the name mangling scheme

Author: lukewagner

design/mvp/CanonicalABI.md

@@ -1441,7 +1441,7 @@ def mangle_funcvec(es):
   if len(es) == 1 and isinstance(es[0], ValType):
     return 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)
+  mangled_elems = (e[0] + ': ' + mangle_valtype(e[1]) for e in es)
   return '(' + ', '.join(mangled_elems) + ')'
 
 def mangle_valtype(t):
@@ -1470,24 +1470,24 @@ def mangle_valtype(t):
     case Result(ok,error) : return mangle_resulttype(ok,error)
 
 def mangle_recordtype(fields):
-  mangled_fields = (f.label + ':' + mangle_valtype(f.t) for f in fields)
-  return 'record{' + ', '.join(mangled_fields) + '}'
+  mangled_fields = (f.label + ': ' + mangle_valtype(f.t) for f in fields)
+  return 'record { ' + ', '.join(mangled_fields) + ' }'
 
 def mangle_tupletype(ts):
   return 'tuple<' + ', '.join(mangle_valtype(t) for t in ts) + '>'
 
 def mangle_flags(labels):
-  return 'flags{' + ', '.join(labels) + '}'
+  return 'flags { ' + ', '.join(labels) + ' }'
 
 def mangle_varianttype(cases):
   mangled_cases = (c.label + '(' + mangle_maybevaltype(c.t) + ')' for c in cases)
-  return 'variant{' + ', '.join(mangled_cases) + '}'
+  return 'variant { ' + ', '.join(mangled_cases) + ' }'
 
 def mangle_enumtype(labels):
-  return 'enum{' + ', '.join(labels) + '}'
+  return 'enum { ' + ', '.join(labels) + ' }'
 
 def mangle_uniontype(ts):
-  return 'union{' + ', '.join(mangle_valtype(t) for t in ts) + '}'
+  return 'union { ' + ', '.join(mangle_valtype(t) for t in ts) + ' }'
 
 def mangle_optiontype(t):
   return 'option<' + mangle_valtype(t) + '>'
@@ -1516,12 +1516,12 @@ 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))
-  (export "_memory" (memory 0))
-  (export "_realloc" (func (param i32 i32 i32 i32) (result i32)))
-  (export "_start{cabi=0.1}: func (v1:string) -> (v2:list<list<string>>)" (func (param i32 i32) (result i32)))
+  (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 "_post-baz" (func (param i32)))
+  (export "cabi_post_baz" (func (param i32)))
 )
 ```
 

design/mvp/canonical-abi/definitions.py

@@ -1088,7 +1088,7 @@ def mangle_funcvec(es):
   if len(es) == 1 and isinstance(es[0], ValType):
     return 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)
+  mangled_elems = (e[0] + ': ' + mangle_valtype(e[1]) for e in es)
   return '(' + ', '.join(mangled_elems) + ')'
 
 def mangle_valtype(t):
@@ -1117,24 +1117,24 @@ def mangle_valtype(t):
     case Result(ok,error) : return mangle_resulttype(ok,error)
 
 def mangle_recordtype(fields):
-  mangled_fields = (f.label + ':' + mangle_valtype(f.t) for f in fields)
-  return 'record{' + ', '.join(mangled_fields) + '}'
+  mangled_fields = (f.label + ': ' + mangle_valtype(f.t) for f in fields)
+  return 'record { ' + ', '.join(mangled_fields) + ' }'
 
 def mangle_tupletype(ts):
   return 'tuple<' + ', '.join(mangle_valtype(t) for t in ts) + '>'
 
 def mangle_flags(labels):
-  return 'flags{' + ', '.join(labels) + '}'
+  return 'flags { ' + ', '.join(labels) + ' }'
 
 def mangle_varianttype(cases):
   mangled_cases = (c.label + '(' + mangle_maybevaltype(c.t) + ')' for c in cases)
-  return 'variant{' + ', '.join(mangled_cases) + '}'
+  return 'variant { ' + ', '.join(mangled_cases) + ' }'
 
 def mangle_enumtype(labels):
-  return 'enum{' + ', '.join(labels) + '}'
+  return 'enum { ' + ', '.join(labels) + ' }'
 
 def mangle_uniontype(ts):
-  return 'union{' + ', '.join(mangle_valtype(t) for t in ts) + '}'
+  return 'union { ' + ', '.join(mangle_valtype(t) for t in ts) + ' }'
 
 def mangle_optiontype(t):
   return 'option<' + mangle_valtype(t) + '>'

design/mvp/canonical-abi/run_tests.py

@@ -371,29 +371,29 @@ def test_mangle_functype(params, results, expect):
   got = mangle_funcname('x', ft)
   expect = 'x: ' + expect
   if got != expect:
-    fail("test_mangle_func({}) expected {}, got {}".format(ft, expect, got))
+    fail("test_mangle_func() got:\n  {}\nexpected:\n  {}".format(got, 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([('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())])], [],
-                     'func record{x:record{y:string}, z:u32} -> ()')
+                     'func record { x: record { y: string }, z: u32 } -> ()')
 test_mangle_functype([Tuple([U8()])], [Tuple([U8(),U8()])],
                      'func tuple<u8> -> tuple<u8, u8>')
 test_mangle_functype([Flags(['a','b'])], [Enum(['a','b'])],
-                     'func flags{a, b} -> enum{a, b}')
+                     'func flags { a, b } -> enum { a, b }')
 test_mangle_functype([Variant([Case('a',None),Case('b',U8())])], [Union([U8(),List(String())])],
-                     'func variant{a(_), b(u8)} -> union{u8, list<string>}')
+                     'func variant { a(_), b(u8) } -> union { u8, list<string> }')
 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,7 +431,7 @@ 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('cabi_post_d.e', CoreFuncType(['i32'],[]))]
@@ -449,10 +449,10 @@ def test_cabi(ct, expect):
   ),
   ModuleType(
     [CoreImportDecl('','foo: func () -> ()', CoreFuncType([],[])),
-     CoreImportDecl('','a.bar: func (x:u32, y:u32) -> u32', CoreFuncType(['i32','i32'],['i32']))],
+     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('cabi_post_baz', CoreFuncType(['i32'],[]))]