Skip to content

Implement type imports and exports #7330

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 19 commits into
base: main
Choose a base branch
from
Open

Implement type imports and exports #7330

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
19 commits
Select commit Hold shift + click to select a range
c066fcd
Type imports
vouillon Feb 24, 2025
48cc48e
Add tests
vouillon Feb 25, 2025
9e527ef
Test updates
vouillon Feb 26, 2025
7e56d35
More test updates
vouillon Feb 26, 2025
df60079
Fix hashing and comparison
vouillon Feb 27, 2025
f098ced
Fuzzing updates
vouillon Feb 27, 2025
fce76ff
Validation fixes
vouillon Feb 27, 2025
e316807
Reuse the type-sorting code from ModuleUtils in wasm-merge
vouillon Feb 27, 2025
982ab07
Comment updates
vouillon Feb 27, 2025
6dfcdb9
Tests: name functions
vouillon Feb 27, 2025
22e093b
Rename Import to TypeImport
vouillon Feb 27, 2025
60bd789
Unnecessary include
vouillon Feb 27, 2025
bc7c3f8
Fix Subtypes::getMaxDepths
vouillon Feb 27, 2025
1541147
Merge remote-tracking branch 'origin/main' into type-imports
vouillon Mar 13, 2025
7da566f
fix
vouillon Mar 13, 2025
c989d27
Put type exports with other exports
vouillon Feb 27, 2025
ad45a6d
Fix tool options
vouillon Mar 14, 2025
aa1e4ae
format
vouillon Mar 14, 2025
682ab0f
Fix tool outputs
vouillon Mar 14, 2025
File filter

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Tests: name functions
  • Loading branch information
@vouillon
vouillon committed Feb 27, 2025
commit 6dfcdb973f4d00291574d0e28ee5e39ffcd8071c
50 changes: 25 additions & 25 deletions test/lit/basic/type-imports.wast
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,7 @@
;; CHECK: (import "env" "t2" (type $t2 (sub any)))
(import "env" "t2" (type $t2))

;; Alternative synyax with both import and export
;; Alternative syntax with both import and export
(type $t3 (export "t3") (import "env" "t3") (sub struct))

;; Use an imported type in a type
Expand All @@ -42,7 +42,26 @@
(import "env" "g" (func $g (param (ref $t1)) (result (ref $t2))))

;; Cast and function call involving imported types
(func (export "f1")
;; CHECK: (export "t3" (type $t3))

;; CHECK: (export "t5" (type $t5))

;; CHECK: (export "t2" (type $t2))

;; CHECK: (export "t4" (type $t4))

;; CHECK: (export "f1" (func $f1))

;; CHECK: (export "f2" (func $f2))

;; CHECK: (func $f1 (type $6) (param $x (ref eq)) (param $1 (ref $t2)) (param $2 (ref $t3)) (param $3 (ref $t4)) (result (ref $t2))
;; CHECK-NEXT: (call $g
;; CHECK-NEXT: (ref.cast (ref $t1)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $f1 (export "f1")
(param $x (ref eq)) (param (ref $t2) (ref $t3) (ref $t4)) (result (ref $t2))
(call $g
(ref.cast (ref $t1)
Expand All @@ -52,41 +71,22 @@
)

;; Check that the imported type is a subtype of its bound
(func (export "f2") (param $x (ref $t3)) (result (ref struct))
;; CHECK: (func $f2 (type $7) (param $x (ref $t3)) (result (ref struct))
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
(func $f2 (export "f2") (param $x (ref $t3)) (result (ref struct))
(local.get $x)
)

;; Reexport an imported type
;; CHECK: (export "t3" (type $t3))

;; CHECK: (export "t5" (type $t5))

;; CHECK: (export "t2" (type $t2))
(export "t2" (type $t2))

;; Export a type defined in this module
;; CHECK: (export "t4" (type $t4))
(export "t4" (type $t4))

;; Export an abstract heap type
(export "t6" (type extern))
)
;; CHECK: (export "f1" (func $0))

;; CHECK: (export "f2" (func $1))

;; CHECK: (func $0 (type $6) (param $x (ref eq)) (param $1 (ref $t2)) (param $2 (ref $t3)) (param $3 (ref $t4)) (result (ref $t2))
;; CHECK-NEXT: (call $g
;; CHECK-NEXT: (ref.cast (ref $t1)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )

;; CHECK: (func $1 (type $7) (param $x (ref $t3)) (result (ref struct))
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )

;; CHECK-BIN-NODEBUG: (import "env" "t1" (type $0 (sub eq)))

;; CHECK-BIN-NODEBUG: (import "env" "t2" (type $1 (sub any)))
Expand Down
148 changes: 72 additions & 76 deletions test/lit/merge/type-imports.wat
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,113 +21,109 @@
(import "second" "g" (func $g (param (ref $t2))))

;; Check that the function parameters are updated
(func (export "f") (param (ref $t1) (ref $t2) (ref $t3) (ref $t4))
;; CHECK: (type $t2 (array i8))

;; CHECK: (rec
;; CHECK-NEXT: (type $r1 (struct (field (ref $r1)) (field (ref $r2)) (field (ref eq))))

;; CHECK: (type $r2 (struct (field (ref $r1)) (field (ref $r2)) (field (ref $t2))))

;; CHECK: (type $5 (func (param (ref eq) (ref $t2) (ref $t3) (ref $t4))))

;; CHECK: (type $6 (func (param (ref any)) (result (ref eq))))

;; CHECK: (type $7 (func (param (ref any)) (result (ref $t2))))

;; CHECK: (type $8 (func (param (ref any)) (result (ref $t3))))

;; CHECK: (type $9 (func (param (ref any)) (result (ref $t4))))

;; CHECK: (type $10 (func (param (ref eq)) (result (ref $r1))))

;; CHECK: (type $11 (func (param (ref $t2))))

;; CHECK: (export "t2" (type $t2))

;; CHECK: (export "t3" (type $t3))

;; CHECK: (export "f" (func $f))

;; CHECK: (export "g1" (func $g1))

;; CHECK: (export "g2" (func $g2))

;; CHECK: (export "g3" (func $g3))

;; CHECK: (export "g4" (func $g4))

;; CHECK: (export "h" (func $h))

;; CHECK: (export "g" (func $g_7))

;; CHECK: (func $f (type $5) (param $0 (ref eq)) (param $1 (ref $t2)) (param $2 (ref $t3)) (param $3 (ref $t4))
;; CHECK-NEXT: )
(func $f (export "f") (param (ref $t1) (ref $t2) (ref $t3) (ref $t4))
)

;; Check that types in instructions are also updated
(func (export "g1") (param $x (ref any)) (result (ref $t1))
;; CHECK: (func $g1 (type $6) (param $x (ref any)) (result (ref eq))
;; CHECK-NEXT: (ref.cast (ref eq)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $g1 (export "g1") (param $x (ref any)) (result (ref $t1))
(ref.cast (ref $t1)
(local.get $x)
)
)

(func (export "g2") (param $x (ref any)) (result (ref $t2))
;; CHECK: (func $g2 (type $7) (param $x (ref any)) (result (ref $t2))
;; CHECK-NEXT: (ref.cast (ref $t2)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $g2 (export "g2") (param $x (ref any)) (result (ref $t2))
(ref.cast (ref $t2)
(local.get $x)
)
)

(func (export "g3") (param $x (ref any)) (result (ref $t3))
;; CHECK: (func $g3 (type $8) (param $x (ref any)) (result (ref $t3))
;; CHECK-NEXT: (ref.cast (ref $t3)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $g3 (export "g3") (param $x (ref any)) (result (ref $t3))
(ref.cast (ref $t3)
(local.get $x)
)
)

(func (export "g4") (param $x (ref any)) (result (ref $t4))
;; CHECK: (func $g4 (type $9) (param $x (ref any)) (result (ref $t4))
;; CHECK-NEXT: (ref.cast (ref $t4)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $g4 (export "g4") (param $x (ref any)) (result (ref $t4))
(ref.cast (ref $t4)
(local.get $x)
)
)

;; Check that recursive types are preserved
(rec
;; CHECK: (type $t2 (array i8))

;; CHECK: (rec
;; CHECK-NEXT: (type $r1 (struct (field (ref $r1)) (field (ref $r2)) (field (ref eq))))
(type $r1 (struct (field (ref $r1) (ref $r2) (ref $t1))))
;; CHECK: (type $r2 (struct (field (ref $r1)) (field (ref $r2)) (field (ref $t2))))
(type $r2 (struct (field (ref $r1) (ref $r2) (ref $t2))))
)

(func (export "h") (param $x (ref eq)) (result (ref $r1))
;; CHECK: (func $h (type $10) (param $x (ref eq)) (result (ref $r1))
;; CHECK-NEXT: (ref.cast (ref $r1)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $h (export "h") (param $x (ref eq)) (result (ref $r1))
(ref.cast (ref $r1) (local.get $x)))
)

;; CHECK: (type $5 (func (param (ref eq) (ref $t2) (ref $t3) (ref $t4))))

;; CHECK: (type $6 (func (param (ref any)) (result (ref eq))))

;; CHECK: (type $7 (func (param (ref any)) (result (ref $t2))))

;; CHECK: (type $8 (func (param (ref any)) (result (ref $t3))))

;; CHECK: (type $9 (func (param (ref any)) (result (ref $t4))))

;; CHECK: (type $10 (func (param (ref eq)) (result (ref $r1))))

;; CHECK: (type $11 (func (param (ref $t2))))

;; CHECK: (export "t2" (type $t2))

;; CHECK: (export "t3" (type $t3))

;; CHECK: (export "f" (func $0))

;; CHECK: (export "g1" (func $1))

;; CHECK: (export "g2" (func $2))

;; CHECK: (export "g3" (func $3))

;; CHECK: (export "g4" (func $4))

;; CHECK: (export "h" (func $5))

;; CHECK: (export "g" (func $g_7))

;; CHECK: (func $0 (type $5) (param $0 (ref eq)) (param $1 (ref $t2)) (param $2 (ref $t3)) (param $3 (ref $t4))
;; CHECK-NEXT: )

;; CHECK: (func $1 (type $6) (param $x (ref any)) (result (ref eq))
;; CHECK-NEXT: (ref.cast (ref eq)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )

;; CHECK: (func $2 (type $7) (param $x (ref any)) (result (ref $t2))
;; CHECK-NEXT: (ref.cast (ref $t2)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )

;; CHECK: (func $3 (type $8) (param $x (ref any)) (result (ref $t3))
;; CHECK-NEXT: (ref.cast (ref $t3)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )

;; CHECK: (func $4 (type $9) (param $x (ref any)) (result (ref $t4))
;; CHECK-NEXT: (ref.cast (ref $t4)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )

;; CHECK: (func $5 (type $10) (param $x (ref eq)) (result (ref $r1))
;; CHECK-NEXT: (ref.cast (ref $r1)
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )

;; CHECK: (func $g_7 (type $11) (param $0 (ref $t2))
;; CHECK-NEXT: )