From 0f1efe04c39bb2994f8ef96101a57cccfe0effa8 Mon Sep 17 00:00:00 2001 From: James Price Date: Fri, 11 Jun 2021 12:46:26 +0000 Subject: [PATCH] writer/msl: Fix texture intrinsic generation Wrap the texture expression in parentheses when it has lower precendence than the function call operator. Cast integer coordinates to unsigned integers as required by MSL. Fixed: tint:536 Change-Id: I957e6be3c51044959e25e0be96c2d2c65db18187 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/53962 Kokoro: Kokoro Commit-Queue: James Price Reviewed-by: Ben Clayton --- src/writer/msl/generator_impl.cc | 61 +++++++++++++++-- .../generator_impl_intrinsic_texture_test.cc | 50 +++++++------- .../storage_texture.wgsl.expected.msl | 17 +---- .../gen/ignore/5016e5.wgsl.expected.msl | 26 +++---- .../gen/ignore/509355.wgsl.expected.msl | 26 +++---- .../gen/ignore/5c9edf.wgsl.expected.msl | 26 +++---- .../gen/ignore/ad88be.wgsl.expected.msl | 26 +++---- .../gen/ignore/b469af.wgsl.expected.msl | 26 +++---- .../gen/ignore/c8a0ee.wgsl.expected.msl | 26 +++---- .../gen/ignore/e0187b.wgsl.expected.msl | 26 +++---- .../002b2a.wgsl.expected.msl | 37 +++++----- .../012b82.wgsl.expected.msl | 40 +++++------ .../08753d.wgsl.expected.msl | 37 +++++----- .../08a62e.wgsl.expected.msl | 37 +++++----- .../0a5fcf.wgsl.expected.msl | 40 +++++------ .../0bab57.wgsl.expected.msl | 43 +++++------- .../0c4772.wgsl.expected.msl | 43 +++++------- .../0cce40.wgsl.expected.msl | 37 +++++----- .../0cf2ff.wgsl.expected.msl | 40 +++++------ .../0d8b7e.wgsl.expected.msl | 40 +++++------ .../0e32ee.wgsl.expected.msl | 43 +++++------- .../0f3c50.wgsl.expected.msl | 40 +++++------ .../1147d6.wgsl.expected.msl | 40 +++++------ .../1191a5.wgsl.expected.msl | 40 +++++------ .../12c9bb.wgsl.expected.msl | 40 +++++------ .../147998.wgsl.expected.msl | 40 +++++------ .../16036c.wgsl.expected.msl | 40 +++++------ .../168fcc.wgsl.expected.msl | 40 +++++------ .../183b3e.wgsl.expected.msl | 43 +++++------- .../18bd57.wgsl.expected.msl | 40 +++++------ .../19bffc.wgsl.expected.msl | 43 +++++------- .../1a58e7.wgsl.expected.msl | 40 +++++------ .../1aa199.wgsl.expected.msl | 40 +++++------ .../1b71f0.wgsl.expected.msl | 43 +++++------- .../1d6c26.wgsl.expected.msl | 40 +++++------ .../1e189c.wgsl.expected.msl | 43 +++++------- .../1e9e39.wgsl.expected.msl | 37 +++++----- .../1ebd6a.wgsl.expected.msl | 43 +++++------- .../1f20c5.wgsl.expected.msl | 40 +++++------ .../214b7b.wgsl.expected.msl | 37 +++++----- .../214dd4.wgsl.expected.msl | 43 +++++------- .../267788.wgsl.expected.msl | 40 +++++------ .../26bdfa.wgsl.expected.msl | 43 +++++------- .../26ef6c.wgsl.expected.msl | 40 +++++------ .../2ad087.wgsl.expected.msl | 40 +++++------ .../2d32ae.wgsl.expected.msl | 43 +++++------- .../2e0662.wgsl.expected.msl | 40 +++++------ .../2efa05.wgsl.expected.msl | 43 +++++------- .../2f289f.wgsl.expected.msl | 43 +++++------- .../2fe1cc.wgsl.expected.msl | 40 +++++------ .../318ecc.wgsl.expected.msl | 37 +++++----- .../340d06.wgsl.expected.msl | 43 +++++------- .../398e30.wgsl.expected.msl | 40 +++++------ .../39a600.wgsl.expected.msl | 40 +++++------ .../3a94ea.wgsl.expected.msl | 40 +++++------ .../3aca08.wgsl.expected.msl | 37 +++++----- .../3c5ad8.wgsl.expected.msl | 40 +++++------ .../3d5817.wgsl.expected.msl | 37 +++++----- .../3e0403.wgsl.expected.msl | 43 +++++------- .../3e626d.wgsl.expected.msl | 43 +++++------- .../40bc10.wgsl.expected.msl | 37 +++++----- .../423f99.wgsl.expected.msl | 37 +++++----- .../4267ee.wgsl.expected.msl | 40 +++++------ .../42d4e6.wgsl.expected.msl | 37 +++++----- .../441392.wgsl.expected.msl | 37 +++++----- .../48cb89.wgsl.expected.msl | 40 +++++------ .../48cbb2.wgsl.expected.msl | 40 +++++------ .../48f360.wgsl.expected.msl | 40 +++++------ .../49d274.wgsl.expected.msl | 40 +++++------ .../4df9a8.wgsl.expected.msl | 37 +++++----- .../55b23e.wgsl.expected.msl | 37 +++++----- .../56ccfa.wgsl.expected.msl | 43 +++++------- .../579629.wgsl.expected.msl | 40 +++++------ .../57da0b.wgsl.expected.msl | 37 +++++----- .../57e7b3.wgsl.expected.msl | 43 +++++------- .../58a515.wgsl.expected.msl | 40 +++++------ .../5985f3.wgsl.expected.msl | 40 +++++------ .../5caa5e.wgsl.expected.msl | 37 +++++----- .../5e295d.wgsl.expected.msl | 40 +++++------ .../5ec4e1.wgsl.expected.msl | 43 +++++------- .../60bf54.wgsl.expected.msl | 43 +++++------- .../63f3cf.wgsl.expected.msl | 43 +++++------- .../66dc4e.wgsl.expected.msl | 40 +++++------ .../670d90.wgsl.expected.msl | 43 +++++------- .../68105c.wgsl.expected.msl | 40 +++++------ .../6adac6.wgsl.expected.msl | 37 +++++----- .../6c08ab.wgsl.expected.msl | 37 +++++----- .../6e2d12.wgsl.expected.msl | 37 +++++----- .../6ec1b4.wgsl.expected.msl | 43 +++++------- .../6f0d79.wgsl.expected.msl | 40 +++++------ .../702c53.wgsl.expected.msl | 40 +++++------ .../70e26a.wgsl.expected.msl | 37 +++++----- .../71e8f7.wgsl.expected.msl | 40 +++++------ .../72e5d6.wgsl.expected.msl | 40 +++++------ .../75be9d.wgsl.expected.msl | 43 +++++------- .../76e722.wgsl.expected.msl | 43 +++++------- .../770103.wgsl.expected.msl | 43 +++++------- .../7bb707.wgsl.expected.msl | 43 +++++------- .../7bf826.wgsl.expected.msl | 40 +++++------ .../7f5c2e.wgsl.expected.msl | 40 +++++------ .../8028f3.wgsl.expected.msl | 43 +++++------- .../811679.wgsl.expected.msl | 43 +++++------- .../820596.wgsl.expected.msl | 43 +++++------- .../82138e.wgsl.expected.msl | 40 +++++------ .../8347ab.wgsl.expected.msl | 37 +++++----- .../83ee5a.wgsl.expected.msl | 40 +++++------ .../85d556.wgsl.expected.msl | 40 +++++------ .../8799ee.wgsl.expected.msl | 43 +++++------- .../89a864.wgsl.expected.msl | 40 +++++------ .../8aa4c4.wgsl.expected.msl | 43 +++++------- .../8b4fff.wgsl.expected.msl | 40 +++++------ .../8d89f8.wgsl.expected.msl | 37 +++++----- .../8deb5e.wgsl.expected.msl | 43 +++++------- .../8fca0f.wgsl.expected.msl | 43 +++++------- .../9042ab.wgsl.expected.msl | 40 +++++------ .../91f42d.wgsl.expected.msl | 43 +++++------- .../924742.wgsl.expected.msl | 43 +++++------- .../92ad20.wgsl.expected.msl | 43 +++++------- .../939fdb.wgsl.expected.msl | 40 +++++------ .../9572e5.wgsl.expected.msl | 43 +++++------- .../998f6b.wgsl.expected.msl | 40 +++++------ .../9abfe5.wgsl.expected.msl | 40 +++++------ .../9c9c57.wgsl.expected.msl | 40 +++++------ .../9da9e2.wgsl.expected.msl | 37 +++++----- .../9eb8d8.wgsl.expected.msl | 40 +++++------ .../9f8e46.wgsl.expected.msl | 40 +++++------ .../a0aad1.wgsl.expected.msl | 40 +++++------ .../a0e4ec.wgsl.expected.msl | 43 +++++------- .../a6ca1c.wgsl.expected.msl | 43 +++++------- .../a7d565.wgsl.expected.msl | 37 +++++----- .../a863f2.wgsl.expected.msl | 37 +++++----- .../ae457f.wgsl.expected.msl | 40 +++++------ .../b0e16d.wgsl.expected.msl | 40 +++++------ .../b91240.wgsl.expected.msl | 40 +++++------ .../ba1481.wgsl.expected.msl | 40 +++++------ .../ba6e15.wgsl.expected.msl | 40 +++++------ .../bb3dde.wgsl.expected.msl | 43 +++++------- .../bdf2ee.wgsl.expected.msl | 43 +++++------- .../c2215f.wgsl.expected.msl | 40 +++++------ .../c30e75.wgsl.expected.msl | 40 +++++------ .../c60b66.wgsl.expected.msl | 37 +++++----- .../c74533.wgsl.expected.msl | 40 +++++------ .../c7943d.wgsl.expected.msl | 40 +++++------ .../caaabb.wgsl.expected.msl | 40 +++++------ .../cc5478.wgsl.expected.msl | 37 +++++----- .../cc968c.wgsl.expected.msl | 37 +++++----- .../cccc17.wgsl.expected.msl | 43 +++++------- .../cccc8f.wgsl.expected.msl | 37 +++++----- .../cd76a7.wgsl.expected.msl | 43 +++++------- .../cdaff9.wgsl.expected.msl | 43 +++++------- .../cdf473.wgsl.expected.msl | 40 +++++------ .../cec841.wgsl.expected.msl | 40 +++++------ .../cf1d42.wgsl.expected.msl | 37 +++++----- .../cf7e43.wgsl.expected.msl | 43 +++++------- .../d40b9e.wgsl.expected.msl | 40 +++++------ .../d4106f.wgsl.expected.msl | 40 +++++------ .../d8f951.wgsl.expected.msl | 37 +++++----- .../da3099.wgsl.expected.msl | 43 +++++------- .../daf7c0.wgsl.expected.msl | 40 +++++------ .../dba47c.wgsl.expected.msl | 37 +++++----- .../dc2dd0.wgsl.expected.msl | 37 +++++----- .../e10157.wgsl.expected.msl | 40 +++++------ .../e22247.wgsl.expected.msl | 43 +++++------- .../e93464.wgsl.expected.msl | 37 +++++----- .../e9628c.wgsl.expected.msl | 40 +++++------ .../e9e96c.wgsl.expected.msl | 40 +++++------ .../e9fe54.wgsl.expected.msl | 40 +++++------ .../e9fe58.wgsl.expected.msl | 40 +++++------ .../eda4e3.wgsl.expected.msl | 43 +++++------- .../ef5b89.wgsl.expected.msl | 40 +++++------ .../efc8a4.wgsl.expected.msl | 43 +++++------- .../f1b72b.wgsl.expected.msl | 40 +++++------ .../f507c9.wgsl.expected.msl | 43 +++++------- .../f70326.wgsl.expected.msl | 43 +++++------- .../f7145b.wgsl.expected.msl | 40 +++++------ .../f7aa9e.wgsl.expected.msl | 40 +++++------ .../f7e436.wgsl.expected.msl | 40 +++++------ .../f931c7.wgsl.expected.msl | 40 +++++------ .../fa90e1.wgsl.expected.msl | 40 +++++------ .../fa9859.wgsl.expected.msl | 40 +++++------ .../fb5670.wgsl.expected.msl | 40 +++++------ .../fbbe4d.wgsl.expected.msl | 43 +++++------- .../fcac78.wgsl.expected.msl | 43 +++++------- .../gen/textureLoad/050c33.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/072e26.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/078bc4.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/127e12.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/1561a7.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/19cf87.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/1a062f.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/1a8452.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/1b8588.wgsl.expected.msl | 67 ++++++++++++++----- .../gen/textureLoad/1f2016.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/20fa2f.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/276a2c.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/2887d7.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/2ae485.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/2d6cf7.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/3c0d9e.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/3c9587.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/3d001b.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/3d9c90.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/484344.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/4fd803.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/505aa2.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/519ab5.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/53378a.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/560573.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/582015.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/5a2f9d.wgsl.expected.msl | 67 ++++++++++++++----- .../gen/textureLoad/5bb7fb.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/5d0a2f.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/6154d4.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/62d125.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/6678b6.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/67edca.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/749704.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/79e697.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/7c90e5.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/81c381.wgsl.expected.msl | 67 ++++++++++++++----- .../gen/textureLoad/83cea4.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/87be85.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/8acf41.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/8e5032.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/936952.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/9a7c90.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/9b2667.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/9c2a14.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/a583c9.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/a6a85a.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/a6b61d.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/a7a3c3.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/a9a9f5.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/b1bf79.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/b58c6d.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/b6c458.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/bfd154.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c02b74.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c07013.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c2a480.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c378ee.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c40dcb.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c456bc.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c7cbed.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/c9cc40.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/d5c48d.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/d81c57.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/d8617f.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/dbd554.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/ddeed3.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/dee8e7.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/e3d2cc.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/e65916.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/e893d7.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/eb573b.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/ecc823.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/ef5405.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/f06b69.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/f379e2.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/f56e6f.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/f74bd8.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/fc6d36.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/fdebd0.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/fe222a.wgsl.expected.msl | 37 +++++----- .../gen/textureLoad/feab99.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/024820.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/053df7.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/058cc3.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/09d05d.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/13b4ce.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/22e53b.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/2f6bb3.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/315298.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/3615e3.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/390fd5.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/45155d.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/4bf67b.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/562013.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/57092f.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/5d59cd.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/68a65b.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/778bd1.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/7f1937.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/85f980.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/87953e.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/893e7c.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/938763.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/9700fb.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/a216d2.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/aa08a7.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/ab0c9b.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/b8cd76.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/be1d70.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/be3acb.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/c09917.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/c7c7f2.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/cd5dc8.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/d5b228.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/e15642.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/e31be1.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/e653c0.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/ee942f.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/f33005.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/fcec98.wgsl.expected.msl | 37 +++++----- .../textureNumLayers/ff5e89.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/076cb5.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/080d95.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/09ddd0.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/105988.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/23f750.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/2c3575.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/5101cf.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/897aaf.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/9da7a5.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/a91c03.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/aee7c8.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/b1b12b.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/b4f5ea.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/d004a9.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/dca09e.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/e67231.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/ed078b.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/f46ec6.wgsl.expected.msl | 37 +++++----- .../textureNumLevels/f5828d.wgsl.expected.msl | 37 +++++----- .../2c6f14.wgsl.expected.msl | 37 +++++----- .../42f8bb.wgsl.expected.msl | 37 +++++----- .../449d23.wgsl.expected.msl | 37 +++++----- .../textureSample/02aa9b.wgsl.expected.msl | 21 ++---- .../textureSample/100dc0.wgsl.expected.msl | 21 ++---- .../textureSample/38bbb9.wgsl.expected.msl | 21 ++---- .../textureSample/3b50bd.wgsl.expected.msl | 21 ++---- .../textureSample/4dd1bf.wgsl.expected.msl | 21 ++---- .../textureSample/51b514.wgsl.expected.msl | 21 ++---- .../textureSample/667d76.wgsl.expected.msl | 21 ++---- .../textureSample/6717ca.wgsl.expected.msl | 21 ++---- .../textureSample/6e64fb.wgsl.expected.msl | 21 ++---- .../textureSample/7c3baa.wgsl.expected.msl | 21 ++---- .../textureSample/7e9ffd.wgsl.expected.msl | 21 ++---- .../textureSample/8522e7.wgsl.expected.msl | 21 ++---- .../textureSample/bb81ce.wgsl.expected.msl | 21 ++---- .../textureSample/c2f4e8.wgsl.expected.msl | 21 ++---- .../textureSample/e53267.wgsl.expected.msl | 21 ++---- .../textureSample/ea7030.wgsl.expected.msl | 21 ++---- .../53b9f7.wgsl.expected.msl | 21 ++---- .../65ac50.wgsl.expected.msl | 21 ++---- .../6a9113.wgsl.expected.msl | 21 ++---- .../80e579.wgsl.expected.msl | 21 ++---- .../81c19a.wgsl.expected.msl | 21 ++---- .../d3fa1b.wgsl.expected.msl | 21 ++---- .../df91bb.wgsl.expected.msl | 21 ++---- .../eed7c4.wgsl.expected.msl | 21 ++---- .../25fcd1.wgsl.expected.msl | 21 ++---- .../3a5923.wgsl.expected.msl | 21 ++---- .../63fb83.wgsl.expected.msl | 21 ++---- .../98b85c.wgsl.expected.msl | 21 ++---- .../a3ca7e.wgsl.expected.msl | 21 ++---- .../dd431d.wgsl.expected.msl | 21 ++---- .../21402b.wgsl.expected.msl | 40 +++++------ .../2ecd8f.wgsl.expected.msl | 40 +++++------ .../468f88.wgsl.expected.msl | 40 +++++------ .../521263.wgsl.expected.msl | 40 +++++------ .../5312f4.wgsl.expected.msl | 40 +++++------ .../872f00.wgsl.expected.msl | 40 +++++------ .../e383db.wgsl.expected.msl | 40 +++++------ .../e9a2f7.wgsl.expected.msl | 40 +++++------ .../02be59.wgsl.expected.msl | 40 +++++------ .../0bdd9a.wgsl.expected.msl | 40 +++++------ .../1b0291.wgsl.expected.msl | 40 +++++------ .../1bf73e.wgsl.expected.msl | 40 +++++------ .../302be4.wgsl.expected.msl | 40 +++++------ .../47daa4.wgsl.expected.msl | 40 +++++------ .../690d95.wgsl.expected.msl | 40 +++++------ .../979816.wgsl.expected.msl | 40 +++++------ .../9bd37b.wgsl.expected.msl | 40 +++++------ .../a4af26.wgsl.expected.msl | 40 +++++------ .../abfcc0.wgsl.expected.msl | 40 +++++------ .../ae5e39.wgsl.expected.msl | 40 +++++------ .../ba93b3.wgsl.expected.msl | 40 +++++------ .../c32df7.wgsl.expected.msl | 40 +++++------ .../c6aca6.wgsl.expected.msl | 40 +++++------ .../gen/textureStore/05ce15.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/064c7f.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/068641.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/0af6b5.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/0c3dff.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/102722.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/1bbd08.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/1c02e7.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/22d955.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/26bf70.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/2796b4.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/2ac6c7.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/2eb2a4.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/2ed2a3.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/31745b.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/32f368.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/331aee.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/38e8d7.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/3a52ac.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/3bb7a1.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/3bec15.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/441ba8.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/4fc057.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/5a2f8f.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/60975f.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/682fd6.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/6b75c3.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/6b80d2.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/6cff2e.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/6da692.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/731349.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/752da6.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/77c0ae.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/7cec8d.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/7f7fae.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/804942.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/805dae.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/83bcc1.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/872747.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/8e0479.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/8f71a1.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/969534.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/9a3ecc.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/9d9cd5.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/9e3ec5.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/ac67aa.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/b706b1.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/bbcb7f.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/be6e30.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/bf775c.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/c5af1e.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/c863be.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/d73b5c.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/dd7d81.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/dde364.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/e885e8.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/eb702f.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/eb78b9.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/ee6acc.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/ef9f2f.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/f8dead.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/f9be83.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/fb9a8f.wgsl.expected.msl | 37 +++++----- .../gen/textureStore/fbf53f.wgsl.expected.msl | 37 +++++----- 444 files changed, 6831 insertions(+), 9792 deletions(-) diff --git a/src/writer/msl/generator_impl.cc b/src/writer/msl/generator_impl.cc index 08982b9341..0b42222dc0 100644 --- a/src/writer/msl/generator_impl.cc +++ b/src/writer/msl/generator_impl.cc @@ -531,6 +531,27 @@ bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr, auto* texture_type = TypeOf(texture)->UnwrapRef()->As(); + // Helper to emit the texture expression, wrapped in parentheses if the + // expression includes an operator with lower precedence than the member + // accessor used for the function calls. + auto texture_expr = [&]() { + bool paren_lhs = + !texture + ->IsAnyOf(); + if (paren_lhs) { + out_ << "("; + } + if (!EmitExpression(texture)) { + return false; + } + if (paren_lhs) { + out_ << ")"; + } + return true; + }; + switch (intrinsic->Type()) { case sem::IntrinsicType::kTextureDimensions: { std::vector dims; @@ -557,7 +578,7 @@ bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr, } auto get_dim = [&](const char* name) { - if (!EmitExpression(texture)) { + if (!texture_expr()) { return false; } out_ << ".get_" << name << "("; @@ -589,7 +610,7 @@ bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr, } case sem::IntrinsicType::kTextureNumLayers: { out_ << "int("; - if (!EmitExpression(texture)) { + if (!texture_expr()) { return false; } out_ << ".get_array_size())"; @@ -597,7 +618,7 @@ bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr, } case sem::IntrinsicType::kTextureNumLevels: { out_ << "int("; - if (!EmitExpression(texture)) { + if (!texture_expr()) { return false; } out_ << ".get_num_mip_levels())"; @@ -605,7 +626,7 @@ bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr, } case sem::IntrinsicType::kTextureNumSamples: { out_ << "int("; - if (!EmitExpression(texture)) { + if (!texture_expr()) { return false; } out_ << ".get_num_samples())"; @@ -615,8 +636,9 @@ bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr, break; } - if (!EmitExpression(texture)) + if (!texture_expr()) { return false; + } bool lod_param_is_named = true; @@ -655,9 +677,38 @@ bool GeneratorImpl::EmitTextureCall(ast::CallExpression* expr, {Usage::kValue, Usage::kSampler, Usage::kCoords, Usage::kArrayIndex, Usage::kDepthRef, Usage::kSampleIndex}) { if (auto* e = arg(usage)) { + auto* sem_e = program_->Sem().Get(e); + maybe_write_comma(); + + // Cast the coordinates to unsigned integers if necessary. + bool casted = false; + if (usage == Usage::kCoords && + sem_e->Type()->UnwrapRef()->is_integer_scalar_or_vector()) { + casted = true; + switch (texture_type->dim()) { + case ast::TextureDimension::k1d: + out_ << "uint("; + break; + case ast::TextureDimension::k2d: + case ast::TextureDimension::k2dArray: + out_ << "uint2("; + break; + case ast::TextureDimension::k3d: + out_ << "uint3("; + break; + default: + TINT_ICE(diagnostics_) << "unhandled texture dimensionality"; + break; + } + } + if (!EmitExpression(e)) return false; + + if (casted) { + out_ << ")"; + } } } diff --git a/src/writer/msl/generator_impl_intrinsic_texture_test.cc b/src/writer/msl/generator_impl_intrinsic_texture_test.cc index 901f100f8f..8ffe66e3aa 100644 --- a/src/writer/msl/generator_impl_intrinsic_texture_test.cc +++ b/src/writer/msl/generator_impl_intrinsic_texture_test.cc @@ -181,41 +181,41 @@ std::string expected_texture_overload( case ValidTextureOverload::kSampleCompareDepthCubeArrayF32: return R"(texture.sample_compare(sampler, float3(1.0f, 2.0f, 3.0f), 4, 5.0f))"; case ValidTextureOverload::kLoad1dLevelF32: - return R"(texture.read(1, 3))"; + return R"(texture.read(uint(1), 3))"; case ValidTextureOverload::kLoad1dLevelU32: - return R"(texture.read(1, 3))"; + return R"(texture.read(uint(1), 3))"; case ValidTextureOverload::kLoad1dLevelI32: - return R"(texture.read(1, 3))"; + return R"(texture.read(uint(1), 3))"; case ValidTextureOverload::kLoad2dLevelF32: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoad2dLevelU32: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoad2dLevelI32: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoad2dArrayLevelF32: - return R"(texture.read(int2(1, 2), 3, 4))"; + return R"(texture.read(uint2(int2(1, 2)), 3, 4))"; case ValidTextureOverload::kLoad2dArrayLevelU32: - return R"(texture.read(int2(1, 2), 3, 4))"; + return R"(texture.read(uint2(int2(1, 2)), 3, 4))"; case ValidTextureOverload::kLoad2dArrayLevelI32: - return R"(texture.read(int2(1, 2), 3, 4))"; + return R"(texture.read(uint2(int2(1, 2)), 3, 4))"; case ValidTextureOverload::kLoad3dLevelF32: - return R"(texture.read(int3(1, 2, 3), 4))"; + return R"(texture.read(uint3(int3(1, 2, 3)), 4))"; case ValidTextureOverload::kLoad3dLevelU32: - return R"(texture.read(int3(1, 2, 3), 4))"; + return R"(texture.read(uint3(int3(1, 2, 3)), 4))"; case ValidTextureOverload::kLoad3dLevelI32: - return R"(texture.read(int3(1, 2, 3), 4))"; + return R"(texture.read(uint3(int3(1, 2, 3)), 4))"; case ValidTextureOverload::kLoadMultisampled2dF32: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoadMultisampled2dU32: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoadMultisampled2dI32: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoadDepth2dLevelF32: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoadDepth2dArrayLevelF32: - return R"(texture.read(int2(1, 2), 3, 4))"; + return R"(texture.read(uint2(int2(1, 2)), 3, 4))"; case ValidTextureOverload::kLoadStorageRO1dRgba32float: - return R"(texture.read(1))"; + return R"(texture.read(uint(1)))"; case ValidTextureOverload::kLoadStorageRO2dRgba8unorm: case ValidTextureOverload::kLoadStorageRO2dRgba8snorm: case ValidTextureOverload::kLoadStorageRO2dRgba8uint: @@ -232,19 +232,19 @@ std::string expected_texture_overload( case ValidTextureOverload::kLoadStorageRO2dRgba32uint: case ValidTextureOverload::kLoadStorageRO2dRgba32sint: case ValidTextureOverload::kLoadStorageRO2dRgba32float: - return R"(texture.read(int2(1, 2)))"; + return R"(texture.read(uint2(int2(1, 2))))"; case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float: - return R"(texture.read(int2(1, 2), 3))"; + return R"(texture.read(uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kLoadStorageRO3dRgba32float: - return R"(texture.read(int3(1, 2, 3)))"; + return R"(texture.read(uint3(int3(1, 2, 3))))"; case ValidTextureOverload::kStoreWO1dRgba32float: - return R"(texture.write(float4(2.0f, 3.0f, 4.0f, 5.0f), 1))"; + return R"(texture.write(float4(2.0f, 3.0f, 4.0f, 5.0f), uint(1)))"; case ValidTextureOverload::kStoreWO2dRgba32float: - return R"(texture.write(float4(3.0f, 4.0f, 5.0f, 6.0f), int2(1, 2)))"; + return R"(texture.write(float4(3.0f, 4.0f, 5.0f, 6.0f), uint2(int2(1, 2))))"; case ValidTextureOverload::kStoreWO2dArrayRgba32float: - return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), int2(1, 2), 3))"; + return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), uint2(int2(1, 2)), 3))"; case ValidTextureOverload::kStoreWO3dRgba32float: - return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), int3(1, 2, 3)))"; + return R"(texture.write(float4(4.0f, 5.0f, 6.0f, 7.0f), uint3(int3(1, 2, 3))))"; } return ""; } // NOLINT - Ignore the length of this function diff --git a/test/deprecated/access_deco/storage_texture.wgsl.expected.msl b/test/deprecated/access_deco/storage_texture.wgsl.expected.msl index 3ed6e7ca76..acf4fbb7fe 100644 --- a/test/deprecated/access_deco/storage_texture.wgsl.expected.msl +++ b/test/deprecated/access_deco/storage_texture.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - deprecated/access_deco/storage_texture.wgsl:1:84 warning: use of deprecated language feature: access control is expected as last parameter of storage textures [[group(0), binding(0)]] var tex : [[access(write)]] texture_storage_2d; ^ - - -Validation Failure: #include using namespace metal; -kernel void tint_symbol() { - int2 x = int2(tex.get_width(), tex.get_height()); +kernel void tint_symbol(texture2d tint_symbol_1 [[texture(0)]]) { + int2 x = int2(tint_symbol_1.get_width(), tint_symbol_1.get_height()); return; } - -tint_Aillrb.metal:5:17: error: use of undeclared identifier 'tex' - int2 x = int2(tex.get_width(), tex.get_height()); - ^ -tint_Aillrb.metal:5:34: error: use of undeclared identifier 'tex' - int2 x = int2(tex.get_width(), tex.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/ignore/5016e5.wgsl.expected.msl b/test/intrinsics/gen/ignore/5016e5.wgsl.expected.msl index a32370f045..5580f867d4 100644 --- a/test/intrinsics/gen/ignore/5016e5.wgsl.expected.msl +++ b/test/intrinsics/gen/ignore/5016e5.wgsl.expected.msl @@ -1,8 +1,3 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; @@ -10,28 +5,23 @@ struct tint_symbol { float4 value [[position]]; }; -void ignore_5016e5() { - (void) arg_0; +void ignore_5016e5(sampler tint_symbol_2) { + (void) tint_symbol_2; } -vertex tint_symbol vertex_main() { - ignore_5016e5(); +vertex tint_symbol vertex_main(sampler tint_symbol_3 [[sampler(0)]]) { + ignore_5016e5(tint_symbol_3); tint_symbol const tint_symbol_1 = {.value=float4()}; return tint_symbol_1; } -fragment void fragment_main() { - ignore_5016e5(); +fragment void fragment_main(sampler tint_symbol_4 [[sampler(0)]]) { + ignore_5016e5(tint_symbol_4); return; } -kernel void compute_main() { - ignore_5016e5(); +kernel void compute_main(sampler tint_symbol_5 [[sampler(0)]]) { + ignore_5016e5(tint_symbol_5); return; } - -tint_nr1Dd1.metal:9:10: error: use of undeclared identifier 'arg_0' - (void) arg_0; - ^ -1 error generated. diff --git a/test/intrinsics/gen/ignore/509355.wgsl.expected.msl b/test/intrinsics/gen/ignore/509355.wgsl.expected.msl index 6593af4fcd..e99a3cc074 100644 --- a/test/intrinsics/gen/ignore/509355.wgsl.expected.msl +++ b/test/intrinsics/gen/ignore/509355.wgsl.expected.msl @@ -1,8 +1,3 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; @@ -10,28 +5,23 @@ struct tint_symbol { float4 value [[position]]; }; -void ignore_509355() { - (void) arg_0; +void ignore_509355(depthcube tint_symbol_2) { + (void) tint_symbol_2; } -vertex tint_symbol vertex_main() { - ignore_509355(); +vertex tint_symbol vertex_main(depthcube tint_symbol_3 [[texture(0)]]) { + ignore_509355(tint_symbol_3); tint_symbol const tint_symbol_1 = {.value=float4()}; return tint_symbol_1; } -fragment void fragment_main() { - ignore_509355(); +fragment void fragment_main(depthcube tint_symbol_4 [[texture(0)]]) { + ignore_509355(tint_symbol_4); return; } -kernel void compute_main() { - ignore_509355(); +kernel void compute_main(depthcube tint_symbol_5 [[texture(0)]]) { + ignore_509355(tint_symbol_5); return; } - -tint_BUnzrQ.metal:9:10: error: use of undeclared identifier 'arg_0' - (void) arg_0; - ^ -1 error generated. diff --git a/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.msl b/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.msl index f7201d36ed..046928efce 100644 --- a/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.msl +++ b/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.msl @@ -1,8 +1,3 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; @@ -10,28 +5,23 @@ struct tint_symbol { float4 value [[position]]; }; -void ignore_5c9edf() { - (void) arg_0; +void ignore_5c9edf(texture2d tint_symbol_2) { + (void) tint_symbol_2; } -vertex tint_symbol vertex_main() { - ignore_5c9edf(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + ignore_5c9edf(tint_symbol_3); tint_symbol const tint_symbol_1 = {.value=float4()}; return tint_symbol_1; } -fragment void fragment_main() { - ignore_5c9edf(); +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + ignore_5c9edf(tint_symbol_4); return; } -kernel void compute_main() { - ignore_5c9edf(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + ignore_5c9edf(tint_symbol_5); return; } - -tint_520czX.metal:9:10: error: use of undeclared identifier 'arg_0' - (void) arg_0; - ^ -1 error generated. diff --git a/test/intrinsics/gen/ignore/ad88be.wgsl.expected.msl b/test/intrinsics/gen/ignore/ad88be.wgsl.expected.msl index 9aab6d10d5..c29ad22116 100644 --- a/test/intrinsics/gen/ignore/ad88be.wgsl.expected.msl +++ b/test/intrinsics/gen/ignore/ad88be.wgsl.expected.msl @@ -1,8 +1,3 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; @@ -10,28 +5,23 @@ struct tint_symbol { float4 value [[position]]; }; -void ignore_ad88be() { - (void) arg_0; +void ignore_ad88be(depthcube_array tint_symbol_2) { + (void) tint_symbol_2; } -vertex tint_symbol vertex_main() { - ignore_ad88be(); +vertex tint_symbol vertex_main(depthcube_array tint_symbol_3 [[texture(0)]]) { + ignore_ad88be(tint_symbol_3); tint_symbol const tint_symbol_1 = {.value=float4()}; return tint_symbol_1; } -fragment void fragment_main() { - ignore_ad88be(); +fragment void fragment_main(depthcube_array tint_symbol_4 [[texture(0)]]) { + ignore_ad88be(tint_symbol_4); return; } -kernel void compute_main() { - ignore_ad88be(); +kernel void compute_main(depthcube_array tint_symbol_5 [[texture(0)]]) { + ignore_ad88be(tint_symbol_5); return; } - -tint_BhQwjP.metal:9:10: error: use of undeclared identifier 'arg_0' - (void) arg_0; - ^ -1 error generated. diff --git a/test/intrinsics/gen/ignore/b469af.wgsl.expected.msl b/test/intrinsics/gen/ignore/b469af.wgsl.expected.msl index 5ff3a78799..1bd4303fc3 100644 --- a/test/intrinsics/gen/ignore/b469af.wgsl.expected.msl +++ b/test/intrinsics/gen/ignore/b469af.wgsl.expected.msl @@ -1,8 +1,3 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; @@ -10,28 +5,23 @@ struct tint_symbol { float4 value [[position]]; }; -void ignore_b469af() { - (void) arg_0; +void ignore_b469af(sampler tint_symbol_2) { + (void) tint_symbol_2; } -vertex tint_symbol vertex_main() { - ignore_b469af(); +vertex tint_symbol vertex_main(sampler tint_symbol_3 [[sampler(0)]]) { + ignore_b469af(tint_symbol_3); tint_symbol const tint_symbol_1 = {.value=float4()}; return tint_symbol_1; } -fragment void fragment_main() { - ignore_b469af(); +fragment void fragment_main(sampler tint_symbol_4 [[sampler(0)]]) { + ignore_b469af(tint_symbol_4); return; } -kernel void compute_main() { - ignore_b469af(); +kernel void compute_main(sampler tint_symbol_5 [[sampler(0)]]) { + ignore_b469af(tint_symbol_5); return; } - -tint_vztXdF.metal:9:10: error: use of undeclared identifier 'arg_0' - (void) arg_0; - ^ -1 error generated. diff --git a/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.msl b/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.msl index c8a3ce8eca..cdc9af32fa 100644 --- a/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.msl +++ b/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.msl @@ -1,8 +1,3 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; @@ -10,28 +5,23 @@ struct tint_symbol { float4 value [[position]]; }; -void ignore_c8a0ee() { - (void) arg_0; +void ignore_c8a0ee(depth2d_array tint_symbol_2) { + (void) tint_symbol_2; } -vertex tint_symbol vertex_main() { - ignore_c8a0ee(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_3 [[texture(0)]]) { + ignore_c8a0ee(tint_symbol_3); tint_symbol const tint_symbol_1 = {.value=float4()}; return tint_symbol_1; } -fragment void fragment_main() { - ignore_c8a0ee(); +fragment void fragment_main(depth2d_array tint_symbol_4 [[texture(0)]]) { + ignore_c8a0ee(tint_symbol_4); return; } -kernel void compute_main() { - ignore_c8a0ee(); +kernel void compute_main(depth2d_array tint_symbol_5 [[texture(0)]]) { + ignore_c8a0ee(tint_symbol_5); return; } - -tint_77yvjP.metal:9:10: error: use of undeclared identifier 'arg_0' - (void) arg_0; - ^ -1 error generated. diff --git a/test/intrinsics/gen/ignore/e0187b.wgsl.expected.msl b/test/intrinsics/gen/ignore/e0187b.wgsl.expected.msl index ea97a13976..86180d9d89 100644 --- a/test/intrinsics/gen/ignore/e0187b.wgsl.expected.msl +++ b/test/intrinsics/gen/ignore/e0187b.wgsl.expected.msl @@ -1,8 +1,3 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; @@ -10,28 +5,23 @@ struct tint_symbol { float4 value [[position]]; }; -void ignore_e0187b() { - (void) arg_0; +void ignore_e0187b(depth2d tint_symbol_2) { + (void) tint_symbol_2; } -vertex tint_symbol vertex_main() { - ignore_e0187b(); +vertex tint_symbol vertex_main(depth2d tint_symbol_3 [[texture(0)]]) { + ignore_e0187b(tint_symbol_3); tint_symbol const tint_symbol_1 = {.value=float4()}; return tint_symbol_1; } -fragment void fragment_main() { - ignore_e0187b(); +fragment void fragment_main(depth2d tint_symbol_4 [[texture(0)]]) { + ignore_e0187b(tint_symbol_4); return; } -kernel void compute_main() { - ignore_e0187b(); +kernel void compute_main(depth2d tint_symbol_5 [[texture(0)]]) { + ignore_e0187b(tint_symbol_5); return; } - -tint_gjL9b8.metal:9:10: error: use of undeclared identifier 'arg_0' - (void) arg_0; - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.msl index 736870d57a..f0a2f46609 100644 --- a/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_002b2a() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_002b2a(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_002b2a(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_002b2a(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_002b2a(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_002b2a(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_002b2a(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_002b2a(); - return; -} - - -tint_YrBvi5.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.msl index 701bdde822..4f64e04513 100644 --- a/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_012b82() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_012b82(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_012b82(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_012b82(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_012b82(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_012b82(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_012b82(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_012b82(); - return; -} - - -tint_53mrsD.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_53mrsD.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.msl index 9747407006..07590788c4 100644 --- a/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_08753d() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_08753d(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_08753d(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_08753d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_08753d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_08753d(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_08753d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_08753d(); - return; -} - - -tint_UY6QJy.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/08a62e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/08a62e.wgsl.expected.msl index 9091d77a23..f0f7937465 100644 --- a/test/intrinsics/gen/textureDimensions/08a62e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/08a62e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_08a62e() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_08a62e(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_08a62e(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_08a62e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_08a62e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_08a62e(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_08a62e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_08a62e(); - return; -} - - -tint_YCd6H7.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/0a5fcf.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0a5fcf.wgsl.expected.msl index c47cacc894..c832aaa7df 100644 --- a/test/intrinsics/gen/textureDimensions/0a5fcf.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0a5fcf.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0a5fcf() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0a5fcf(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_0a5fcf(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_0a5fcf(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_0a5fcf(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0a5fcf(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_0a5fcf(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0a5fcf(); - return; -} - - -tint_NfeUfx.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_NfeUfx.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/0bab57.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0bab57.wgsl.expected.msl index 26f279e191..a67843f5bf 100644 --- a/test/intrinsics/gen/textureDimensions/0bab57.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0bab57.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0bab57() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0bab57(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_0bab57(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_0bab57(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_0bab57(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0bab57(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_0bab57(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0bab57(); - return; -} - - -tint_VmqGL7.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_VmqGL7.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_VmqGL7.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.msl index 2185536c8a..c939d4ceb0 100644 --- a/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0c4772() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0c4772(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_0c4772(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_0c4772(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_0c4772(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0c4772(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_0c4772(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0c4772(); - return; -} - - -tint_oTvIFp.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_oTvIFp.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_oTvIFp.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.msl index b771ab7c06..7fb64de818 100644 --- a/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0cce40() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0cce40(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_0cce40(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_0cce40(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_0cce40(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0cce40(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_0cce40(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0cce40(); - return; -} - - -tint_qF3vqW.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.msl index 41747da143..699cdc3f5a 100644 --- a/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0cf2ff() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0cf2ff(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_0cf2ff(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_0cf2ff(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_0cf2ff(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0cf2ff(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_0cf2ff(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0cf2ff(); - return; -} - - -tint_qzu6tS.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_qzu6tS.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.msl index 50cf96a22a..9c78642232 100644 --- a/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0d8b7e() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0d8b7e(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_0d8b7e(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_0d8b7e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_0d8b7e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0d8b7e(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_0d8b7e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0d8b7e(); - return; -} - - -tint_F95BY3.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_F95BY3.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.msl index ba2297d372..72b3ab6819 100644 --- a/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0e32ee() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0e32ee(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_0e32ee(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_0e32ee(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_0e32ee(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0e32ee(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_0e32ee(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0e32ee(); - return; -} - - -tint_xjHPQ6.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_xjHPQ6.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_xjHPQ6.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.msl index 6c2793a007..88a1190c7d 100644 --- a/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_0f3c50() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_0f3c50(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_0f3c50(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_0f3c50(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_0f3c50(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_0f3c50(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_0f3c50(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_0f3c50(); - return; -} - - -tint_UClgXx.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_UClgXx.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1147d6.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1147d6.wgsl.expected.msl index 37d8bdb441..649e4f44c3 100644 --- a/test/intrinsics/gen/textureDimensions/1147d6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1147d6.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1147d6() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1147d6(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_1147d6(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_1147d6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_1147d6(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1147d6(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_1147d6(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1147d6(); - return; -} - - -tint_cYmRIw.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_cYmRIw.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.msl index c20ed0cb28..fbcd00abaa 100644 --- a/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1191a5() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1191a5(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_1191a5(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_1191a5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_1191a5(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1191a5(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_1191a5(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1191a5(); - return; -} - - -tint_dHtSbR.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_dHtSbR.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.msl index 29197a2ca6..a570183e87 100644 --- a/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_12c9bb() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_12c9bb(depth2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_12c9bb(); +vertex tint_symbol vertex_main(depth2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_12c9bb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_12c9bb(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_12c9bb(); +kernel void compute_main(depth2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_12c9bb(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_12c9bb(); - return; -} - - -tint_jub3iU.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_jub3iU.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.msl index b8a7f49ea3..24a7d9ba88 100644 --- a/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_147998() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_147998(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_147998(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_147998(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_147998(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_147998(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_147998(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_147998(); - return; -} - - -tint_XJHJFB.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_XJHJFB.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.msl index 3509672bd8..7d8a4259ff 100644 --- a/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_16036c() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_16036c(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_16036c(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_16036c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_16036c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_16036c(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_16036c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_16036c(); - return; -} - - -tint_vxFz1a.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_vxFz1a.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/168fcc.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/168fcc.wgsl.expected.msl index 77c4feaef3..52b4c262ce 100644 --- a/test/intrinsics/gen/textureDimensions/168fcc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/168fcc.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_168fcc() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_168fcc(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_168fcc(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_168fcc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_168fcc(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_168fcc(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_168fcc(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_168fcc(); - return; -} - - -tint_IK0v0a.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_IK0v0a.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/183b3e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/183b3e.wgsl.expected.msl index f613834f8a..29b1d23621 100644 --- a/test/intrinsics/gen/textureDimensions/183b3e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/183b3e.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_183b3e() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_183b3e(texturecube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_183b3e(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_183b3e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_183b3e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_183b3e(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_183b3e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_183b3e(); - return; -} - - -tint_k1bgdS.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_k1bgdS.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_k1bgdS.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/18bd57.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/18bd57.wgsl.expected.msl index 1e1ae1e3f0..7db854a024 100644 --- a/test/intrinsics/gen/textureDimensions/18bd57.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/18bd57.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_18bd57() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_18bd57(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_18bd57(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_18bd57(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_18bd57(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_18bd57(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_18bd57(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_18bd57(); - return; -} - - -tint_Maj4Vv.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_Maj4Vv.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/19bffc.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/19bffc.wgsl.expected.msl index d0cac34ae2..b24ac12aa0 100644 --- a/test/intrinsics/gen/textureDimensions/19bffc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/19bffc.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_19bffc() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_19bffc(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_19bffc(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_19bffc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_19bffc(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_19bffc(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_19bffc(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_19bffc(); - return; -} - - -tint_3gqqBY.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_3gqqBY.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_3gqqBY.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1a58e7.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1a58e7.wgsl.expected.msl index 80d0a7230b..9592acfed0 100644 --- a/test/intrinsics/gen/textureDimensions/1a58e7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1a58e7.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1a58e7() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1a58e7(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_1a58e7(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_1a58e7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_1a58e7(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1a58e7(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_1a58e7(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1a58e7(); - return; -} - - -tint_ErdWWi.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_ErdWWi.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1aa199.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1aa199.wgsl.expected.msl index 9f17d36096..85b5ae6b31 100644 --- a/test/intrinsics/gen/textureDimensions/1aa199.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1aa199.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1aa199() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1aa199(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_1aa199(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_1aa199(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_1aa199(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1aa199(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_1aa199(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1aa199(); - return; -} - - -tint_6ZmaRP.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_6ZmaRP.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.msl index 3cf91c487c..673514dc8a 100644 --- a/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1b71f0() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1b71f0(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_1b71f0(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_1b71f0(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_1b71f0(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1b71f0(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_1b71f0(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1b71f0(); - return; -} - - -tint_Hgy8iM.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_Hgy8iM.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_Hgy8iM.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.msl index 96b2fa17cb..f0a48afd01 100644 --- a/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1d6c26() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1d6c26(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_1d6c26(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_1d6c26(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_1d6c26(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1d6c26(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_1d6c26(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1d6c26(); - return; -} - - -tint_sD3lxy.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_sD3lxy.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1e189c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1e189c.wgsl.expected.msl index d42dd47006..6c0bd84a0f 100644 --- a/test/intrinsics/gen/textureDimensions/1e189c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1e189c.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1e189c() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1e189c(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_1e189c(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_1e189c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_1e189c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1e189c(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_1e189c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1e189c(); - return; -} - - -tint_gyn8lu.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_gyn8lu.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_gyn8lu.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.msl index a9f4a053ad..137e221ebf 100644 --- a/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1e9e39() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1e9e39(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_1e9e39(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_1e9e39(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_1e9e39(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1e9e39(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_1e9e39(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1e9e39(); - return; -} - - -tint_woGJy5.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/1ebd6a.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1ebd6a.wgsl.expected.msl index 95dc541486..8dfb0e41ab 100644 --- a/test/intrinsics/gen/textureDimensions/1ebd6a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1ebd6a.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1ebd6a() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1ebd6a(texturecube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_1ebd6a(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureDimensions_1ebd6a(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureDimensions_1ebd6a(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1ebd6a(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureDimensions_1ebd6a(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1ebd6a(); - return; -} - - -tint_OvApsq.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_OvApsq.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_OvApsq.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.msl index cc39489d59..1bf676677e 100644 --- a/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_1f20c5() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_1f20c5(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_1f20c5(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_1f20c5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_1f20c5(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_1f20c5(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_1f20c5(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_1f20c5(); - return; -} - - -tint_u7r45E.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_u7r45E.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/214b7b.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/214b7b.wgsl.expected.msl index 3ba81a2eb1..17de1cb06f 100644 --- a/test/intrinsics/gen/textureDimensions/214b7b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/214b7b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_214b7b() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_214b7b(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_214b7b(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_214b7b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_214b7b(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_214b7b(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_214b7b(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_214b7b(); - return; -} - - -tint_mQY3pp.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.msl index cf5792a4a1..1775391502 100644 --- a/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_214dd4() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_214dd4(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_214dd4(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_214dd4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_214dd4(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_214dd4(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_214dd4(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_214dd4(); - return; -} - - -tint_RuhGmN.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_RuhGmN.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_RuhGmN.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.msl index 457b334db2..c5b753e491 100644 --- a/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_267788() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_267788(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_267788(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_267788(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_267788(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_267788(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_267788(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_267788(); - return; -} - - -tint_t0FoEb.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_t0FoEb.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.msl index dbc0fde045..372f1c72fd 100644 --- a/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_26bdfa() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_26bdfa(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_depth(1)); } -vertex void vertex_main() { - textureDimensions_26bdfa(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_26bdfa(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_26bdfa(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_26bdfa(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_26bdfa(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_26bdfa(); - return; -} - - -tint_ZWMTxF.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -tint_ZWMTxF.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -tint_ZWMTxF.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.msl index 332afa32da..4d31ec0db5 100644 --- a/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_26ef6c() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_26ef6c(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_26ef6c(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_26ef6c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_26ef6c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_26ef6c(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_26ef6c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_26ef6c(); - return; -} - - -tint_AGQyA0.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_AGQyA0.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.msl index 60571a7a6c..dcae9dfdad 100644 --- a/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_2ad087() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_2ad087(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_2ad087(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_2ad087(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_2ad087(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_2ad087(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_2ad087(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_2ad087(); - return; -} - - -tint_wMnrXN.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_wMnrXN.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/2d32ae.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/2d32ae.wgsl.expected.msl index a278b6cf69..8690ddc8eb 100644 --- a/test/intrinsics/gen/textureDimensions/2d32ae.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/2d32ae.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_2d32ae() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_2d32ae(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_2d32ae(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_2d32ae(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_2d32ae(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_2d32ae(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_2d32ae(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_2d32ae(); - return; -} - - -tint_mQ7t9w.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_mQ7t9w.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_mQ7t9w.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/2e0662.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/2e0662.wgsl.expected.msl index 4a03532d16..cad0288e3c 100644 --- a/test/intrinsics/gen/textureDimensions/2e0662.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/2e0662.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_2e0662() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_2e0662(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_2e0662(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_2e0662(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_2e0662(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_2e0662(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_2e0662(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_2e0662(); - return; -} - - -tint_kZyeWE.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_kZyeWE.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.msl index 38226ec73f..0831f9262d 100644 --- a/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_2efa05() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_2efa05(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_depth(1)); } -vertex void vertex_main() { - textureDimensions_2efa05(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_2efa05(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_2efa05(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_2efa05(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_2efa05(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_2efa05(); - return; -} - - -tint_27jxuk.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -tint_27jxuk.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -tint_27jxuk.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.msl index 6aaf3be66a..619e2cc4a8 100644 --- a/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_2f289f() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_2f289f(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_2f289f(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_2f289f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_2f289f(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_2f289f(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_2f289f(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_2f289f(); - return; -} - - -tint_xxOVlF.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_xxOVlF.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_xxOVlF.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.msl index 1090ab70cd..bbe8e90b5c 100644 --- a/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_2fe1cc() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_2fe1cc(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_2fe1cc(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_2fe1cc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_2fe1cc(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_2fe1cc(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_2fe1cc(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_2fe1cc(); - return; -} - - -tint_6Uwx6N.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_6Uwx6N.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.msl index 55c6228b01..d3fac46090 100644 --- a/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_318ecc() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_318ecc(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_318ecc(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_318ecc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_318ecc(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_318ecc(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_318ecc(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_318ecc(); - return; -} - - -tint_G5ZUUJ.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.msl index 3b0ea883f4..330cf6a50e 100644 --- a/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_340d06() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_340d06(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_340d06(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_340d06(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_340d06(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_340d06(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_340d06(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_340d06(); - return; -} - - -tint_E6aL0a.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_E6aL0a.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_E6aL0a.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.msl index d19328ec2e..2dd70beb06 100644 --- a/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_398e30() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_398e30(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_398e30(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_398e30(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_398e30(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_398e30(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_398e30(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_398e30(); - return; -} - - -tint_QcQpUI.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_QcQpUI.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/39a600.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/39a600.wgsl.expected.msl index 585dd48c8c..75d2a3ac78 100644 --- a/test/intrinsics/gen/textureDimensions/39a600.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/39a600.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_39a600() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_39a600(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_39a600(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_39a600(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_39a600(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_39a600(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_39a600(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_39a600(); - return; -} - - -tint_IGrYE5.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_IGrYE5.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.msl index baedbc72f8..3936b9e41f 100644 --- a/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_3a94ea() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_3a94ea(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_3a94ea(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_3a94ea(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_3a94ea(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_3a94ea(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_3a94ea(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_3a94ea(); - return; -} - - -tint_IJj3j3.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_IJj3j3.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.msl index e12c743704..8d1dc1fe21 100644 --- a/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_3aca08() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_3aca08(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_3aca08(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_3aca08(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_3aca08(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_3aca08(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_3aca08(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_3aca08(); - return; -} - - -tint_DgMBiO.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.msl index 42638895a8..48d369aab1 100644 --- a/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_3c5ad8() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_3c5ad8(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_3c5ad8(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_3c5ad8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_3c5ad8(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_3c5ad8(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_3c5ad8(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_3c5ad8(); - return; -} - - -tint_WN6S73.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_WN6S73.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/3d5817.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/3d5817.wgsl.expected.msl index 9b81afbb71..5b42cbdd5c 100644 --- a/test/intrinsics/gen/textureDimensions/3d5817.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/3d5817.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_3d5817() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_3d5817(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_3d5817(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_3d5817(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_3d5817(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_3d5817(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_3d5817(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_3d5817(); - return; -} - - -tint_a86Ot5.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/3e0403.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/3e0403.wgsl.expected.msl index 73a0f66630..37315f73a5 100644 --- a/test/intrinsics/gen/textureDimensions/3e0403.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/3e0403.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_3e0403() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_3e0403(texturecube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_3e0403(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_3e0403(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_3e0403(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_3e0403(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_3e0403(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_3e0403(); - return; -} - - -tint_12sPbd.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_12sPbd.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_12sPbd.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/3e626d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/3e626d.wgsl.expected.msl index 8821401bab..970257ef76 100644 --- a/test/intrinsics/gen/textureDimensions/3e626d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/3e626d.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_3e626d() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_3e626d(depthcube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_3e626d(); +vertex tint_symbol vertex_main(depthcube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_3e626d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_3e626d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_3e626d(); +kernel void compute_main(depthcube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_3e626d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_3e626d(); - return; -} - - -tint_ZTQ9Wa.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_ZTQ9Wa.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_ZTQ9Wa.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/40bc10.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/40bc10.wgsl.expected.msl index ab8ed04d22..6868c2ea4d 100644 --- a/test/intrinsics/gen/textureDimensions/40bc10.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/40bc10.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_40bc10() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_40bc10(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_40bc10(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_40bc10(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_40bc10(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_40bc10(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_40bc10(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_40bc10(); - return; -} - - -tint_ukJagZ.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.msl index 7a76a75352..0ff7dea290 100644 --- a/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_423f99() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_423f99(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_423f99(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_423f99(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_423f99(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_423f99(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_423f99(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_423f99(); - return; -} - - -tint_mj2s9A.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.msl index a494763d64..22b7a7702d 100644 --- a/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_4267ee() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_4267ee(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_4267ee(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_4267ee(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_4267ee(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_4267ee(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_4267ee(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_4267ee(); - return; -} - - -tint_9XjQPO.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_9XjQPO.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.msl index 35fac39647..b398ce3b5d 100644 --- a/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_42d4e6() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_42d4e6(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_42d4e6(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_42d4e6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_42d4e6(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_42d4e6(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_42d4e6(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_42d4e6(); - return; -} - - -tint_OEpToQ.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/441392.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/441392.wgsl.expected.msl index 981210f179..6c90ca2cba 100644 --- a/test/intrinsics/gen/textureDimensions/441392.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/441392.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_441392() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_441392(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_441392(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_441392(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_441392(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_441392(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_441392(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_441392(); - return; -} - - -tint_J7rYXr.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.msl index 52b7fa86c2..d119c1e0b2 100644 --- a/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_48cb89() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_48cb89(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_48cb89(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_48cb89(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_48cb89(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_48cb89(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_48cb89(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_48cb89(); - return; -} - - -tint_dswMSP.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_dswMSP.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/48cbb2.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/48cbb2.wgsl.expected.msl index 8ce4bb7a7c..de78f98791 100644 --- a/test/intrinsics/gen/textureDimensions/48cbb2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/48cbb2.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_48cbb2() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_48cbb2(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_48cbb2(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_48cbb2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_48cbb2(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_48cbb2(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_48cbb2(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_48cbb2(); - return; -} - - -tint_rl5Xrx.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_rl5Xrx.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/48f360.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/48f360.wgsl.expected.msl index 5757db61f1..754c094cbc 100644 --- a/test/intrinsics/gen/textureDimensions/48f360.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/48f360.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_48f360() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_48f360(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_48f360(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_48f360(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_48f360(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_48f360(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_48f360(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_48f360(); - return; -} - - -tint_uKd3an.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_uKd3an.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.msl index fe0d210a55..0df06b26f0 100644 --- a/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_49d274() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_49d274(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_49d274(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_49d274(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_49d274(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_49d274(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_49d274(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_49d274(); - return; -} - - -tint_VhbHeD.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_VhbHeD.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.msl index 38a04a9b48..ae35a49382 100644 --- a/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_4df9a8() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_4df9a8(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_4df9a8(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_4df9a8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_4df9a8(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_4df9a8(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_4df9a8(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_4df9a8(); - return; -} - - -tint_gTHNDu.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.msl index 72474f381f..ca7a221ae0 100644 --- a/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_55b23e() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_55b23e(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_55b23e(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_55b23e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_55b23e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_55b23e(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_55b23e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_55b23e(); - return; -} - - -tint_bIR2Jm.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/56ccfa.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/56ccfa.wgsl.expected.msl index 287a2995f4..ccecc8b5ed 100644 --- a/test/intrinsics/gen/textureDimensions/56ccfa.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/56ccfa.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_56ccfa() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_56ccfa(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_56ccfa(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_56ccfa(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_56ccfa(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_56ccfa(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_56ccfa(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_56ccfa(); - return; -} - - -tint_7x14H7.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_7x14H7.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_7x14H7.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.msl index 535dea4a87..0aac0b68bd 100644 --- a/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_579629() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_579629(texture2d_ms tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_579629(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureDimensions_579629(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureDimensions_579629(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_579629(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureDimensions_579629(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_579629(); - return; -} - - -tint_FOf5JR.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_FOf5JR.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.msl index 0f18c54687..c5ece87f49 100644 --- a/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_57da0b() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_57da0b(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_57da0b(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_57da0b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_57da0b(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_57da0b(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_57da0b(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_57da0b(); - return; -} - - -tint_0q7tmr.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/57e7b3.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/57e7b3.wgsl.expected.msl index 1cd19c3ddd..44c924c10b 100644 --- a/test/intrinsics/gen/textureDimensions/57e7b3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/57e7b3.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_57e7b3() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_57e7b3(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_57e7b3(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_57e7b3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_57e7b3(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_57e7b3(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_57e7b3(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_57e7b3(); - return; -} - - -tint_ZD9nyd.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_ZD9nyd.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_ZD9nyd.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.msl index 1adcb54111..4e189b6d79 100644 --- a/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_58a515() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_58a515(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_58a515(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_58a515(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_58a515(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_58a515(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_58a515(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_58a515(); - return; -} - - -tint_XaWz8h.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_XaWz8h.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.msl index c012972165..d1e91f8903 100644 --- a/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_5985f3() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_5985f3(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_5985f3(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_5985f3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_5985f3(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_5985f3(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_5985f3(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_5985f3(); - return; -} - - -tint_hRnD1E.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_hRnD1E.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.msl index 3d20f6842e..0ca4064271 100644 --- a/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_5caa5e() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_5caa5e(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_5caa5e(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_5caa5e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_5caa5e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_5caa5e(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_5caa5e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_5caa5e(); - return; -} - - -tint_pj9O9H.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.msl index ce3951e92d..2dabc247ec 100644 --- a/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_5e295d() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_5e295d(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_5e295d(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_5e295d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_5e295d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_5e295d(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_5e295d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_5e295d(); - return; -} - - -tint_MszFa3.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_MszFa3.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/5ec4e1.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/5ec4e1.wgsl.expected.msl index 2f6bffb152..52c9599eae 100644 --- a/test/intrinsics/gen/textureDimensions/5ec4e1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/5ec4e1.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_5ec4e1() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_5ec4e1(texturecube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_5ec4e1(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureDimensions_5ec4e1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureDimensions_5ec4e1(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_5ec4e1(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureDimensions_5ec4e1(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_5ec4e1(); - return; -} - - -tint_zI0Hei.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_zI0Hei.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_zI0Hei.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.msl index 1018d0adce..ff91e5c3df 100644 --- a/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_60bf54() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_60bf54(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_60bf54(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_60bf54(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_60bf54(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_60bf54(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_60bf54(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_60bf54(); - return; -} - - -tint_nwkB68.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_nwkB68.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_nwkB68.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.msl index 8d6a0b774a..953f336b52 100644 --- a/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_63f3cf() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_63f3cf(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_63f3cf(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_63f3cf(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_63f3cf(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_63f3cf(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_63f3cf(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_63f3cf(); - return; -} - - -tint_xOZqUk.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_xOZqUk.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_xOZqUk.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/66dc4e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/66dc4e.wgsl.expected.msl index 96ac5f30b7..413dadf648 100644 --- a/test/intrinsics/gen/textureDimensions/66dc4e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/66dc4e.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_66dc4e() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_66dc4e(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_66dc4e(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_66dc4e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_66dc4e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_66dc4e(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_66dc4e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_66dc4e(); - return; -} - - -tint_cbPOlr.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_cbPOlr.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/670d90.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/670d90.wgsl.expected.msl index e392d86ed5..2efae3c751 100644 --- a/test/intrinsics/gen/textureDimensions/670d90.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/670d90.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_670d90() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_670d90(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_670d90(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_670d90(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_670d90(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_670d90(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_670d90(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_670d90(); - return; -} - - -tint_pQtIJE.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_pQtIJE.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_pQtIJE.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.msl index 7908305ecb..fe75ae9995 100644 --- a/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_68105c() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_68105c(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_68105c(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_68105c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_68105c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_68105c(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_68105c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_68105c(); - return; -} - - -tint_ImHXh7.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_ImHXh7.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.msl index 7c2faab988..0f1b763cde 100644 --- a/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_6adac6() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_6adac6(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_6adac6(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_6adac6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_6adac6(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_6adac6(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_6adac6(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_6adac6(); - return; -} - - -tint_kowEvS.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/6c08ab.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/6c08ab.wgsl.expected.msl index 35a39737a0..1ae9906518 100644 --- a/test/intrinsics/gen/textureDimensions/6c08ab.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/6c08ab.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_6c08ab() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_6c08ab(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_6c08ab(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_6c08ab(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_6c08ab(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_6c08ab(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_6c08ab(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_6c08ab(); - return; -} - - -tint_R7GQmD.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/6e2d12.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/6e2d12.wgsl.expected.msl index e74d8c8575..5e8a1ed0a0 100644 --- a/test/intrinsics/gen/textureDimensions/6e2d12.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/6e2d12.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_6e2d12() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_6e2d12(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_6e2d12(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_6e2d12(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_6e2d12(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_6e2d12(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_6e2d12(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_6e2d12(); - return; -} - - -tint_b9AESR.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.msl index 17889b570f..ef90a6d354 100644 --- a/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_6ec1b4() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_6ec1b4(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_6ec1b4(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_6ec1b4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_6ec1b4(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_6ec1b4(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_6ec1b4(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_6ec1b4(); - return; -} - - -tint_K0FZJY.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_K0FZJY.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_K0FZJY.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.msl index 979f71a814..0919062e0d 100644 --- a/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_6f0d79() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_6f0d79(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_6f0d79(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_6f0d79(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_6f0d79(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_6f0d79(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_6f0d79(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_6f0d79(); - return; -} - - -tint_xB7TMS.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_xB7TMS.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.msl index 5120e5920f..01f28c58dc 100644 --- a/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_702c53() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_702c53(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_702c53(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_702c53(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_702c53(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_702c53(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_702c53(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_702c53(); - return; -} - - -tint_XEg02Y.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_XEg02Y.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/70e26a.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/70e26a.wgsl.expected.msl index 15a4b62e71..640f076d7c 100644 --- a/test/intrinsics/gen/textureDimensions/70e26a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/70e26a.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_70e26a() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_70e26a(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_70e26a(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_70e26a(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_70e26a(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_70e26a(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_70e26a(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_70e26a(); - return; -} - - -tint_YKLVNs.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/71e8f7.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/71e8f7.wgsl.expected.msl index 6fa1f68499..55e3b38efc 100644 --- a/test/intrinsics/gen/textureDimensions/71e8f7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/71e8f7.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_71e8f7() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_71e8f7(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_71e8f7(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_71e8f7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_71e8f7(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_71e8f7(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_71e8f7(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_71e8f7(); - return; -} - - -tint_s1L8fA.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_s1L8fA.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.msl index 8367897aef..4b4629d722 100644 --- a/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_72e5d6() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_72e5d6(depth2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_72e5d6(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_72e5d6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_72e5d6(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_72e5d6(); +kernel void compute_main(depth2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_72e5d6(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_72e5d6(); - return; -} - - -tint_nWOwt2.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_nWOwt2.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/75be9d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/75be9d.wgsl.expected.msl index 4cfb4d449b..774810a463 100644 --- a/test/intrinsics/gen/textureDimensions/75be9d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/75be9d.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_75be9d() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_75be9d(texturecube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_75be9d(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureDimensions_75be9d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureDimensions_75be9d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_75be9d(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureDimensions_75be9d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_75be9d(); - return; -} - - -tint_8I50aH.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_8I50aH.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_8I50aH.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/76e722.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/76e722.wgsl.expected.msl index 3be4993b14..acb5195070 100644 --- a/test/intrinsics/gen/textureDimensions/76e722.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/76e722.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_76e722() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_76e722(depthcube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_76e722(); +vertex tint_symbol vertex_main(depthcube tint_symbol_3 [[texture(0)]]) { + textureDimensions_76e722(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube tint_symbol_4 [[texture(0)]]) { + textureDimensions_76e722(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_76e722(); +kernel void compute_main(depthcube tint_symbol_5 [[texture(0)]]) { + textureDimensions_76e722(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_76e722(); - return; -} - - -tint_rCoJkt.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_rCoJkt.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_rCoJkt.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/770103.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/770103.wgsl.expected.msl index f65d8cdfe0..1586977322 100644 --- a/test/intrinsics/gen/textureDimensions/770103.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/770103.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_770103() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_770103(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_770103(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_770103(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_770103(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_770103(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_770103(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_770103(); - return; -} - - -tint_bsVnyq.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_bsVnyq.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_bsVnyq.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/7bb707.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/7bb707.wgsl.expected.msl index 7fe0dd5a99..8ec9b7540e 100644 --- a/test/intrinsics/gen/textureDimensions/7bb707.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/7bb707.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_7bb707() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_7bb707(texturecube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_7bb707(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureDimensions_7bb707(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureDimensions_7bb707(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_7bb707(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureDimensions_7bb707(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_7bb707(); - return; -} - - -tint_VyEaVz.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_VyEaVz.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_VyEaVz.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.msl index 7f217c2107..9d42595ca7 100644 --- a/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_7bf826() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_7bf826(depth2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_7bf826(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_7bf826(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_7bf826(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_7bf826(); +kernel void compute_main(depth2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_7bf826(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_7bf826(); - return; -} - - -tint_fEyKMk.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_fEyKMk.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.msl index 8f23096c4c..ebcf1dc833 100644 --- a/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_7f5c2e() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_7f5c2e(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_7f5c2e(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_7f5c2e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_7f5c2e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_7f5c2e(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_7f5c2e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_7f5c2e(); - return; -} - - -tint_V3gAt9.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_V3gAt9.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.msl index 8563a2717d..8ddef21ea4 100644 --- a/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8028f3() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8028f3(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_8028f3(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8028f3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8028f3(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8028f3(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8028f3(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8028f3(); - return; -} - - -tint_rNXDNa.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_rNXDNa.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_rNXDNa.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.msl index 963c63400f..432b5a9d96 100644 --- a/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_811679() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_811679(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_811679(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_811679(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_811679(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_811679(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_811679(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_811679(); - return; -} - - -tint_zUXsFf.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_zUXsFf.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_zUXsFf.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.msl index 83c960f830..d93f23dbfd 100644 --- a/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_820596() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_820596(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_820596(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_820596(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_820596(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_820596(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_820596(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_820596(); - return; -} - - -tint_wPNSW7.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_wPNSW7.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_wPNSW7.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/82138e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/82138e.wgsl.expected.msl index 83d6afb4b6..6f661c8f10 100644 --- a/test/intrinsics/gen/textureDimensions/82138e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/82138e.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_82138e() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_82138e(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_82138e(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_82138e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_82138e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_82138e(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_82138e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_82138e(); - return; -} - - -tint_Npp6pY.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_Npp6pY.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/8347ab.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8347ab.wgsl.expected.msl index a000567bef..580ac20f43 100644 --- a/test/intrinsics/gen/textureDimensions/8347ab.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8347ab.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8347ab() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8347ab(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_8347ab(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8347ab(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8347ab(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8347ab(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8347ab(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8347ab(); - return; -} - - -tint_gN8oSM.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.msl index 7f51f22b35..22390e1181 100644 --- a/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_83ee5a() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_83ee5a(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_83ee5a(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_83ee5a(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_83ee5a(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_83ee5a(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_83ee5a(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_83ee5a(); - return; -} - - -tint_H9Kwto.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_H9Kwto.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.msl index f9e9e2e19c..2e35fd018b 100644 --- a/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_85d556() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_85d556(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_85d556(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_85d556(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_85d556(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_85d556(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_85d556(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_85d556(); - return; -} - - -tint_now3jP.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_now3jP.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/8799ee.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8799ee.wgsl.expected.msl index aa12070a9a..e1a8e80d5e 100644 --- a/test/intrinsics/gen/textureDimensions/8799ee.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8799ee.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8799ee() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8799ee(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_8799ee(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8799ee(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8799ee(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8799ee(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8799ee(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8799ee(); - return; -} - - -tint_oFGVm6.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_oFGVm6.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_oFGVm6.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/89a864.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/89a864.wgsl.expected.msl index d851f90d2f..484cd8e7b8 100644 --- a/test/intrinsics/gen/textureDimensions/89a864.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/89a864.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_89a864() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_89a864(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_89a864(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_89a864(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_89a864(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_89a864(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_89a864(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_89a864(); - return; -} - - -tint_d9UcqL.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_d9UcqL.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.msl index 0b9908245c..53d6576ce0 100644 --- a/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8aa4c4() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8aa4c4(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_8aa4c4(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8aa4c4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8aa4c4(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8aa4c4(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8aa4c4(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8aa4c4(); - return; -} - - -tint_Jf2SUf.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_Jf2SUf.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_Jf2SUf.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/8b4fff.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8b4fff.wgsl.expected.msl index 24a76acdda..b92c382c8f 100644 --- a/test/intrinsics/gen/textureDimensions/8b4fff.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8b4fff.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8b4fff() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8b4fff(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_8b4fff(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8b4fff(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8b4fff(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8b4fff(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8b4fff(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8b4fff(); - return; -} - - -tint_HYEIin.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_HYEIin.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/8d89f8.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8d89f8.wgsl.expected.msl index 5028c4037c..ac9eae7524 100644 --- a/test/intrinsics/gen/textureDimensions/8d89f8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8d89f8.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8d89f8() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8d89f8(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_8d89f8(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8d89f8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8d89f8(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8d89f8(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8d89f8(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8d89f8(); - return; -} - - -tint_VjxWxy.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.msl index 2000e1866a..cd45aa5fc1 100644 --- a/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8deb5e() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8deb5e(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_8deb5e(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8deb5e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8deb5e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8deb5e(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8deb5e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8deb5e(); - return; -} - - -tint_sSlF0R.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_sSlF0R.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_sSlF0R.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.msl index 3466bc5c4b..26ef2cfe70 100644 --- a/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_8fca0f() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_8fca0f(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_8fca0f(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_8fca0f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_8fca0f(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_8fca0f(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_8fca0f(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_8fca0f(); - return; -} - - -tint_ROXO5D.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_ROXO5D.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_ROXO5D.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.msl index 83b4534a48..7b0908d296 100644 --- a/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_9042ab() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_9042ab(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_9042ab(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_9042ab(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_9042ab(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_9042ab(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_9042ab(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_9042ab(); - return; -} - - -tint_B1qgWW.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_B1qgWW.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/91f42d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/91f42d.wgsl.expected.msl index 2a44126de2..5e6653cfdf 100644 --- a/test/intrinsics/gen/textureDimensions/91f42d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/91f42d.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_91f42d() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_91f42d(texturecube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_91f42d(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_91f42d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_91f42d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_91f42d(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_91f42d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_91f42d(); - return; -} - - -tint_G9KC5u.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_G9KC5u.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_G9KC5u.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/924742.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/924742.wgsl.expected.msl index af8bd0adb1..01cfc36c83 100644 --- a/test/intrinsics/gen/textureDimensions/924742.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/924742.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_924742() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_924742(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_924742(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_924742(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_924742(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_924742(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_924742(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_924742(); - return; -} - - -tint_wgXnIZ.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_wgXnIZ.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_wgXnIZ.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/92ad20.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/92ad20.wgsl.expected.msl index 9e963acaa7..4a6f7becbe 100644 --- a/test/intrinsics/gen/textureDimensions/92ad20.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/92ad20.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_92ad20() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_92ad20(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_92ad20(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_92ad20(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_92ad20(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_92ad20(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_92ad20(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_92ad20(); - return; -} - - -tint_u1hm4E.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_u1hm4E.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_u1hm4E.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.msl index 8f97c1b5db..05b52790be 100644 --- a/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_939fdb() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_939fdb(depth2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_939fdb(); +vertex tint_symbol vertex_main(depth2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_939fdb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_939fdb(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_939fdb(); +kernel void compute_main(depth2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_939fdb(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_939fdb(); - return; -} - - -tint_uyPO2n.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_uyPO2n.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/9572e5.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/9572e5.wgsl.expected.msl index 55bbe37d15..4fcfc032f9 100644 --- a/test/intrinsics/gen/textureDimensions/9572e5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/9572e5.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_9572e5() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_9572e5(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_9572e5(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_9572e5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_9572e5(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_9572e5(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_9572e5(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_9572e5(); - return; -} - - -tint_ubERwe.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_ubERwe.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_ubERwe.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/998f6b.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/998f6b.wgsl.expected.msl index b2a3245e6a..02f4e38005 100644 --- a/test/intrinsics/gen/textureDimensions/998f6b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/998f6b.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_998f6b() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_998f6b(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_998f6b(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_998f6b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_998f6b(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_998f6b(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_998f6b(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_998f6b(); - return; -} - - -tint_rna27I.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_rna27I.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.msl index f510b8db0c..11d7780122 100644 --- a/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_9abfe5() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_9abfe5(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_9abfe5(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_9abfe5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_9abfe5(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_9abfe5(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_9abfe5(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_9abfe5(); - return; -} - - -tint_aLx7To.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_aLx7To.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.msl index f8f5356b0a..3e14184d68 100644 --- a/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_9c9c57() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_9c9c57(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_9c9c57(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_9c9c57(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_9c9c57(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_9c9c57(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_9c9c57(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_9c9c57(); - return; -} - - -tint_NYnjny.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_NYnjny.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.msl index 6fb03a5ea1..f89d05070b 100644 --- a/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_9da9e2() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_9da9e2(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_9da9e2(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_9da9e2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_9da9e2(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_9da9e2(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_9da9e2(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_9da9e2(); - return; -} - - -tint_LQ6PJO.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.msl index 6d9361fda7..9f4cb270a5 100644 --- a/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_9eb8d8() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_9eb8d8(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_9eb8d8(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_9eb8d8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_9eb8d8(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_9eb8d8(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_9eb8d8(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_9eb8d8(); - return; -} - - -tint_A2F2rt.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_A2F2rt.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.msl index df82743476..16f228f01d 100644 --- a/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_9f8e46() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_9f8e46(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_9f8e46(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_9f8e46(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_9f8e46(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_9f8e46(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_9f8e46(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_9f8e46(); - return; -} - - -tint_bK96vd.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_bK96vd.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/a0aad1.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/a0aad1.wgsl.expected.msl index dee0891c59..19d1ccab67 100644 --- a/test/intrinsics/gen/textureDimensions/a0aad1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/a0aad1.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_a0aad1() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_a0aad1(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_a0aad1(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_a0aad1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_a0aad1(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_a0aad1(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_a0aad1(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_a0aad1(); - return; -} - - -tint_9s1OKb.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_9s1OKb.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/a0e4ec.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/a0e4ec.wgsl.expected.msl index 62aed2c8d1..b8473fe7f3 100644 --- a/test/intrinsics/gen/textureDimensions/a0e4ec.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/a0e4ec.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_a0e4ec() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_a0e4ec(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_a0e4ec(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_a0e4ec(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_a0e4ec(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_a0e4ec(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_a0e4ec(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_a0e4ec(); - return; -} - - -tint_Gx3LOP.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_Gx3LOP.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_Gx3LOP.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/a6ca1c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/a6ca1c.wgsl.expected.msl index 7955481faf..4613cec7fa 100644 --- a/test/intrinsics/gen/textureDimensions/a6ca1c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/a6ca1c.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_a6ca1c() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_a6ca1c(depthcube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_a6ca1c(); +vertex tint_symbol vertex_main(depthcube tint_symbol_3 [[texture(0)]]) { + textureDimensions_a6ca1c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube tint_symbol_4 [[texture(0)]]) { + textureDimensions_a6ca1c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_a6ca1c(); +kernel void compute_main(depthcube tint_symbol_5 [[texture(0)]]) { + textureDimensions_a6ca1c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_a6ca1c(); - return; -} - - -tint_QYHqWT.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_QYHqWT.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_QYHqWT.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.msl index 867a1b7cad..99881f0fdf 100644 --- a/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_a7d565() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_a7d565(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_a7d565(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_a7d565(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_a7d565(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_a7d565(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_a7d565(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_a7d565(); - return; -} - - -tint_9E9ULI.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.msl index f44cdd5e2e..3cc15027fc 100644 --- a/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_a863f2() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_a863f2(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_a863f2(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_a863f2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_a863f2(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_a863f2(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_a863f2(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_a863f2(); - return; -} - - -tint_wjS4Td.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/ae457f.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/ae457f.wgsl.expected.msl index 707857c6ab..fcdd22c3a3 100644 --- a/test/intrinsics/gen/textureDimensions/ae457f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/ae457f.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_ae457f() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_ae457f(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_ae457f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_ae457f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_ae457f(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_ae457f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_ae457f(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_ae457f(); - return; -} - - -tint_fBh8Vy.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_fBh8Vy.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.msl index 4749a7864b..5f26a99f3d 100644 --- a/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_b0e16d() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_b0e16d(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_b0e16d(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_b0e16d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_b0e16d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_b0e16d(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_b0e16d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_b0e16d(); - return; -} - - -tint_Qlz1ri.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_Qlz1ri.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.msl index a2c9940ccb..d5e95cfb18 100644 --- a/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_b91240() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_b91240(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_b91240(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_b91240(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_b91240(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_b91240(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_b91240(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_b91240(); - return; -} - - -tint_KzkVEm.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_KzkVEm.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.msl index a4422c7a31..d17c84e278 100644 --- a/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_ba1481() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_ba1481(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_ba1481(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_ba1481(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_ba1481(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_ba1481(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_ba1481(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_ba1481(); - return; -} - - -tint_kAFvfK.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_kAFvfK.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/ba6e15.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/ba6e15.wgsl.expected.msl index 367a4096a9..e4a32a9e02 100644 --- a/test/intrinsics/gen/textureDimensions/ba6e15.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/ba6e15.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_ba6e15() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_ba6e15(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_ba6e15(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_ba6e15(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_ba6e15(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_ba6e15(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_ba6e15(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_ba6e15(); - return; -} - - -tint_2PV8R2.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_2PV8R2.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.msl index dd2c2ef994..df43e6a900 100644 --- a/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_bb3dde() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_bb3dde(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_bb3dde(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_bb3dde(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_bb3dde(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_bb3dde(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_bb3dde(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_bb3dde(); - return; -} - - -tint_RiPDug.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_RiPDug.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_RiPDug.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/bdf2ee.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/bdf2ee.wgsl.expected.msl index 630b31fee5..1d2d53e029 100644 --- a/test/intrinsics/gen/textureDimensions/bdf2ee.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/bdf2ee.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_bdf2ee() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_bdf2ee(depthcube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_bdf2ee(); +vertex tint_symbol vertex_main(depthcube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_bdf2ee(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_bdf2ee(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_bdf2ee(); +kernel void compute_main(depthcube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_bdf2ee(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_bdf2ee(); - return; -} - - -tint_i7osat.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_i7osat.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_i7osat.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/c2215f.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/c2215f.wgsl.expected.msl index 57ddc42d56..0ccf456dfc 100644 --- a/test/intrinsics/gen/textureDimensions/c2215f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/c2215f.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_c2215f() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_c2215f(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_c2215f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_c2215f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_c2215f(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_c2215f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_c2215f(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_c2215f(); - return; -} - - -tint_J5e0DN.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_J5e0DN.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.msl index 074981fe12..80ec0fdb47 100644 --- a/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_c30e75() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_c30e75(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_c30e75(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_c30e75(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_c30e75(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_c30e75(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_c30e75(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_c30e75(); - return; -} - - -tint_SwzetC.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_SwzetC.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/c60b66.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/c60b66.wgsl.expected.msl index 10be8b6b6f..8b823d095b 100644 --- a/test/intrinsics/gen/textureDimensions/c60b66.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/c60b66.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_c60b66() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_c60b66(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_c60b66(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_c60b66(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_c60b66(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_c60b66(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_c60b66(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_c60b66(); - return; -} - - -tint_6k1Wwt.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/c74533.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/c74533.wgsl.expected.msl index 49ee7a13d9..3a74224451 100644 --- a/test/intrinsics/gen/textureDimensions/c74533.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/c74533.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_c74533() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_c74533(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_c74533(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_c74533(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_c74533(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_c74533(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_c74533(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_c74533(); - return; -} - - -tint_E6igyy.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_E6igyy.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.msl index ba4f2af735..0800954658 100644 --- a/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_c7943d() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_c7943d(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_c7943d(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_c7943d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_c7943d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_c7943d(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_c7943d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_c7943d(); - return; -} - - -tint_3yQidg.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_3yQidg.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/caaabb.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/caaabb.wgsl.expected.msl index 2d6d08a8dd..44e18efa72 100644 --- a/test/intrinsics/gen/textureDimensions/caaabb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/caaabb.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_caaabb() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_caaabb(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_caaabb(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_caaabb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_caaabb(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_caaabb(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_caaabb(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_caaabb(); - return; -} - - -tint_DJpP79.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_DJpP79.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/cc5478.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cc5478.wgsl.expected.msl index bdfff9e870..bd3ff234e6 100644 --- a/test/intrinsics/gen/textureDimensions/cc5478.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cc5478.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cc5478() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cc5478(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_cc5478(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_cc5478(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_cc5478(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cc5478(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_cc5478(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cc5478(); - return; -} - - -tint_0velK0.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.msl index b306a45cd7..437f99c791 100644 --- a/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cc968c() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cc968c(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_cc968c(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_cc968c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_cc968c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cc968c(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_cc968c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cc968c(); - return; -} - - -tint_6Q5H36.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/cccc17.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cccc17.wgsl.expected.msl index ab3854a966..6870fbbe85 100644 --- a/test/intrinsics/gen/textureDimensions/cccc17.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cccc17.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cccc17() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cccc17(texturecube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_cccc17(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureDimensions_cccc17(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureDimensions_cccc17(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cccc17(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureDimensions_cccc17(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cccc17(); - return; -} - - -tint_U2fIpr.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_U2fIpr.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_U2fIpr.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.msl index 8a8b48b611..f039b30c86 100644 --- a/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cccc8f() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cccc8f(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_cccc8f(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_cccc8f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_cccc8f(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cccc8f(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_cccc8f(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cccc8f(); - return; -} - - -tint_OCbEI7.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.msl index 1b1d170317..20daf709b7 100644 --- a/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cd76a7() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cd76a7(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_cd76a7(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_cd76a7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_cd76a7(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cd76a7(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_cd76a7(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cd76a7(); - return; -} - - -tint_VISNvu.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_VISNvu.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_VISNvu.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/cdaff9.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cdaff9.wgsl.expected.msl index d1ae8a9c81..b2f453dbf2 100644 --- a/test/intrinsics/gen/textureDimensions/cdaff9.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cdaff9.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cdaff9() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cdaff9(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_cdaff9(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_cdaff9(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_cdaff9(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cdaff9(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_cdaff9(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cdaff9(); - return; -} - - -tint_wkmQk8.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_wkmQk8.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_wkmQk8.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.msl index eb92cd3f56..5745017aa4 100644 --- a/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cdf473() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cdf473(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_cdf473(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_cdf473(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_cdf473(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cdf473(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_cdf473(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cdf473(); - return; -} - - -tint_qj2hGZ.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_qj2hGZ.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.msl index 4f2cda2f4c..b3688fa0cd 100644 --- a/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cec841() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cec841(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_cec841(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_cec841(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_cec841(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cec841(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_cec841(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cec841(); - return; -} - - -tint_SwK5DB.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_SwK5DB.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/cf1d42.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cf1d42.wgsl.expected.msl index d69b8c75fb..20bd51d172 100644 --- a/test/intrinsics/gen/textureDimensions/cf1d42.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cf1d42.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cf1d42() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cf1d42(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_cf1d42(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_cf1d42(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_cf1d42(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cf1d42(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_cf1d42(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cf1d42(); - return; -} - - -tint_S83f2X.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.msl index 23e8921c4a..a4d7f3439c 100644 --- a/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_cf7e43() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_cf7e43(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_cf7e43(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_cf7e43(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_cf7e43(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_cf7e43(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_cf7e43(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_cf7e43(); - return; -} - - -tint_TeMQxk.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_TeMQxk.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_TeMQxk.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/d40b9e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/d40b9e.wgsl.expected.msl index ebe5e39ce9..eb9ac14eef 100644 --- a/test/intrinsics/gen/textureDimensions/d40b9e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/d40b9e.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_d40b9e() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_d40b9e(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_d40b9e(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_d40b9e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_d40b9e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_d40b9e(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_d40b9e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_d40b9e(); - return; -} - - -tint_X1JMnR.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_X1JMnR.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/d4106f.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/d4106f.wgsl.expected.msl index f0448530d4..d5dca92327 100644 --- a/test/intrinsics/gen/textureDimensions/d4106f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/d4106f.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_d4106f() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_d4106f(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_d4106f(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_d4106f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_d4106f(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_d4106f(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_d4106f(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_d4106f(); - return; -} - - -tint_kMBhTg.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_kMBhTg.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/d8f951.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/d8f951.wgsl.expected.msl index ed1390acf4..9de7a83e18 100644 --- a/test/intrinsics/gen/textureDimensions/d8f951.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/d8f951.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_d8f951() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_d8f951(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_d8f951(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_d8f951(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_d8f951(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_d8f951(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_d8f951(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_d8f951(); - return; -} - - -tint_z7tLH4.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/da3099.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/da3099.wgsl.expected.msl index fc0d392d14..10643e9923 100644 --- a/test/intrinsics/gen/textureDimensions/da3099.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/da3099.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_da3099() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_da3099(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_da3099(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_da3099(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_da3099(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_da3099(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_da3099(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_da3099(); - return; -} - - -tint_O84Slz.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_O84Slz.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_O84Slz.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.msl index 3f795189a9..ff1d7f8882 100644 --- a/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_daf7c0() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_daf7c0(texture2d_ms tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_daf7c0(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureDimensions_daf7c0(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureDimensions_daf7c0(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_daf7c0(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureDimensions_daf7c0(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_daf7c0(); - return; -} - - -tint_5xXP11.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_5xXP11.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/dba47c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/dba47c.wgsl.expected.msl index 2caf8c1d30..f3b4139398 100644 --- a/test/intrinsics/gen/textureDimensions/dba47c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/dba47c.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_dba47c() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_dba47c(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_dba47c(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_dba47c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_dba47c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_dba47c(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_dba47c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_dba47c(); - return; -} - - -tint_EKCC5G.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.msl index 46d0e9844f..4c9cd2cd10 100644 --- a/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_dc2dd0() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_dc2dd0(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_dc2dd0(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_dc2dd0(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_dc2dd0(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_dc2dd0(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_dc2dd0(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_dc2dd0(); - return; -} - - -tint_uUYkvN.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/e10157.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/e10157.wgsl.expected.msl index c0a6001c05..87b491ab36 100644 --- a/test/intrinsics/gen/textureDimensions/e10157.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/e10157.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_e10157() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_e10157(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_e10157(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_e10157(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_e10157(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_e10157(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_e10157(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_e10157(); - return; -} - - -tint_i8ZUzz.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_i8ZUzz.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/e22247.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/e22247.wgsl.expected.msl index 76a891c98b..48b64a2913 100644 --- a/test/intrinsics/gen/textureDimensions/e22247.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/e22247.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_e22247() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_e22247(texturecube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_e22247(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_e22247(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_e22247(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_e22247(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_e22247(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_e22247(); - return; -} - - -tint_57n5Dl.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_57n5Dl.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_57n5Dl.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/e93464.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/e93464.wgsl.expected.msl index ee0b851e07..39312ace7a 100644 --- a/test/intrinsics/gen/textureDimensions/e93464.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/e93464.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_e93464() { - int res = int(arg_0.get_width()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_e93464(texture1d tint_symbol_2) { + int res = int(tint_symbol_2.get_width()); } -vertex void vertex_main() { - textureDimensions_e93464(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureDimensions_e93464(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureDimensions_e93464(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_e93464(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureDimensions_e93464(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_e93464(); - return; -} - - -tint_YaTuvv.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_width()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureDimensions/e9628c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/e9628c.wgsl.expected.msl index 5017a2d7bd..8b37edf690 100644 --- a/test/intrinsics/gen/textureDimensions/e9628c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/e9628c.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_e9628c() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_e9628c(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_e9628c(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_e9628c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_e9628c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_e9628c(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_e9628c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_e9628c(); - return; -} - - -tint_MmSOA1.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_MmSOA1.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.msl index 394dca6902..a7d7c297d3 100644 --- a/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_e9e96c() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_e9e96c(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_e9e96c(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_e9e96c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_e9e96c(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_e9e96c(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_e9e96c(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_e9e96c(); - return; -} - - -tint_AH7LwX.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_AH7LwX.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/e9fe54.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/e9fe54.wgsl.expected.msl index e1665b7233..c3db723b0e 100644 --- a/test/intrinsics/gen/textureDimensions/e9fe54.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/e9fe54.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_e9fe54() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_e9fe54(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_e9fe54(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_e9fe54(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_e9fe54(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_e9fe54(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_e9fe54(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_e9fe54(); - return; -} - - -tint_YVYyTW.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_YVYyTW.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/e9fe58.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/e9fe58.wgsl.expected.msl index a18dd38180..d36a085cda 100644 --- a/test/intrinsics/gen/textureDimensions/e9fe58.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/e9fe58.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_e9fe58() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_e9fe58(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_e9fe58(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_e9fe58(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_e9fe58(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_e9fe58(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_e9fe58(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_e9fe58(); - return; -} - - -tint_RswUR8.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_RswUR8.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/eda4e3.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/eda4e3.wgsl.expected.msl index 2290c1df10..5cc7d40200 100644 --- a/test/intrinsics/gen/textureDimensions/eda4e3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/eda4e3.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_eda4e3() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_eda4e3(texturecube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_eda4e3(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_eda4e3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_eda4e3(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_eda4e3(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_eda4e3(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_eda4e3(); - return; -} - - -tint_GLqIhV.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_GLqIhV.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -tint_GLqIhV.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_height(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.msl index 93769a95b2..0b8bea33c8 100644 --- a/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_ef5b89() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_ef5b89(texture2d_ms tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_ef5b89(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureDimensions_ef5b89(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureDimensions_ef5b89(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_ef5b89(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureDimensions_ef5b89(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_ef5b89(); - return; -} - - -tint_MEwQTz.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_MEwQTz.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.msl index 35d024c836..8537677e87 100644 --- a/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_efc8a4() { - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_efc8a4(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1), tint_symbol_2.get_depth(1)); } -vertex void vertex_main() { - textureDimensions_efc8a4(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_efc8a4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_efc8a4(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_efc8a4(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_efc8a4(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_efc8a4(); - return; -} - - -tint_VKcQYC.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -tint_VKcQYC.metal:5:39: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -tint_VKcQYC.metal:5:60: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(1), arg_0.get_height(1), arg_0.get_depth(1)); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/f1b72b.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/f1b72b.wgsl.expected.msl index f77285e0ba..03d14107db 100644 --- a/test/intrinsics/gen/textureDimensions/f1b72b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/f1b72b.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_f1b72b() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_f1b72b(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_f1b72b(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_f1b72b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_f1b72b(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_f1b72b(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_f1b72b(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_f1b72b(); - return; -} - - -tint_ABnmGI.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_ABnmGI.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/f507c9.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/f507c9.wgsl.expected.msl index 9263173a5b..a35a3a0c6d 100644 --- a/test/intrinsics/gen/textureDimensions/f507c9.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/f507c9.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_f507c9() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_f507c9(texturecube tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_f507c9(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureDimensions_f507c9(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureDimensions_f507c9(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_f507c9(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureDimensions_f507c9(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_f507c9(); - return; -} - - -tint_bJqzWF.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_bJqzWF.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_bJqzWF.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/f70326.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/f70326.wgsl.expected.msl index 17338a724e..907634aa82 100644 --- a/test/intrinsics/gen/textureDimensions/f70326.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/f70326.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_f70326() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_f70326(texturecube_array tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_f70326(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_f70326(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_f70326(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_f70326(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_f70326(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_f70326(); - return; -} - - -tint_fUHJfB.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_fUHJfB.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -tint_fUHJfB.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_height()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.msl index 260fc18a19..b144b7d1ba 100644 --- a/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_f7145b() { - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_f7145b(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(1), tint_symbol_2.get_height(1)); } -vertex void vertex_main() { - textureDimensions_f7145b(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_f7145b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_f7145b(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_f7145b(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_f7145b(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_f7145b(); - return; -} - - -tint_zCqbpt.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -tint_zCqbpt.metal:5:39: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(1), arg_0.get_height(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/f7aa9e.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/f7aa9e.wgsl.expected.msl index 0ff3c91082..52112bc0d9 100644 --- a/test/intrinsics/gen/textureDimensions/f7aa9e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/f7aa9e.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_f7aa9e() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_f7aa9e(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_f7aa9e(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_f7aa9e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_f7aa9e(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_f7aa9e(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_f7aa9e(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_f7aa9e(); - return; -} - - -tint_53o5jc.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_53o5jc.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/f7e436.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/f7e436.wgsl.expected.msl index 020b3f1f55..bb7d49e27b 100644 --- a/test/intrinsics/gen/textureDimensions/f7e436.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/f7e436.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_f7e436() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_f7e436(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_f7e436(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_f7e436(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_f7e436(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_f7e436(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_f7e436(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_f7e436(); - return; -} - - -tint_qF7VTP.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_qF7VTP.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.msl index 204705ebc6..495657b77f 100644 --- a/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_f931c7() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_f931c7(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_f931c7(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_f931c7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_f931c7(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_f931c7(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_f931c7(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_f931c7(); - return; -} - - -tint_af2gOe.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_af2gOe.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/fa90e1.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/fa90e1.wgsl.expected.msl index 1325749ac6..4275f66a29 100644 --- a/test/intrinsics/gen/textureDimensions/fa90e1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/fa90e1.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_fa90e1() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_fa90e1(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_fa90e1(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_fa90e1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_fa90e1(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_fa90e1(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_fa90e1(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_fa90e1(); - return; -} - - -tint_hCi2mv.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_hCi2mv.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.msl index a5f4fea94e..38e0620490 100644 --- a/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_fa9859() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_fa9859(texture2d tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_fa9859(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureDimensions_fa9859(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureDimensions_fa9859(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_fa9859(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureDimensions_fa9859(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_fa9859(); - return; -} - - -tint_Jef2wt.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_Jef2wt.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.msl index 36ca7808aa..ac2553fac1 100644 --- a/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_fb5670() { - int2 res = int2(arg_0.get_width(), arg_0.get_height()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_fb5670(texture2d_array tint_symbol_2) { + int2 res = int2(tint_symbol_2.get_width(), tint_symbol_2.get_height()); } -vertex void vertex_main() { - textureDimensions_fb5670(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureDimensions_fb5670(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureDimensions_fb5670(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_fb5670(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureDimensions_fb5670(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_fb5670(); - return; -} - - -tint_Rgwrfb.metal:5:19: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -tint_Rgwrfb.metal:5:38: error: use of undeclared identifier 'arg_0' - int2 res = int2(arg_0.get_width(), arg_0.get_height()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/fbbe4d.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/fbbe4d.wgsl.expected.msl index b0454dbbfa..3353e4ca92 100644 --- a/test/intrinsics/gen/textureDimensions/fbbe4d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/fbbe4d.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_fbbe4d() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_fbbe4d(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_fbbe4d(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_fbbe4d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_fbbe4d(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_fbbe4d(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_fbbe4d(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_fbbe4d(); - return; -} - - -tint_h7tqyr.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_h7tqyr.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_h7tqyr.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.msl b/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.msl index e2ca28c072..36e420b4ec 100644 --- a/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.msl +++ b/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.msl @@ -1,38 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureDimensions_fcac78() { - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureDimensions_fcac78(texture3d tint_symbol_2) { + int3 res = int3(tint_symbol_2.get_width(), tint_symbol_2.get_height(), tint_symbol_2.get_depth()); } -vertex void vertex_main() { - textureDimensions_fcac78(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureDimensions_fcac78(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureDimensions_fcac78(tint_symbol_4); return; } -fragment void fragment_main() { - textureDimensions_fcac78(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureDimensions_fcac78(tint_symbol_5); return; } -kernel void compute_main() { - textureDimensions_fcac78(); - return; -} - - -tint_nsbNpw.metal:5:19: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_nsbNpw.metal:5:38: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -tint_nsbNpw.metal:5:58: error: use of undeclared identifier 'arg_0' - int3 res = int3(arg_0.get_width(), arg_0.get_height(), arg_0.get_depth()); - ^ -3 errors generated. diff --git a/test/intrinsics/gen/textureLoad/050c33.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/050c33.wgsl.expected.msl index 834283463f..59a30414d5 100644 --- a/test/intrinsics/gen/textureLoad/050c33.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/050c33.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_050c33() { - uint4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_050c33(texture2d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_050c33(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_050c33(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_050c33(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_050c33(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_050c33(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_050c33(); - return; -} - - -tint_YLQCFG.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/072e26.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/072e26.wgsl.expected.msl index 9bee2e90b2..634584347a 100644 --- a/test/intrinsics/gen/textureLoad/072e26.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/072e26.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_072e26() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_072e26(texture2d_array tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_072e26(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_072e26(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_072e26(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_072e26(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_072e26(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_072e26(); - return; -} - - -tint_JrhYNT.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/078bc4.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/078bc4.wgsl.expected.msl index d5062a1bd0..0b7a6522c9 100644 --- a/test/intrinsics/gen/textureLoad/078bc4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/078bc4.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_078bc4() { - float4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_078bc4(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_078bc4(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_078bc4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_078bc4(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_078bc4(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_078bc4(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_078bc4(); - return; -} - - -tint_jjAKvY.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/127e12.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/127e12.wgsl.expected.msl index a996429178..1cc3ec47c4 100644 --- a/test/intrinsics/gen/textureLoad/127e12.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/127e12.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_127e12() { - uint4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_127e12(texture2d_array tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_127e12(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_127e12(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_127e12(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_127e12(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_127e12(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_127e12(); - return; -} - - -tint_cm9xwP.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/1561a7.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/1561a7.wgsl.expected.msl index 56f55670d6..203ac151ad 100644 --- a/test/intrinsics/gen/textureLoad/1561a7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/1561a7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_1561a7() { - uint4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_1561a7(texture1d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_1561a7(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_1561a7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_1561a7(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_1561a7(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_1561a7(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_1561a7(); - return; -} - - -tint_o82pOs.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.msl index 94d4866ba1..47fc544645 100644 --- a/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_19cf87() { - float res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_19cf87(depth2d tint_symbol_2) { + float res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_19cf87(); +vertex tint_symbol vertex_main(depth2d tint_symbol_3 [[texture(0)]]) { + textureLoad_19cf87(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d tint_symbol_4 [[texture(0)]]) { + textureLoad_19cf87(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_19cf87(); +kernel void compute_main(depth2d tint_symbol_5 [[texture(0)]]) { + textureLoad_19cf87(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_19cf87(); - return; -} - - -tint_AKv56M.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/1a062f.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/1a062f.wgsl.expected.msl index bb6c46bd7a..8e22867927 100644 --- a/test/intrinsics/gen/textureLoad/1a062f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/1a062f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_1a062f() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_1a062f(texture2d_array tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_1a062f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_1a062f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_1a062f(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_1a062f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_1a062f(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_1a062f(); - return; -} - - -tint_vRBu5V.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/1a8452.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/1a8452.wgsl.expected.msl index 6ecab82ce5..ff0f972b9b 100644 --- a/test/intrinsics/gen/textureLoad/1a8452.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/1a8452.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_1a8452() { - uint4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_1a8452(texture1d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_1a8452(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_1a8452(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_1a8452(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_1a8452(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_1a8452(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_1a8452(); - return; -} - - -tint_E0YZXD.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.msl index afae3cf954..50729e0980 100644 --- a/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.msl @@ -6,27 +6,64 @@ Validation Failure: #include using namespace metal; -void textureLoad_1b8588() { - uint4 res = arg_0.read(1, 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_1b8588(thread texture1d* const tint_symbol_2) { + uint4 res = (*(tint_symbol_2)).read(uint(1), 1); } -vertex void vertex_main() { - textureLoad_1b8588(); +vertex tint_symbol vertex_main(texture1d tint_symbol_4 [[texture(0)]]) { + texture1d tint_symbol_5 = tint_symbol_4; + thread texture1d* const tint_symbol_3 = &(tint_symbol_5); + textureLoad_1b8588(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_7 [[texture(0)]]) { + texture1d tint_symbol_8 = tint_symbol_7; + thread texture1d* const tint_symbol_6 = &(tint_symbol_8); + textureLoad_1b8588(tint_symbol_6); return; } -fragment void fragment_main() { - textureLoad_1b8588(); - return; -} - -kernel void compute_main() { - textureLoad_1b8588(); +kernel void compute_main(texture1d tint_symbol_10 [[texture(0)]]) { + texture1d tint_symbol_11 = tint_symbol_10; + thread texture1d* const tint_symbol_9 = &(tint_symbol_11); + textureLoad_1b8588(tint_symbol_9); return; } -tint_8clnPn.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(1, 1); - ^ -1 error generated. +Compilation failed: + +program_source:9:34: error: no matching member function for call to 'read' + uint4 res = (*(tint_symbol_2)).read(uint(1), 1); + ~~~~~~~~~~~~~~~~~~~^~~~ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1132:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d' (aka 'texture1d')), parameter type must be 'const device metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1164:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d' (aka 'texture1d')), parameter type must be 'const constant metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1196:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d' (aka 'texture1d')), parameter type must be 'const ray_data metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const ray_data METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1117:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d' (aka 'texture1d')), parameter type must be 'const device metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1149:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d' (aka 'texture1d')), parameter type must be 'const constant metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1181:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d' (aka 'texture1d')), parameter type must be 'const ray_data metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const ray_data METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1086:24: note: candidate disabled: 'lod' argument value must be 0 + METAL_FUNC vec read(ushort coord, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ ~~~~~~~~~~~~~~~~~~~ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1101:24: note: candidate disabled: 'lod' argument value must be 0 + METAL_FUNC vec read(uint coord, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ ~~~~~~~~~~~~~~~~~~~ + diff --git a/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.msl index a1422f8183..b8f035a6af 100644 --- a/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_1f2016() { - float4 res = arg_0.read(int3(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_1f2016(texture3d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint3(int3()), 1); } -vertex void vertex_main() { - textureLoad_1f2016(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_1f2016(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_1f2016(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_1f2016(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_1f2016(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_1f2016(); - return; -} - - -tint_PZhzf3.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int3(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/20fa2f.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/20fa2f.wgsl.expected.msl index fecc8ce4b0..cbdfc5f21c 100644 --- a/test/intrinsics/gen/textureLoad/20fa2f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/20fa2f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_20fa2f() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_20fa2f(texture2d_array tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_20fa2f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_20fa2f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_20fa2f(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_20fa2f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_20fa2f(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_20fa2f(); - return; -} - - -tint_laj3aH.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/276a2c.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/276a2c.wgsl.expected.msl index 763246745c..e4d228ce02 100644 --- a/test/intrinsics/gen/textureLoad/276a2c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/276a2c.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_276a2c() { - uint4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_276a2c(texture1d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_276a2c(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_276a2c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_276a2c(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_276a2c(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_276a2c(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_276a2c(); - return; -} - - -tint_d2GdWr.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/2887d7.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/2887d7.wgsl.expected.msl index 452af57ca2..69584cb522 100644 --- a/test/intrinsics/gen/textureLoad/2887d7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/2887d7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_2887d7() { - float4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_2887d7(texture1d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_2887d7(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_2887d7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_2887d7(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_2887d7(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_2887d7(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_2887d7(); - return; -} - - -tint_Woie28.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/2ae485.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/2ae485.wgsl.expected.msl index 3844142fcd..434a22effb 100644 --- a/test/intrinsics/gen/textureLoad/2ae485.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/2ae485.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_2ae485() { - int4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_2ae485(texture2d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_2ae485(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_2ae485(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_2ae485(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_2ae485(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_2ae485(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_2ae485(); - return; -} - - -tint_bpTyQu.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/2d6cf7.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/2d6cf7.wgsl.expected.msl index 9395679cde..427e98f348 100644 --- a/test/intrinsics/gen/textureLoad/2d6cf7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/2d6cf7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_2d6cf7() { - int4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_2d6cf7(texture1d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_2d6cf7(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_2d6cf7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_2d6cf7(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_2d6cf7(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_2d6cf7(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_2d6cf7(); - return; -} - - -tint_UsuKLT.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/3c0d9e.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/3c0d9e.wgsl.expected.msl index 89d32a1599..e75b199acb 100644 --- a/test/intrinsics/gen/textureLoad/3c0d9e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/3c0d9e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_3c0d9e() { - uint4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_3c0d9e(texture2d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_3c0d9e(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_3c0d9e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_3c0d9e(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_3c0d9e(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_3c0d9e(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_3c0d9e(); - return; -} - - -tint_RbcsGC.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/3c9587.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/3c9587.wgsl.expected.msl index 60712e66c0..cc88af5fe1 100644 --- a/test/intrinsics/gen/textureLoad/3c9587.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/3c9587.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_3c9587() { - float4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_3c9587(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_3c9587(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_3c9587(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_3c9587(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_3c9587(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_3c9587(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_3c9587(); - return; -} - - -tint_LgFWEE.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/3d001b.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/3d001b.wgsl.expected.msl index d55d6ac507..6afb309e89 100644 --- a/test/intrinsics/gen/textureLoad/3d001b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/3d001b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_3d001b() { - int4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_3d001b(texture3d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_3d001b(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_3d001b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_3d001b(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_3d001b(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_3d001b(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_3d001b(); - return; -} - - -tint_OhK8qo.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/3d9c90.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/3d9c90.wgsl.expected.msl index 737e62688e..bcdf185826 100644 --- a/test/intrinsics/gen/textureLoad/3d9c90.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/3d9c90.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_3d9c90() { - float4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_3d9c90(texture3d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_3d9c90(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_3d9c90(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_3d9c90(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_3d9c90(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_3d9c90(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_3d9c90(); - return; -} - - -tint_jsl4ld.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/484344.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/484344.wgsl.expected.msl index 9d40169275..2b581c6a6c 100644 --- a/test/intrinsics/gen/textureLoad/484344.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/484344.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_484344() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_484344(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_484344(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_484344(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_484344(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_484344(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_484344(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_484344(); - return; -} - - -tint_kMAwof.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.msl index 3d1c4ce647..697c8292ea 100644 --- a/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_4fd803() { - int4 res = arg_0.read(int3(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_4fd803(texture3d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint3(int3()), 1); } -vertex void vertex_main() { - textureLoad_4fd803(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_4fd803(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_4fd803(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_4fd803(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_4fd803(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_4fd803(); - return; -} - - -tint_LFK7PX.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int3(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/505aa2.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/505aa2.wgsl.expected.msl index afbf77baaa..26a387450a 100644 --- a/test/intrinsics/gen/textureLoad/505aa2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/505aa2.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_505aa2() { - int4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_505aa2(texture3d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_505aa2(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_505aa2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_505aa2(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_505aa2(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_505aa2(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_505aa2(); - return; -} - - -tint_B775lh.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/519ab5.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/519ab5.wgsl.expected.msl index e9a10b558a..f325aa3d42 100644 --- a/test/intrinsics/gen/textureLoad/519ab5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/519ab5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_519ab5() { - float4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_519ab5(texture1d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_519ab5(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_519ab5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_519ab5(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_519ab5(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_519ab5(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_519ab5(); - return; -} - - -tint_ApSVcX.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/53378a.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/53378a.wgsl.expected.msl index 6014dee21c..5b277a77b0 100644 --- a/test/intrinsics/gen/textureLoad/53378a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/53378a.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_53378a() { - int4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_53378a(texture2d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_53378a(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_53378a(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_53378a(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_53378a(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_53378a(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_53378a(); - return; -} - - -tint_xZcA0b.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/560573.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/560573.wgsl.expected.msl index 0eb867438c..4d1bf7b82f 100644 --- a/test/intrinsics/gen/textureLoad/560573.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/560573.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_560573() { - int4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_560573(texture2d_array tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_560573(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_560573(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_560573(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_560573(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_560573(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_560573(); - return; -} - - -tint_cktG5W.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/582015.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/582015.wgsl.expected.msl index b64322d4a0..1fb0823658 100644 --- a/test/intrinsics/gen/textureLoad/582015.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/582015.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_582015() { - int4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_582015(texture2d_array tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_582015(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_582015(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_582015(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_582015(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_582015(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_582015(); - return; -} - - -tint_qpBH7K.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.msl index 6ed398fad0..7a922a6f56 100644 --- a/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.msl @@ -6,27 +6,64 @@ Validation Failure: #include using namespace metal; -void textureLoad_5a2f9d() { - int4 res = arg_0.read(1, 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_5a2f9d(thread texture1d* const tint_symbol_2) { + int4 res = (*(tint_symbol_2)).read(uint(1), 1); } -vertex void vertex_main() { - textureLoad_5a2f9d(); +vertex tint_symbol vertex_main(texture1d tint_symbol_4 [[texture(0)]]) { + texture1d tint_symbol_5 = tint_symbol_4; + thread texture1d* const tint_symbol_3 = &(tint_symbol_5); + textureLoad_5a2f9d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_7 [[texture(0)]]) { + texture1d tint_symbol_8 = tint_symbol_7; + thread texture1d* const tint_symbol_6 = &(tint_symbol_8); + textureLoad_5a2f9d(tint_symbol_6); return; } -fragment void fragment_main() { - textureLoad_5a2f9d(); - return; -} - -kernel void compute_main() { - textureLoad_5a2f9d(); +kernel void compute_main(texture1d tint_symbol_10 [[texture(0)]]) { + texture1d tint_symbol_11 = tint_symbol_10; + thread texture1d* const tint_symbol_9 = &(tint_symbol_11); + textureLoad_5a2f9d(tint_symbol_9); return; } -tint_CRtFdW.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(1, 1); - ^ -1 error generated. +Compilation failed: + +program_source:9:33: error: no matching member function for call to 'read' + int4 res = (*(tint_symbol_2)).read(uint(1), 1); + ~~~~~~~~~~~~~~~~~~~^~~~ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1132:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const device metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1164:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const constant metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1196:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const ray_data metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const ray_data METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1117:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const device metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1149:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const constant metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1181:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const ray_data metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const ray_data METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1086:24: note: candidate disabled: 'lod' argument value must be 0 + METAL_FUNC vec read(ushort coord, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ ~~~~~~~~~~~~~~~~~~~ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1101:24: note: candidate disabled: 'lod' argument value must be 0 + METAL_FUNC vec read(uint coord, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ ~~~~~~~~~~~~~~~~~~~ + diff --git a/test/intrinsics/gen/textureLoad/5bb7fb.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/5bb7fb.wgsl.expected.msl index b0e3ec01a6..b1ad6746e0 100644 --- a/test/intrinsics/gen/textureLoad/5bb7fb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/5bb7fb.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_5bb7fb() { - uint4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_5bb7fb(texture1d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_5bb7fb(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_5bb7fb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_5bb7fb(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_5bb7fb(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_5bb7fb(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_5bb7fb(); - return; -} - - -tint_7znWmf.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/5d0a2f.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/5d0a2f.wgsl.expected.msl index 8b917290ee..cc781f6d30 100644 --- a/test/intrinsics/gen/textureLoad/5d0a2f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/5d0a2f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_5d0a2f() { - uint4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_5d0a2f(texture2d_array tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_5d0a2f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_5d0a2f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_5d0a2f(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_5d0a2f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_5d0a2f(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_5d0a2f(); - return; -} - - -tint_hkcUe3.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.msl index 2adcb35c52..c87ec8e058 100644 --- a/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_6154d4() { - uint4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_6154d4(texture2d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_6154d4(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_6154d4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_6154d4(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_6154d4(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_6154d4(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_6154d4(); - return; -} - - -tint_i3aA5Y.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/62d125.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/62d125.wgsl.expected.msl index 9e5a3c159a..eed23cf311 100644 --- a/test/intrinsics/gen/textureLoad/62d125.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/62d125.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_62d125() { - float4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_62d125(texture3d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_62d125(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_62d125(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_62d125(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_62d125(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_62d125(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_62d125(); - return; -} - - -tint_7Etnvc.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/6678b6.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/6678b6.wgsl.expected.msl index cbfb396ac6..0cf2a48ed5 100644 --- a/test/intrinsics/gen/textureLoad/6678b6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/6678b6.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_6678b6() { - int4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_6678b6(texture1d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_6678b6(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_6678b6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_6678b6(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_6678b6(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_6678b6(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_6678b6(); - return; -} - - -tint_jYZ5PL.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/67edca.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/67edca.wgsl.expected.msl index ead27c9475..cc59d2f617 100644 --- a/test/intrinsics/gen/textureLoad/67edca.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/67edca.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_67edca() { - uint4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_67edca(texture3d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_67edca(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_67edca(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_67edca(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_67edca(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_67edca(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_67edca(); - return; -} - - -tint_6fwyP5.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/749704.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/749704.wgsl.expected.msl index ef756da3be..d2a9aa7f8f 100644 --- a/test/intrinsics/gen/textureLoad/749704.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/749704.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_749704() { - uint4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_749704(texture2d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_749704(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_749704(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_749704(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_749704(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_749704(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_749704(); - return; -} - - -tint_h41DHl.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.msl index a592ca735f..c065d50793 100644 --- a/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_79e697() { - int4 res = arg_0.read(int2(), 1, 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_79e697(texture2d_array tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1, 1); } -vertex void vertex_main() { - textureLoad_79e697(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_79e697(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_79e697(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_79e697(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_79e697(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_79e697(); - return; -} - - -tint_0CahWp.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1, 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.msl index add45a9ff9..0ca9e0608f 100644 --- a/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_7c90e5() { - uint4 res = arg_0.read(int2(), 1, 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_7c90e5(texture2d_array tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1, 1); } -vertex void vertex_main() { - textureLoad_7c90e5(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_7c90e5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_7c90e5(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_7c90e5(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_7c90e5(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_7c90e5(); - return; -} - - -tint_cSpOsM.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1, 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.msl index b244c3a1df..f583a3ecc6 100644 --- a/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.msl @@ -6,27 +6,64 @@ Validation Failure: #include using namespace metal; -void textureLoad_81c381() { - float4 res = arg_0.read(1, 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_81c381(thread texture1d* const tint_symbol_2) { + float4 res = (*(tint_symbol_2)).read(uint(1), 1); } -vertex void vertex_main() { - textureLoad_81c381(); +vertex tint_symbol vertex_main(texture1d tint_symbol_4 [[texture(0)]]) { + texture1d tint_symbol_5 = tint_symbol_4; + thread texture1d* const tint_symbol_3 = &(tint_symbol_5); + textureLoad_81c381(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_7 [[texture(0)]]) { + texture1d tint_symbol_8 = tint_symbol_7; + thread texture1d* const tint_symbol_6 = &(tint_symbol_8); + textureLoad_81c381(tint_symbol_6); return; } -fragment void fragment_main() { - textureLoad_81c381(); - return; -} - -kernel void compute_main() { - textureLoad_81c381(); +kernel void compute_main(texture1d tint_symbol_10 [[texture(0)]]) { + texture1d tint_symbol_11 = tint_symbol_10; + thread texture1d* const tint_symbol_9 = &(tint_symbol_11); + textureLoad_81c381(tint_symbol_9); return; } -tint_w456fy.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(1, 1); - ^ -1 error generated. +Compilation failed: + +program_source:9:35: error: no matching member function for call to 'read' + float4 res = (*(tint_symbol_2)).read(uint(1), 1); + ~~~~~~~~~~~~~~~~~~~^~~~ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1132:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const device metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1164:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const constant metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1196:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const ray_data metal::texture1d' + METAL_FUNC vec read(uint coord, uint lod = 0) const ray_data METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1117:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const device metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const device METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1149:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const constant metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const constant METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1181:24: note: candidate function not viable: address space mismatch in 'this' argument ('texture1d'), parameter type must be 'const ray_data metal::texture1d' + METAL_FUNC vec read(ushort coord, ushort lod = 0) const ray_data METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1086:24: note: candidate disabled: 'lod' argument value must be 0 + METAL_FUNC vec read(ushort coord, ushort lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ ~~~~~~~~~~~~~~~~~~~ +/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/31001/Libraries/lib/clang/31001.189/include/metal/metal_texture:1101:24: note: candidate disabled: 'lod' argument value must be 0 + METAL_FUNC vec read(uint coord, uint lod = 0) const thread METAL_CONST_ARG(lod) METAL_ZERO_ARG(lod) + ^ ~~~~~~~~~~~~~~~~~~~ + diff --git a/test/intrinsics/gen/textureLoad/83cea4.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/83cea4.wgsl.expected.msl index 59a2bca6e8..9842a839e8 100644 --- a/test/intrinsics/gen/textureLoad/83cea4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/83cea4.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_83cea4() { - uint4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_83cea4(texture1d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_83cea4(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_83cea4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_83cea4(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_83cea4(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_83cea4(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_83cea4(); - return; -} - - -tint_7kpW9b.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.msl index ea046202e3..0cecff9e15 100644 --- a/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_87be85() { - float4 res = arg_0.read(int2(), 1, 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_87be85(texture2d_array tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1, 1); } -vertex void vertex_main() { - textureLoad_87be85(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_87be85(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_87be85(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_87be85(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_87be85(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_87be85(); - return; -} - - -tint_8RPPdu.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1, 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.msl index 1419abf976..a98d05ec20 100644 --- a/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_8acf41() { - float4 res = arg_0.read(int2(), 0); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_8acf41(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 0); } -vertex void vertex_main() { - textureLoad_8acf41(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_8acf41(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_8acf41(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_8acf41(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_8acf41(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_8acf41(); - return; -} - - -tint_olJAtB.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 0); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/8e5032.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/8e5032.wgsl.expected.msl index 42a75d74df..65a656bf05 100644 --- a/test/intrinsics/gen/textureLoad/8e5032.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/8e5032.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_8e5032() { - uint4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_8e5032(texture2d_array tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_8e5032(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_8e5032(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_8e5032(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_8e5032(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_8e5032(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_8e5032(); - return; -} - - -tint_N2THrH.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/936952.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/936952.wgsl.expected.msl index 211f973fb7..67f2aad97b 100644 --- a/test/intrinsics/gen/textureLoad/936952.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/936952.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_936952() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_936952(texture2d_array tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_936952(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_936952(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_936952(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_936952(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_936952(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_936952(); - return; -} - - -tint_Cky0g4.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/9a7c90.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/9a7c90.wgsl.expected.msl index 3e6872e44a..d4cde5dcd6 100644 --- a/test/intrinsics/gen/textureLoad/9a7c90.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/9a7c90.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_9a7c90() { - uint4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_9a7c90(texture3d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_9a7c90(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_9a7c90(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_9a7c90(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_9a7c90(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_9a7c90(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_9a7c90(); - return; -} - - -tint_UQd2nQ.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.msl index 9eb5e2408f..dc5aa61b70 100644 --- a/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_9b2667() { - float res = arg_0.read(int2(), 1, 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_9b2667(depth2d_array tint_symbol_2) { + float res = tint_symbol_2.read(uint2(int2()), 1, 1); } -vertex void vertex_main() { - textureLoad_9b2667(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_9b2667(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_9b2667(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_9b2667(); +kernel void compute_main(depth2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_9b2667(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_9b2667(); - return; -} - - -tint_t9cZ5X.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.read(int2(), 1, 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/9c2a14.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/9c2a14.wgsl.expected.msl index 9fa3c708e7..e40deb22bd 100644 --- a/test/intrinsics/gen/textureLoad/9c2a14.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/9c2a14.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_9c2a14() { - float4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_9c2a14(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_9c2a14(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_9c2a14(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_9c2a14(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_9c2a14(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_9c2a14(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_9c2a14(); - return; -} - - -tint_XqayFJ.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.msl index 72ba5fbccd..3d286b598a 100644 --- a/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_a583c9() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_a583c9(texture2d_ms tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_a583c9(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureLoad_a583c9(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureLoad_a583c9(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_a583c9(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureLoad_a583c9(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_a583c9(); - return; -} - - -tint_0WA0ve.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/a6a85a.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/a6a85a.wgsl.expected.msl index 81c2d07d54..9073153a7b 100644 --- a/test/intrinsics/gen/textureLoad/a6a85a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/a6a85a.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_a6a85a() { - float4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_a6a85a(texture3d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_a6a85a(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_a6a85a(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_a6a85a(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_a6a85a(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_a6a85a(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_a6a85a(); - return; -} - - -tint_MZOSDo.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/a6b61d.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/a6b61d.wgsl.expected.msl index 741e9d047e..02ef514d11 100644 --- a/test/intrinsics/gen/textureLoad/a6b61d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/a6b61d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_a6b61d() { - int4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_a6b61d(texture2d_array tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_a6b61d(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_a6b61d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_a6b61d(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_a6b61d(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_a6b61d(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_a6b61d(); - return; -} - - -tint_MCK3GD.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/a7a3c3.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/a7a3c3.wgsl.expected.msl index 04e3168c05..ffea365df0 100644 --- a/test/intrinsics/gen/textureLoad/a7a3c3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/a7a3c3.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_a7a3c3() { - int4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_a7a3c3(texture3d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_a7a3c3(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_a7a3c3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_a7a3c3(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_a7a3c3(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_a7a3c3(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_a7a3c3(); - return; -} - - -tint_rFvCL7.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.msl index c7341437ed..3699b7f6ae 100644 --- a/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_a9a9f5() { - uint4 res = arg_0.read(int3(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_a9a9f5(texture3d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint3(int3()), 1); } -vertex void vertex_main() { - textureLoad_a9a9f5(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_a9a9f5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_a9a9f5(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_a9a9f5(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_a9a9f5(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_a9a9f5(); - return; -} - - -tint_XRA6On.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int3(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/b1bf79.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/b1bf79.wgsl.expected.msl index a94e96bcc7..a20c8181e5 100644 --- a/test/intrinsics/gen/textureLoad/b1bf79.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/b1bf79.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_b1bf79() { - int4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_b1bf79(texture3d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_b1bf79(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_b1bf79(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_b1bf79(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_b1bf79(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_b1bf79(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_b1bf79(); - return; -} - - -tint_YXVObw.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/b58c6d.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/b58c6d.wgsl.expected.msl index 24d5f4951b..1f48ddca5e 100644 --- a/test/intrinsics/gen/textureLoad/b58c6d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/b58c6d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_b58c6d() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_b58c6d(texture2d_array tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_b58c6d(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_b58c6d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_b58c6d(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_b58c6d(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_b58c6d(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_b58c6d(); - return; -} - - -tint_l0fo2E.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/b6c458.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/b6c458.wgsl.expected.msl index 05acd49bfc..01a20b5cf7 100644 --- a/test/intrinsics/gen/textureLoad/b6c458.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/b6c458.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_b6c458() { - uint4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_b6c458(texture2d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_b6c458(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_b6c458(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_b6c458(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_b6c458(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_b6c458(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_b6c458(); - return; -} - - -tint_VddxXh.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/bfd154.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/bfd154.wgsl.expected.msl index b24fd26e63..02c81eeb61 100644 --- a/test/intrinsics/gen/textureLoad/bfd154.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/bfd154.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_bfd154() { - uint4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_bfd154(texture3d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_bfd154(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_bfd154(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_bfd154(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_bfd154(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_bfd154(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_bfd154(); - return; -} - - -tint_s46SKh.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c02b74.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c02b74.wgsl.expected.msl index 5e004de5dc..24779c56c6 100644 --- a/test/intrinsics/gen/textureLoad/c02b74.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c02b74.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c02b74() { - float4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c02b74(texture1d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_c02b74(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_c02b74(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_c02b74(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c02b74(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_c02b74(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c02b74(); - return; -} - - -tint_plnP7W.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c07013.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c07013.wgsl.expected.msl index 6fa38577d6..d0b249d83d 100644 --- a/test/intrinsics/gen/textureLoad/c07013.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c07013.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c07013() { - float4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c07013(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_c07013(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_c07013(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_c07013(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c07013(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_c07013(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c07013(); - return; -} - - -tint_uSEFIK.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.msl index d7f7741e4d..662b243d7d 100644 --- a/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c2a480() { - int4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c2a480(texture2d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_c2a480(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_c2a480(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_c2a480(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c2a480(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_c2a480(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c2a480(); - return; -} - - -tint_PlRj7V.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.msl index c7280359ac..83a8003e4d 100644 --- a/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c378ee() { - uint4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c378ee(texture2d_ms tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_c378ee(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureLoad_c378ee(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureLoad_c378ee(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c378ee(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureLoad_c378ee(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c378ee(); - return; -} - - -tint_8pq22X.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c40dcb.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c40dcb.wgsl.expected.msl index b100805356..b22ae4ac2f 100644 --- a/test/intrinsics/gen/textureLoad/c40dcb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c40dcb.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c40dcb() { - uint4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c40dcb(texture2d_array tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_c40dcb(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_c40dcb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_c40dcb(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c40dcb(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_c40dcb(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c40dcb(); - return; -} - - -tint_AHh86e.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c456bc.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c456bc.wgsl.expected.msl index bd9098af12..f32246211f 100644 --- a/test/intrinsics/gen/textureLoad/c456bc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c456bc.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c456bc() { - float4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c456bc(texture3d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_c456bc(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_c456bc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_c456bc(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c456bc(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_c456bc(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c456bc(); - return; -} - - -tint_lhWQnt.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c7cbed.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c7cbed.wgsl.expected.msl index 1ad0d4f61b..f49567927c 100644 --- a/test/intrinsics/gen/textureLoad/c7cbed.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c7cbed.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c7cbed() { - float4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c7cbed(texture1d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_c7cbed(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_c7cbed(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_c7cbed(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c7cbed(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_c7cbed(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c7cbed(); - return; -} - - -tint_Tj6Pxg.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/c9cc40.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/c9cc40.wgsl.expected.msl index 75907b0f49..a8fbf70240 100644 --- a/test/intrinsics/gen/textureLoad/c9cc40.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/c9cc40.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_c9cc40() { - int4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_c9cc40(texture1d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_c9cc40(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_c9cc40(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_c9cc40(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_c9cc40(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_c9cc40(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_c9cc40(); - return; -} - - -tint_BXWR82.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/d5c48d.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/d5c48d.wgsl.expected.msl index 3af5b1a1fb..c07be8b5af 100644 --- a/test/intrinsics/gen/textureLoad/d5c48d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/d5c48d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_d5c48d() { - float4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_d5c48d(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_d5c48d(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_d5c48d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_d5c48d(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_d5c48d(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_d5c48d(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_d5c48d(); - return; -} - - -tint_caH8d9.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/d81c57.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/d81c57.wgsl.expected.msl index 3270b75945..7cf6656661 100644 --- a/test/intrinsics/gen/textureLoad/d81c57.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/d81c57.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_d81c57() { - float4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_d81c57(texture1d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_d81c57(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_d81c57(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_d81c57(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_d81c57(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_d81c57(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_d81c57(); - return; -} - - -tint_PBHoWY.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/d8617f.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/d8617f.wgsl.expected.msl index 83ef6bebb1..d51ff3db8c 100644 --- a/test/intrinsics/gen/textureLoad/d8617f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/d8617f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_d8617f() { - int4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_d8617f(texture2d_array tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_d8617f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_d8617f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_d8617f(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_d8617f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_d8617f(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_d8617f(); - return; -} - - -tint_kOdpG9.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/dbd554.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/dbd554.wgsl.expected.msl index 4db5a4a8b2..e81135b772 100644 --- a/test/intrinsics/gen/textureLoad/dbd554.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/dbd554.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_dbd554() { - int4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_dbd554(texture2d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_dbd554(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_dbd554(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_dbd554(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_dbd554(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_dbd554(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_dbd554(); - return; -} - - -tint_u9YBmc.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/ddeed3.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/ddeed3.wgsl.expected.msl index 6a9a8d246a..f63522c574 100644 --- a/test/intrinsics/gen/textureLoad/ddeed3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/ddeed3.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_ddeed3() { - int4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_ddeed3(texture1d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_ddeed3(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_ddeed3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_ddeed3(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_ddeed3(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_ddeed3(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_ddeed3(); - return; -} - - -tint_WoGoyA.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/dee8e7.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/dee8e7.wgsl.expected.msl index 247ee7875e..452cbe661b 100644 --- a/test/intrinsics/gen/textureLoad/dee8e7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/dee8e7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_dee8e7() { - int4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_dee8e7(texture2d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_dee8e7(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_dee8e7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_dee8e7(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_dee8e7(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_dee8e7(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_dee8e7(); - return; -} - - -tint_dUo0qj.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.msl index dbe28f353b..6a8bdb707e 100644 --- a/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_e3d2cc() { - int4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_e3d2cc(texture2d_ms tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_e3d2cc(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureLoad_e3d2cc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureLoad_e3d2cc(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_e3d2cc(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureLoad_e3d2cc(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_e3d2cc(); - return; -} - - -tint_lPhrIU.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/e65916.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/e65916.wgsl.expected.msl index 2bf7b4e10e..6ab4e8517f 100644 --- a/test/intrinsics/gen/textureLoad/e65916.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/e65916.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_e65916() { - int4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_e65916(texture3d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_e65916(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_e65916(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_e65916(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_e65916(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_e65916(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_e65916(); - return; -} - - -tint_JtCsT6.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/e893d7.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/e893d7.wgsl.expected.msl index 39460ff615..f7820deb90 100644 --- a/test/intrinsics/gen/textureLoad/e893d7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/e893d7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_e893d7() { - float4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_e893d7(texture2d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_e893d7(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_e893d7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_e893d7(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_e893d7(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_e893d7(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_e893d7(); - return; -} - - -tint_hiyLRu.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/eb573b.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/eb573b.wgsl.expected.msl index 3c7011ff82..086b75fffb 100644 --- a/test/intrinsics/gen/textureLoad/eb573b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/eb573b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_eb573b() { - int4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_eb573b(texture2d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_eb573b(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_eb573b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_eb573b(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_eb573b(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_eb573b(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_eb573b(); - return; -} - - -tint_1uDHrX.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/ecc823.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/ecc823.wgsl.expected.msl index 22cf47c10b..d9f8ec2a09 100644 --- a/test/intrinsics/gen/textureLoad/ecc823.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/ecc823.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_ecc823() { - uint4 res = arg_0.read(int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_ecc823(texture2d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2())); } -vertex void vertex_main() { - textureLoad_ecc823(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureLoad_ecc823(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureLoad_ecc823(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_ecc823(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureLoad_ecc823(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_ecc823(); - return; -} - - -tint_uJWcQ6.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/ef5405.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/ef5405.wgsl.expected.msl index cc99a0b224..c86b749b78 100644 --- a/test/intrinsics/gen/textureLoad/ef5405.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/ef5405.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_ef5405() { - uint4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_ef5405(texture3d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_ef5405(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_ef5405(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_ef5405(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_ef5405(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_ef5405(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_ef5405(); - return; -} - - -tint_vn4Gjj.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/f06b69.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/f06b69.wgsl.expected.msl index 0546f3ecf9..5dc465351b 100644 --- a/test/intrinsics/gen/textureLoad/f06b69.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/f06b69.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_f06b69() { - int4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_f06b69(texture1d tint_symbol_2) { + int4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_f06b69(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_f06b69(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_f06b69(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_f06b69(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_f06b69(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_f06b69(); - return; -} - - -tint_hzLYnu.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/f379e2.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/f379e2.wgsl.expected.msl index d99131f76b..f8fb4de2b2 100644 --- a/test/intrinsics/gen/textureLoad/f379e2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/f379e2.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_f379e2() { - float4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_f379e2(texture2d_array tint_symbol_2) { + float4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_f379e2(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_f379e2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_f379e2(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_f379e2(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_f379e2(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_f379e2(); - return; -} - - -tint_noH5on.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/f56e6f.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/f56e6f.wgsl.expected.msl index 56cb753bb3..d944b0486f 100644 --- a/test/intrinsics/gen/textureLoad/f56e6f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/f56e6f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_f56e6f() { - uint4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_f56e6f(texture3d tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_f56e6f(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_f56e6f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_f56e6f(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_f56e6f(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_f56e6f(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_f56e6f(); - return; -} - - -tint_bZeB2M.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/f74bd8.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/f74bd8.wgsl.expected.msl index 5de8a78632..41ef241eda 100644 --- a/test/intrinsics/gen/textureLoad/f74bd8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/f74bd8.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_f74bd8() { - float4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_f74bd8(texture3d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_f74bd8(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_f74bd8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_f74bd8(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_f74bd8(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_f74bd8(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_f74bd8(); - return; -} - - -tint_bvWoiL.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/fc6d36.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/fc6d36.wgsl.expected.msl index c7261b4b76..d440e706ca 100644 --- a/test/intrinsics/gen/textureLoad/fc6d36.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/fc6d36.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_fc6d36() { - int4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_fc6d36(texture2d_array tint_symbol_2) { + int4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_fc6d36(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_fc6d36(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_fc6d36(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_fc6d36(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_fc6d36(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_fc6d36(); - return; -} - - -tint_8IAy2k.metal:5:14: error: use of undeclared identifier 'arg_0' - int4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/fdebd0.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/fdebd0.wgsl.expected.msl index 29c550337e..5706eae24b 100644 --- a/test/intrinsics/gen/textureLoad/fdebd0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/fdebd0.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_fdebd0() { - uint4 res = arg_0.read(int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_fdebd0(texture2d_array tint_symbol_2) { + uint4 res = tint_symbol_2.read(uint2(int2()), 1); } -vertex void vertex_main() { - textureLoad_fdebd0(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureLoad_fdebd0(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureLoad_fdebd0(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_fdebd0(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureLoad_fdebd0(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_fdebd0(); - return; -} - - -tint_NgCD5o.metal:5:15: error: use of undeclared identifier 'arg_0' - uint4 res = arg_0.read(int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/fe222a.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/fe222a.wgsl.expected.msl index c8c0402490..b613e48cbe 100644 --- a/test/intrinsics/gen/textureLoad/fe222a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/fe222a.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_fe222a() { - float4 res = arg_0.read(1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_fe222a(texture1d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint(1)); } -vertex void vertex_main() { - textureLoad_fe222a(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureLoad_fe222a(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureLoad_fe222a(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_fe222a(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureLoad_fe222a(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_fe222a(); - return; -} - - -tint_cXPONM.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureLoad/feab99.wgsl.expected.msl b/test/intrinsics/gen/textureLoad/feab99.wgsl.expected.msl index b456fefea8..ddf99c9797 100644 --- a/test/intrinsics/gen/textureLoad/feab99.wgsl.expected.msl +++ b/test/intrinsics/gen/textureLoad/feab99.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureLoad_feab99() { - float4 res = arg_0.read(int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureLoad_feab99(texture3d tint_symbol_2) { + float4 res = tint_symbol_2.read(uint3(int3())); } -vertex void vertex_main() { - textureLoad_feab99(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureLoad_feab99(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureLoad_feab99(tint_symbol_4); return; } -fragment void fragment_main() { - textureLoad_feab99(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureLoad_feab99(tint_symbol_5); return; } -kernel void compute_main() { - textureLoad_feab99(); - return; -} - - -tint_7aCudT.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.read(int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.msl index 0b6d8ec5e6..b08d98a230 100644 --- a/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_024820() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_024820(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_024820(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_024820(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_024820(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_024820(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_024820(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_024820(); - return; -} - - -tint_0jVx27.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.msl index dccaf5947e..09eef92101 100644 --- a/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_053df7() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_053df7(texturecube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_053df7(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_053df7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_053df7(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_053df7(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_053df7(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_053df7(); - return; -} - - -tint_eUidBR.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.msl index 0c8213e7ca..7c2e7e3a1b 100644 --- a/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_058cc3() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_058cc3(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_058cc3(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_058cc3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_058cc3(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_058cc3(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_058cc3(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_058cc3(); - return; -} - - -tint_2AGSfO.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.msl index ece1e7d48c..28157ad8aa 100644 --- a/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_09d05d() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_09d05d(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_09d05d(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_09d05d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_09d05d(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_09d05d(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_09d05d(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_09d05d(); - return; -} - - -tint_PQwrWX.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.msl index 068f3950f8..d48a68a395 100644 --- a/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_13b4ce() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_13b4ce(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_13b4ce(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_13b4ce(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_13b4ce(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_13b4ce(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_13b4ce(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_13b4ce(); - return; -} - - -tint_LccGuI.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.msl index c00e965f6f..7fc1828c86 100644 --- a/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_22e53b() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_22e53b(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_22e53b(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_22e53b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_22e53b(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_22e53b(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_22e53b(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_22e53b(); - return; -} - - -tint_HhSnq0.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/2f6bb3.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/2f6bb3.wgsl.expected.msl index 46f833c267..39a1ce0378 100644 --- a/test/intrinsics/gen/textureNumLayers/2f6bb3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/2f6bb3.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_2f6bb3() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_2f6bb3(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_2f6bb3(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_2f6bb3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_2f6bb3(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_2f6bb3(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_2f6bb3(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_2f6bb3(); - return; -} - - -tint_h3OOas.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/315298.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/315298.wgsl.expected.msl index 7e83a77882..ce79ed8c95 100644 --- a/test/intrinsics/gen/textureNumLayers/315298.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/315298.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_315298() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_315298(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_315298(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_315298(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_315298(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_315298(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_315298(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_315298(); - return; -} - - -tint_GjCxCH.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/3615e3.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/3615e3.wgsl.expected.msl index 6946205873..fa075f77ab 100644 --- a/test/intrinsics/gen/textureNumLayers/3615e3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/3615e3.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_3615e3() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_3615e3(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_3615e3(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_3615e3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_3615e3(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_3615e3(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_3615e3(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_3615e3(); - return; -} - - -tint_57kzTT.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/390fd5.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/390fd5.wgsl.expected.msl index 953ec8a5d9..69cb563cad 100644 --- a/test/intrinsics/gen/textureNumLayers/390fd5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/390fd5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_390fd5() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_390fd5(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_390fd5(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_390fd5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_390fd5(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_390fd5(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_390fd5(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_390fd5(); - return; -} - - -tint_CaQl5W.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/45155d.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/45155d.wgsl.expected.msl index 506e75ab28..346ca65576 100644 --- a/test/intrinsics/gen/textureNumLayers/45155d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/45155d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_45155d() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_45155d(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_45155d(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_45155d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_45155d(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_45155d(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_45155d(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_45155d(); - return; -} - - -tint_sM3glL.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/4bf67b.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/4bf67b.wgsl.expected.msl index c89408c019..9ec0df1979 100644 --- a/test/intrinsics/gen/textureNumLayers/4bf67b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/4bf67b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_4bf67b() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_4bf67b(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_4bf67b(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_4bf67b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_4bf67b(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_4bf67b(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_4bf67b(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_4bf67b(); - return; -} - - -tint_SwyI4f.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.msl index a0cbaf4192..0bcbb68e82 100644 --- a/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_562013() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_562013(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_562013(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_562013(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_562013(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_562013(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_562013(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_562013(); - return; -} - - -tint_Dlhv3z.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/57092f.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/57092f.wgsl.expected.msl index ca0aac986f..1f4863ccab 100644 --- a/test/intrinsics/gen/textureNumLayers/57092f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/57092f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_57092f() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_57092f(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_57092f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_57092f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_57092f(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_57092f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_57092f(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_57092f(); - return; -} - - -tint_OuseLM.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.msl index 35249ebb00..081ef51d0a 100644 --- a/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_5d59cd() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_5d59cd(texturecube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_5d59cd(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_5d59cd(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_5d59cd(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_5d59cd(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_5d59cd(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_5d59cd(); - return; -} - - -tint_ip3QKE.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.msl index 94c1ccfc6b..59335e9978 100644 --- a/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_68a65b() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_68a65b(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_68a65b(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_68a65b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_68a65b(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_68a65b(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_68a65b(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_68a65b(); - return; -} - - -tint_N63zBK.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.msl index 904ccd936c..0253d3e8f9 100644 --- a/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_778bd1() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_778bd1(depthcube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_778bd1(); +vertex tint_symbol vertex_main(depthcube_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_778bd1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_778bd1(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_778bd1(); +kernel void compute_main(depthcube_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_778bd1(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_778bd1(); - return; -} - - -tint_jiLWFd.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.msl index 243a8d0e09..222cf7d18b 100644 --- a/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_7f1937() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_7f1937(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_7f1937(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_7f1937(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_7f1937(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_7f1937(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_7f1937(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_7f1937(); - return; -} - - -tint_KD1toJ.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.msl index 7eea88ed58..3c7904b2d1 100644 --- a/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_85f980() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_85f980(texturecube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_85f980(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_85f980(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_85f980(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_85f980(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_85f980(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_85f980(); - return; -} - - -tint_kFnY8n.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.msl index 090725f837..4fb2af2e8b 100644 --- a/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_87953e() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_87953e(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_87953e(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_87953e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_87953e(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_87953e(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_87953e(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_87953e(); - return; -} - - -tint_m8n8xs.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.msl index c0fa33fe1c..fbab05ec6c 100644 --- a/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_893e7c() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_893e7c(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_893e7c(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_893e7c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_893e7c(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_893e7c(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_893e7c(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_893e7c(); - return; -} - - -tint_Klqhaj.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/938763.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/938763.wgsl.expected.msl index f38a402575..e33db79a4d 100644 --- a/test/intrinsics/gen/textureNumLayers/938763.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/938763.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_938763() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_938763(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_938763(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_938763(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_938763(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_938763(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_938763(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_938763(); - return; -} - - -tint_5XNX1P.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.msl index b72ddf42c1..f71315f348 100644 --- a/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_9700fb() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_9700fb(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_9700fb(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_9700fb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_9700fb(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_9700fb(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_9700fb(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_9700fb(); - return; -} - - -tint_AtgPjG.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.msl index 5439ad7a8c..744b00eba3 100644 --- a/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_a216d2() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_a216d2(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_a216d2(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_a216d2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_a216d2(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_a216d2(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_a216d2(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_a216d2(); - return; -} - - -tint_KEuSt7.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/aa08a7.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/aa08a7.wgsl.expected.msl index 3f76dec7bd..742c5336cf 100644 --- a/test/intrinsics/gen/textureNumLayers/aa08a7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/aa08a7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_aa08a7() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_aa08a7(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_aa08a7(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_aa08a7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_aa08a7(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_aa08a7(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_aa08a7(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_aa08a7(); - return; -} - - -tint_cmcbXy.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/ab0c9b.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/ab0c9b.wgsl.expected.msl index 21af60a0eb..14192729c6 100644 --- a/test/intrinsics/gen/textureNumLayers/ab0c9b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/ab0c9b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_ab0c9b() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_ab0c9b(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_ab0c9b(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_ab0c9b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_ab0c9b(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_ab0c9b(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_ab0c9b(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_ab0c9b(); - return; -} - - -tint_3mx4mu.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/b8cd76.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/b8cd76.wgsl.expected.msl index 8855b9407b..80b3c55c47 100644 --- a/test/intrinsics/gen/textureNumLayers/b8cd76.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/b8cd76.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_b8cd76() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_b8cd76(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_b8cd76(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_b8cd76(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_b8cd76(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_b8cd76(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_b8cd76(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_b8cd76(); - return; -} - - -tint_KU2V1S.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/be1d70.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/be1d70.wgsl.expected.msl index 7e0c20ccb8..e6be933be3 100644 --- a/test/intrinsics/gen/textureNumLayers/be1d70.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/be1d70.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_be1d70() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_be1d70(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_be1d70(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_be1d70(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_be1d70(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_be1d70(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_be1d70(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_be1d70(); - return; -} - - -tint_0Ia5Gx.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/be3acb.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/be3acb.wgsl.expected.msl index a6b169749c..74cae632ba 100644 --- a/test/intrinsics/gen/textureNumLayers/be3acb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/be3acb.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_be3acb() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_be3acb(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_be3acb(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_be3acb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_be3acb(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_be3acb(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_be3acb(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_be3acb(); - return; -} - - -tint_KFyqRK.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/c09917.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/c09917.wgsl.expected.msl index 49a302980a..33c9b86670 100644 --- a/test/intrinsics/gen/textureNumLayers/c09917.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/c09917.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_c09917() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_c09917(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_c09917(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_c09917(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_c09917(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_c09917(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_c09917(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_c09917(); - return; -} - - -tint_TtrZWH.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/c7c7f2.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/c7c7f2.wgsl.expected.msl index 775889c07b..e417cdf643 100644 --- a/test/intrinsics/gen/textureNumLayers/c7c7f2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/c7c7f2.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_c7c7f2() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_c7c7f2(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_c7c7f2(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_c7c7f2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_c7c7f2(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_c7c7f2(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_c7c7f2(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_c7c7f2(); - return; -} - - -tint_92LuOw.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.msl index be37d58da6..8c49d95bfc 100644 --- a/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_cd5dc8() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_cd5dc8(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_cd5dc8(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_cd5dc8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_cd5dc8(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_cd5dc8(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_cd5dc8(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_cd5dc8(); - return; -} - - -tint_7rjv9D.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.msl index fda4dfe0db..8519317622 100644 --- a/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_d5b228() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_d5b228(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_d5b228(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_d5b228(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_d5b228(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_d5b228(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_d5b228(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_d5b228(); - return; -} - - -tint_yPz3Jj.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/e15642.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/e15642.wgsl.expected.msl index dcf2190292..279401f2b7 100644 --- a/test/intrinsics/gen/textureNumLayers/e15642.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/e15642.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_e15642() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_e15642(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_e15642(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_e15642(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_e15642(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_e15642(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_e15642(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_e15642(); - return; -} - - -tint_0CbU62.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.msl index 815c6e0b96..74c73d202c 100644 --- a/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_e31be1() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_e31be1(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_e31be1(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_e31be1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_e31be1(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_e31be1(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_e31be1(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_e31be1(); - return; -} - - -tint_VHnpXj.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.msl index 69f7d4522c..6625911c80 100644 --- a/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_e653c0() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_e653c0(depth2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_e653c0(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_e653c0(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_e653c0(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_e653c0(); +kernel void compute_main(depth2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_e653c0(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_e653c0(); - return; -} - - -tint_ruSiH5.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.msl index 233095c731..caa697864a 100644 --- a/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_ee942f() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_ee942f(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_ee942f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_ee942f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_ee942f(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_ee942f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_ee942f(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_ee942f(); - return; -} - - -tint_RSJrMi.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.msl index 48bdc8d1c0..0aef0029e6 100644 --- a/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_f33005() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_f33005(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_f33005(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_f33005(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_f33005(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_f33005(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_f33005(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_f33005(); - return; -} - - -tint_cU7qBN.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.msl index de3f0e70fd..b19a43b3c4 100644 --- a/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_fcec98() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_fcec98(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_fcec98(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_fcec98(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_fcec98(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_fcec98(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_fcec98(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_fcec98(); - return; -} - - -tint_7cRIpj.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.msl b/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.msl index 339f408100..071635eb93 100644 --- a/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLayers_ff5e89() { - int res = int(arg_0.get_array_size()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLayers_ff5e89(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_array_size()); } -vertex void vertex_main() { - textureNumLayers_ff5e89(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLayers_ff5e89(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLayers_ff5e89(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLayers_ff5e89(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLayers_ff5e89(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLayers_ff5e89(); - return; -} - - -tint_0FvQko.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_array_size()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.msl index 32775720db..d43f837b3c 100644 --- a/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_076cb5() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_076cb5(depthcube tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_076cb5(); +vertex tint_symbol vertex_main(depthcube tint_symbol_3 [[texture(0)]]) { + textureNumLevels_076cb5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube tint_symbol_4 [[texture(0)]]) { + textureNumLevels_076cb5(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_076cb5(); +kernel void compute_main(depthcube tint_symbol_5 [[texture(0)]]) { + textureNumLevels_076cb5(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_076cb5(); - return; -} - - -tint_aMtcrd.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.msl index ac224810a4..1212cf0891 100644 --- a/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_080d95() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_080d95(texturecube tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_080d95(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureNumLevels_080d95(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureNumLevels_080d95(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_080d95(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureNumLevels_080d95(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_080d95(); - return; -} - - -tint_zRq2iR.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.msl index 5411434b04..ab8fc7b684 100644 --- a/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_09ddd0() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_09ddd0(texture2d tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_09ddd0(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureNumLevels_09ddd0(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureNumLevels_09ddd0(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_09ddd0(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureNumLevels_09ddd0(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_09ddd0(); - return; -} - - -tint_VbPpyN.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.msl index d42d667a2b..9fba11ebac 100644 --- a/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_105988() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_105988(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_105988(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_105988(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_105988(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_105988(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_105988(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_105988(); - return; -} - - -tint_Orn2HY.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.msl index de7be4f8f4..69bf6aabda 100644 --- a/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_23f750() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_23f750(texture2d tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_23f750(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureNumLevels_23f750(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureNumLevels_23f750(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_23f750(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureNumLevels_23f750(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_23f750(); - return; -} - - -tint_ne3mQQ.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.msl index 11114313cc..0326a45cdf 100644 --- a/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_2c3575() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_2c3575(depthcube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_2c3575(); +vertex tint_symbol vertex_main(depthcube_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_2c3575(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_2c3575(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_2c3575(); +kernel void compute_main(depthcube_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_2c3575(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_2c3575(); - return; -} - - -tint_m6GLDO.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.msl index a457256ce9..d04511acff 100644 --- a/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_5101cf() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_5101cf(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_5101cf(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_5101cf(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_5101cf(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_5101cf(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_5101cf(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_5101cf(); - return; -} - - -tint_m3uHe8.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.msl index e6aea7e655..0d4b582f9d 100644 --- a/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_897aaf() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_897aaf(texturecube tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_897aaf(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureNumLevels_897aaf(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureNumLevels_897aaf(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_897aaf(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureNumLevels_897aaf(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_897aaf(); - return; -} - - -tint_qjfSAf.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.msl index 401531a1db..d3ff2dfcf9 100644 --- a/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_9da7a5() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_9da7a5(texture3d tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_9da7a5(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureNumLevels_9da7a5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureNumLevels_9da7a5(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_9da7a5(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureNumLevels_9da7a5(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_9da7a5(); - return; -} - - -tint_wbp3EV.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.msl index 8bc44fe226..2a9047dcb3 100644 --- a/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_a91c03() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_a91c03(texturecube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_a91c03(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_a91c03(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_a91c03(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_a91c03(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_a91c03(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_a91c03(); - return; -} - - -tint_hG4QFz.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.msl index c6d9be9eab..e8235f7ff6 100644 --- a/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_aee7c8() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_aee7c8(texturecube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_aee7c8(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_aee7c8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_aee7c8(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_aee7c8(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_aee7c8(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_aee7c8(); - return; -} - - -tint_uSNIsH.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.msl index dc3115832f..bd18c15c4e 100644 --- a/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_b1b12b() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_b1b12b(depth2d tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_b1b12b(); +vertex tint_symbol vertex_main(depth2d tint_symbol_3 [[texture(0)]]) { + textureNumLevels_b1b12b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d tint_symbol_4 [[texture(0)]]) { + textureNumLevels_b1b12b(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_b1b12b(); +kernel void compute_main(depth2d tint_symbol_5 [[texture(0)]]) { + textureNumLevels_b1b12b(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_b1b12b(); - return; -} - - -tint_fK8sGe.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.msl index e3b7eab9a9..2251f59122 100644 --- a/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_b4f5ea() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_b4f5ea(texture3d tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_b4f5ea(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureNumLevels_b4f5ea(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureNumLevels_b4f5ea(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_b4f5ea(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureNumLevels_b4f5ea(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_b4f5ea(); - return; -} - - -tint_kN6LIC.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.msl index 36d75bb6e8..b1ec41db68 100644 --- a/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_d004a9() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_d004a9(texture2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_d004a9(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_d004a9(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_d004a9(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_d004a9(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_d004a9(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_d004a9(); - return; -} - - -tint_J6mNNT.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.msl index 22eaf18eec..8fa8f419f1 100644 --- a/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_dca09e() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_dca09e(texture3d tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_dca09e(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureNumLevels_dca09e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureNumLevels_dca09e(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_dca09e(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureNumLevels_dca09e(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_dca09e(); - return; -} - - -tint_xvDrXY.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.msl index 5d2179418e..d2dffa16b1 100644 --- a/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_e67231() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_e67231(texture2d tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_e67231(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureNumLevels_e67231(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureNumLevels_e67231(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_e67231(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureNumLevels_e67231(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_e67231(); - return; -} - - -tint_qOzNfD.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.msl index 95cc51a191..e3caac8faf 100644 --- a/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_ed078b() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_ed078b(texturecube tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_ed078b(); +vertex tint_symbol vertex_main(texturecube tint_symbol_3 [[texture(0)]]) { + textureNumLevels_ed078b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_4 [[texture(0)]]) { + textureNumLevels_ed078b(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_ed078b(); +kernel void compute_main(texturecube tint_symbol_5 [[texture(0)]]) { + textureNumLevels_ed078b(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_ed078b(); - return; -} - - -tint_mMDibi.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.msl index 2d67f01176..ef13bc61b1 100644 --- a/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_f46ec6() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_f46ec6(texturecube_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_f46ec6(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_f46ec6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_f46ec6(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_f46ec6(); +kernel void compute_main(texturecube_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_f46ec6(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_f46ec6(); - return; -} - - -tint_PqHlsD.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.msl b/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.msl index 49aebc89a3..91b3f31d3c 100644 --- a/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumLevels_f5828d() { - int res = int(arg_0.get_num_mip_levels()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumLevels_f5828d(depth2d_array tint_symbol_2) { + int res = int(tint_symbol_2.get_num_mip_levels()); } -vertex void vertex_main() { - textureNumLevels_f5828d(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_3 [[texture(0)]]) { + textureNumLevels_f5828d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d_array tint_symbol_4 [[texture(0)]]) { + textureNumLevels_f5828d(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumLevels_f5828d(); +kernel void compute_main(depth2d_array tint_symbol_5 [[texture(0)]]) { + textureNumLevels_f5828d(tint_symbol_5); return; } -kernel void compute_main() { - textureNumLevels_f5828d(); - return; -} - - -tint_loTxTw.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_mip_levels()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.msl b/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.msl index fddb2a82f2..c3b22ea7a8 100644 --- a/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumSamples_2c6f14() { - int res = int(arg_0.get_num_samples()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumSamples_2c6f14(texture2d_ms tint_symbol_2) { + int res = int(tint_symbol_2.get_num_samples()); } -vertex void vertex_main() { - textureNumSamples_2c6f14(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureNumSamples_2c6f14(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureNumSamples_2c6f14(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumSamples_2c6f14(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureNumSamples_2c6f14(tint_symbol_5); return; } -kernel void compute_main() { - textureNumSamples_2c6f14(); - return; -} - - -tint_TdWxzV.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_samples()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.msl b/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.msl index 616833cd9f..aa8bbd9216 100644 --- a/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumSamples_42f8bb() { - int res = int(arg_0.get_num_samples()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumSamples_42f8bb(texture2d_ms tint_symbol_2) { + int res = int(tint_symbol_2.get_num_samples()); } -vertex void vertex_main() { - textureNumSamples_42f8bb(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureNumSamples_42f8bb(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureNumSamples_42f8bb(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumSamples_42f8bb(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureNumSamples_42f8bb(tint_symbol_5); return; } -kernel void compute_main() { - textureNumSamples_42f8bb(); - return; -} - - -tint_Z8ljof.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_samples()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.msl b/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.msl index 7f2566cd19..2b38a2be89 100644 --- a/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.msl +++ b/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureNumSamples_449d23() { - int res = int(arg_0.get_num_samples()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureNumSamples_449d23(texture2d_ms tint_symbol_2) { + int res = int(tint_symbol_2.get_num_samples()); } -vertex void vertex_main() { - textureNumSamples_449d23(); +vertex tint_symbol vertex_main(texture2d_ms tint_symbol_3 [[texture(0)]]) { + textureNumSamples_449d23(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_ms tint_symbol_4 [[texture(0)]]) { + textureNumSamples_449d23(tint_symbol_4); return; } -fragment void fragment_main() { - textureNumSamples_449d23(); +kernel void compute_main(texture2d_ms tint_symbol_5 [[texture(0)]]) { + textureNumSamples_449d23(tint_symbol_5); return; } -kernel void compute_main() { - textureNumSamples_449d23(); - return; -} - - -tint_gYoBhK.metal:5:17: error: use of undeclared identifier 'arg_0' - int res = int(arg_0.get_num_samples()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.msl b/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.msl index 22a92aba45..441370a4c2 100644 --- a/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_02aa9b() { - float4 res = arg_0.sample(arg_1, float2(), 1, int2()); +void textureSample_02aa9b(texture2d_array tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2(), 1, int2()); } -fragment void fragment_main() { - textureSample_02aa9b(); +fragment void fragment_main(texture2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_02aa9b(tint_symbol_2, tint_symbol_3); return; } - -tint_3llOQ2.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1, int2()); - ^ -tint_3llOQ2.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1, int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.msl b/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.msl index 8bc14f40c8..05ed18b8f8 100644 --- a/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_100dc0() { - float4 res = arg_0.sample(arg_1, float3(), int3()); +void textureSample_100dc0(texture3d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3(), int3()); } -fragment void fragment_main() { - textureSample_100dc0(); +fragment void fragment_main(texture3d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_100dc0(tint_symbol_2, tint_symbol_3); return; } - -tint_Fkbrex.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), int3()); - ^ -tint_Fkbrex.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), int3()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.msl b/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.msl index 38eea196e7..8ad544cf43 100644 --- a/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_38bbb9() { - float res = arg_0.sample(arg_1, float2()); +void textureSample_38bbb9(depth2d tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample(tint_symbol_1, float2()); } -fragment void fragment_main() { - textureSample_38bbb9(); +fragment void fragment_main(depth2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_38bbb9(tint_symbol_2, tint_symbol_3); return; } - -tint_fTMbcr.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2()); - ^ -tint_fTMbcr.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.msl b/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.msl index 1f171fe68c..d57dfcf70b 100644 --- a/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_3b50bd() { - float4 res = arg_0.sample(arg_1, float3()); +void textureSample_3b50bd(texture3d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3()); } -fragment void fragment_main() { - textureSample_3b50bd(); +fragment void fragment_main(texture3d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_3b50bd(tint_symbol_2, tint_symbol_3); return; } - -tint_rGB6Up.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3()); - ^ -tint_rGB6Up.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.msl b/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.msl index 5a3b8c8864..998b9a174e 100644 --- a/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_4dd1bf() { - float4 res = arg_0.sample(arg_1, float3(), 1); +void textureSample_4dd1bf(texturecube_array tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3(), 1); } -fragment void fragment_main() { - textureSample_4dd1bf(); +fragment void fragment_main(texturecube_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_4dd1bf(tint_symbol_2, tint_symbol_3); return; } - -tint_ULElO7.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), 1); - ^ -tint_ULElO7.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), 1); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/51b514.wgsl.expected.msl b/test/intrinsics/gen/textureSample/51b514.wgsl.expected.msl index aa11503fd4..14061e51d7 100644 --- a/test/intrinsics/gen/textureSample/51b514.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/51b514.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_51b514() { - float4 res = arg_0.sample(arg_1, float2()); +void textureSample_51b514(texture2d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2()); } -fragment void fragment_main() { - textureSample_51b514(); +fragment void fragment_main(texture2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_51b514(tint_symbol_2, tint_symbol_3); return; } - -tint_DjFmC0.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2()); - ^ -tint_DjFmC0.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/667d76.wgsl.expected.msl b/test/intrinsics/gen/textureSample/667d76.wgsl.expected.msl index f49d51cb4a..7867b2087f 100644 --- a/test/intrinsics/gen/textureSample/667d76.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/667d76.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_667d76() { - float res = arg_0.sample(arg_1, float2(), int2()); +void textureSample_667d76(depth2d tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample(tint_symbol_1, float2(), int2()); } -fragment void fragment_main() { - textureSample_667d76(); +fragment void fragment_main(depth2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_667d76(tint_symbol_2, tint_symbol_3); return; } - -tint_Mx8eug.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2(), int2()); - ^ -tint_Mx8eug.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2(), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.msl b/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.msl index 6467e69161..680880fe1e 100644 --- a/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_6717ca() { - float4 res = arg_0.sample(arg_1, float2(), 1); +void textureSample_6717ca(texture2d_array tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2(), 1); } -fragment void fragment_main() { - textureSample_6717ca(); +fragment void fragment_main(texture2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_6717ca(tint_symbol_2, tint_symbol_3); return; } - -tint_u9HsAP.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1); - ^ -tint_u9HsAP.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.msl b/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.msl index c09549831a..b267adbd43 100644 --- a/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_6e64fb() { - float4 res = arg_0.sample(arg_1, 1.0f); +void textureSample_6e64fb(texture1d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, 1.0f); } -fragment void fragment_main() { - textureSample_6e64fb(); +fragment void fragment_main(texture1d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_6e64fb(tint_symbol_2, tint_symbol_3); return; } - -tint_Gw7uQt.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, 1.0f); - ^ -tint_Gw7uQt.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, 1.0f); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.msl b/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.msl index 232efb448d..9b6647827f 100644 --- a/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_7c3baa() { - float4 res = arg_0.sample(arg_1, float2(), int2()); +void textureSample_7c3baa(texture2d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2(), int2()); } -fragment void fragment_main() { - textureSample_7c3baa(); +fragment void fragment_main(texture2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_7c3baa(tint_symbol_2, tint_symbol_3); return; } - -tint_6J7fSq.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), int2()); - ^ -tint_6J7fSq.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.msl b/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.msl index d91c03d3a6..51555bcfab 100644 --- a/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_7e9ffd() { - float res = arg_0.sample(arg_1, float2(), 1); +void textureSample_7e9ffd(depth2d_array tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample(tint_symbol_1, float2(), 1); } -fragment void fragment_main() { - textureSample_7e9ffd(); +fragment void fragment_main(depth2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_7e9ffd(tint_symbol_2, tint_symbol_3); return; } - -tint_RtNcbu.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2(), 1); - ^ -tint_RtNcbu.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2(), 1); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.msl b/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.msl index 6b7d61a078..2673827a87 100644 --- a/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_8522e7() { - float res = arg_0.sample(arg_1, float2(), 1, int2()); +void textureSample_8522e7(depth2d_array tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample(tint_symbol_1, float2(), 1, int2()); } -fragment void fragment_main() { - textureSample_8522e7(); +fragment void fragment_main(depth2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_8522e7(tint_symbol_2, tint_symbol_3); return; } - -tint_Dm6FKk.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2(), 1, int2()); - ^ -tint_Dm6FKk.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2(), 1, int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/bb81ce.wgsl.expected.msl b/test/intrinsics/gen/textureSample/bb81ce.wgsl.expected.msl index e102e8cad3..b08766f852 100644 --- a/test/intrinsics/gen/textureSample/bb81ce.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/bb81ce.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_bb81ce() { - float4 res = arg_0.sample(arg_1, float2()); +void textureSample_bb81ce(texture2d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2()); } -fragment void fragment_main() { - textureSample_bb81ce(); +fragment void fragment_main(texture2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_bb81ce(tint_symbol_2, tint_symbol_3); return; } - -tint_fZQEeQ.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2()); - ^ -tint_fZQEeQ.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.msl b/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.msl index 5d00e0aef7..b6269f6fa6 100644 --- a/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_c2f4e8() { - float res = arg_0.sample(arg_1, float3(), 1); +void textureSample_c2f4e8(depthcube_array tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample(tint_symbol_1, float3(), 1); } -fragment void fragment_main() { - textureSample_c2f4e8(); +fragment void fragment_main(depthcube_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_c2f4e8(tint_symbol_2, tint_symbol_3); return; } - -tint_yWQ2qq.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float3(), 1); - ^ -tint_yWQ2qq.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float3(), 1); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/e53267.wgsl.expected.msl b/test/intrinsics/gen/textureSample/e53267.wgsl.expected.msl index a27e241eda..d2726ea648 100644 --- a/test/intrinsics/gen/textureSample/e53267.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/e53267.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_e53267() { - float4 res = arg_0.sample(arg_1, float3()); +void textureSample_e53267(texturecube tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3()); } -fragment void fragment_main() { - textureSample_e53267(); +fragment void fragment_main(texturecube tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_e53267(tint_symbol_2, tint_symbol_3); return; } - -tint_HSAV5Q.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3()); - ^ -tint_HSAV5Q.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.msl b/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.msl index 1a09ff00e8..84cbeacca2 100644 --- a/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSample_ea7030() { - float res = arg_0.sample(arg_1, float3()); +void textureSample_ea7030(depthcube tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample(tint_symbol_1, float3()); } -fragment void fragment_main() { - textureSample_ea7030(); +fragment void fragment_main(depthcube tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSample_ea7030(tint_symbol_2, tint_symbol_3); return; } - -tint_hX4U1g.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float3()); - ^ -tint_hX4U1g.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float3()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.msl index 3ceac72050..fed3c2ae8e 100644 --- a/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_53b9f7() { - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f)); +void textureSampleBias_53b9f7(texturecube tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3(), bias(1.0f)); } -fragment void fragment_main() { - textureSampleBias_53b9f7(); +fragment void fragment_main(texturecube tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_53b9f7(tint_symbol_2, tint_symbol_3); return; } - -tint_fXClsP.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f)); - ^ -tint_fXClsP.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.msl index aa253728a6..b524707c15 100644 --- a/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_65ac50() { - float4 res = arg_0.sample(arg_1, float2(), 1, bias(1.0f), int2()); +void textureSampleBias_65ac50(texture2d_array tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2(), 1, bias(1.0f), int2()); } -fragment void fragment_main() { - textureSampleBias_65ac50(); +fragment void fragment_main(texture2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_65ac50(tint_symbol_2, tint_symbol_3); return; } - -tint_VENNtZ.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1, bias(1.0f), int2()); - ^ -tint_VENNtZ.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1, bias(1.0f), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.msl index e69609308e..32ca94ed2a 100644 --- a/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_6a9113() { - float4 res = arg_0.sample(arg_1, float2(), bias(1.0f)); +void textureSampleBias_6a9113(texture2d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2(), bias(1.0f)); } -fragment void fragment_main() { - textureSampleBias_6a9113(); +fragment void fragment_main(texture2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_6a9113(tint_symbol_2, tint_symbol_3); return; } - -tint_n6HLQB.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), bias(1.0f)); - ^ -tint_n6HLQB.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), bias(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.msl index e1858876a0..a0bcaf350e 100644 --- a/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_80e579() { - float4 res = arg_0.sample(arg_1, float2(), 1, bias(1.0f)); +void textureSampleBias_80e579(texture2d_array tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2(), 1, bias(1.0f)); } -fragment void fragment_main() { - textureSampleBias_80e579(); +fragment void fragment_main(texture2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_80e579(tint_symbol_2, tint_symbol_3); return; } - -tint_VVVRdp.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1, bias(1.0f)); - ^ -tint_VVVRdp.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1, bias(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.msl index 3569b2b7e6..cc9704be74 100644 --- a/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_81c19a() { - float4 res = arg_0.sample(arg_1, float2(), bias(1.0f), int2()); +void textureSampleBias_81c19a(texture2d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float2(), bias(1.0f), int2()); } -fragment void fragment_main() { - textureSampleBias_81c19a(); +fragment void fragment_main(texture2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_81c19a(tint_symbol_2, tint_symbol_3); return; } - -tint_Zl326D.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), bias(1.0f), int2()); - ^ -tint_Zl326D.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), bias(1.0f), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.msl index ee3b17b1ea..459f852b61 100644 --- a/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_d3fa1b() { - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f)); +void textureSampleBias_d3fa1b(texture3d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3(), bias(1.0f)); } -fragment void fragment_main() { - textureSampleBias_d3fa1b(); +fragment void fragment_main(texture3d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_d3fa1b(tint_symbol_2, tint_symbol_3); return; } - -tint_21BT87.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f)); - ^ -tint_21BT87.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.msl index ca7248380f..679cfa2a54 100644 --- a/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_df91bb() { - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f), int3()); +void textureSampleBias_df91bb(texture3d tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3(), bias(1.0f), int3()); } -fragment void fragment_main() { - textureSampleBias_df91bb(); +fragment void fragment_main(texture3d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_df91bb(tint_symbol_2, tint_symbol_3); return; } - -tint_Y31ZCA.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f), int3()); - ^ -tint_Y31ZCA.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), bias(1.0f), int3()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.msl b/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.msl index 37c07b0003..6c3eee033c 100644 --- a/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleBias_eed7c4() { - float4 res = arg_0.sample(arg_1, float3(), 1, bias(1.0f)); +void textureSampleBias_eed7c4(texturecube_array tint_symbol, sampler tint_symbol_1) { + float4 res = tint_symbol.sample(tint_symbol_1, float3(), 1, bias(1.0f)); } -fragment void fragment_main() { - textureSampleBias_eed7c4(); +fragment void fragment_main(texturecube_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleBias_eed7c4(tint_symbol_2, tint_symbol_3); return; } - -tint_FJH9UG.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), 1, bias(1.0f)); - ^ -tint_FJH9UG.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), 1, bias(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.msl b/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.msl index 91fa073c52..aadfa63be3 100644 --- a/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleCompare_25fcd1() { - float res = arg_0.sample_compare(arg_1, float2(), 1.0f, int2()); +void textureSampleCompare_25fcd1(depth2d tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample_compare(tint_symbol_1, float2(), 1.0f, int2()); } -fragment void fragment_main() { - textureSampleCompare_25fcd1(); +fragment void fragment_main(depth2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleCompare_25fcd1(tint_symbol_2, tint_symbol_3); return; } - -tint_pEGMaq.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample_compare(arg_1, float2(), 1.0f, int2()); - ^ -tint_pEGMaq.metal:5:36: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample_compare(arg_1, float2(), 1.0f, int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.msl b/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.msl index f47fc85aa3..34fff8c59b 100644 --- a/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleCompare_3a5923() { - float res = arg_0.sample_compare(arg_1, float2(), 1.0f); +void textureSampleCompare_3a5923(depth2d tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample_compare(tint_symbol_1, float2(), 1.0f); } -fragment void fragment_main() { - textureSampleCompare_3a5923(); +fragment void fragment_main(depth2d tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleCompare_3a5923(tint_symbol_2, tint_symbol_3); return; } - -tint_VUn9yJ.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample_compare(arg_1, float2(), 1.0f); - ^ -tint_VUn9yJ.metal:5:36: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample_compare(arg_1, float2(), 1.0f); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.msl b/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.msl index d3cbb77ee0..81a2824aaa 100644 --- a/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleCompare_63fb83() { - float res = arg_0.sample_compare(arg_1, float3(), 1.0f); +void textureSampleCompare_63fb83(depthcube tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample_compare(tint_symbol_1, float3(), 1.0f); } -fragment void fragment_main() { - textureSampleCompare_63fb83(); +fragment void fragment_main(depthcube tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleCompare_63fb83(tint_symbol_2, tint_symbol_3); return; } - -tint_GIZRbk.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample_compare(arg_1, float3(), 1.0f); - ^ -tint_GIZRbk.metal:5:36: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample_compare(arg_1, float3(), 1.0f); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.msl b/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.msl index bf33ddb556..ddfa6a6424 100644 --- a/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleCompare_98b85c() { - float res = arg_0.sample_compare(arg_1, float2(), 1, 1.0f, int2()); +void textureSampleCompare_98b85c(depth2d_array tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample_compare(tint_symbol_1, float2(), 1, 1.0f, int2()); } -fragment void fragment_main() { - textureSampleCompare_98b85c(); +fragment void fragment_main(depth2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleCompare_98b85c(tint_symbol_2, tint_symbol_3); return; } - -tint_MYN6rp.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample_compare(arg_1, float2(), 1, 1.0f, int2()); - ^ -tint_MYN6rp.metal:5:36: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample_compare(arg_1, float2(), 1, 1.0f, int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.msl b/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.msl index 7b6911325e..c9ea045b85 100644 --- a/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleCompare_a3ca7e() { - float res = arg_0.sample_compare(arg_1, float3(), 1, 1.0f); +void textureSampleCompare_a3ca7e(depthcube_array tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample_compare(tint_symbol_1, float3(), 1, 1.0f); } -fragment void fragment_main() { - textureSampleCompare_a3ca7e(); +fragment void fragment_main(depthcube_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleCompare_a3ca7e(tint_symbol_2, tint_symbol_3); return; } - -tint_9kTJOr.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample_compare(arg_1, float3(), 1, 1.0f); - ^ -tint_9kTJOr.metal:5:36: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample_compare(arg_1, float3(), 1, 1.0f); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.msl b/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.msl index 21ecff4cdc..821659d2f2 100644 --- a/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.msl @@ -1,25 +1,12 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleCompare_dd431d() { - float res = arg_0.sample_compare(arg_1, float2(), 1, 1.0f); +void textureSampleCompare_dd431d(depth2d_array tint_symbol, sampler tint_symbol_1) { + float res = tint_symbol.sample_compare(tint_symbol_1, float2(), 1, 1.0f); } -fragment void fragment_main() { - textureSampleCompare_dd431d(); +fragment void fragment_main(depth2d_array tint_symbol_2 [[texture(0)]], sampler tint_symbol_3 [[sampler(1)]]) { + textureSampleCompare_dd431d(tint_symbol_2, tint_symbol_3); return; } - -tint_QVzgbg.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample_compare(arg_1, float2(), 1, 1.0f); - ^ -tint_QVzgbg.metal:5:36: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample_compare(arg_1, float2(), 1, 1.0f); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.msl index 57728da442..219cb0f19c 100644 --- a/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_21402b() { - float4 res = arg_0.sample(arg_1, float3(), gradient3d(float3(), float3())); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_21402b(texture3d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), gradient3d(float3(), float3())); } -vertex void vertex_main() { - textureSampleGrad_21402b(); +vertex tint_symbol vertex_main(texture3d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_21402b(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_21402b(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_21402b(); +kernel void compute_main(texture3d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_21402b(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_21402b(); - return; -} - - -tint_A4BTTm.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), gradient3d(float3(), float3())); - ^ -tint_A4BTTm.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), gradient3d(float3(), float3())); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.msl index 97ce44841f..7c2dc9fab6 100644 --- a/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_2ecd8f() { - float4 res = arg_0.sample(arg_1, float2(), 1, gradient2d(float2(), float2())); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_2ecd8f(texture2d_array tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), 1, gradient2d(float2(), float2())); } -vertex void vertex_main() { - textureSampleGrad_2ecd8f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_2ecd8f(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_2ecd8f(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_2ecd8f(); +kernel void compute_main(texture2d_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_2ecd8f(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_2ecd8f(); - return; -} - - -tint_sLu7kk.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1, gradient2d(float2(), float2())); - ^ -tint_sLu7kk.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1, gradient2d(float2(), float2())); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.msl index 984a782f59..4e95d39068 100644 --- a/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_468f88() { - float4 res = arg_0.sample(arg_1, float2(), gradient2d(float2(), float2()), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_468f88(texture2d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), gradient2d(float2(), float2()), int2()); } -vertex void vertex_main() { - textureSampleGrad_468f88(); +vertex tint_symbol vertex_main(texture2d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_468f88(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_468f88(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_468f88(); +kernel void compute_main(texture2d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_468f88(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_468f88(); - return; -} - - -tint_doTaaj.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), gradient2d(float2(), float2()), int2()); - ^ -tint_doTaaj.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), gradient2d(float2(), float2()), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.msl index 8991aad3e2..ade4b16e81 100644 --- a/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_521263() { - float4 res = arg_0.sample(arg_1, float2(), gradient2d(float2(), float2())); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_521263(texture2d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), gradient2d(float2(), float2())); } -vertex void vertex_main() { - textureSampleGrad_521263(); +vertex tint_symbol vertex_main(texture2d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_521263(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_521263(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_521263(); +kernel void compute_main(texture2d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_521263(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_521263(); - return; -} - - -tint_WUNBbn.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), gradient2d(float2(), float2())); - ^ -tint_WUNBbn.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), gradient2d(float2(), float2())); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.msl index e1c12534cd..4509bb3fd2 100644 --- a/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_5312f4() { - float4 res = arg_0.sample(arg_1, float3(), gradientcube(float3(), float3())); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_5312f4(texturecube tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), gradientcube(float3(), float3())); } -vertex void vertex_main() { - textureSampleGrad_5312f4(); +vertex tint_symbol vertex_main(texturecube tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_5312f4(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_5312f4(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_5312f4(); +kernel void compute_main(texturecube tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_5312f4(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_5312f4(); - return; -} - - -tint_ktuoWy.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), gradientcube(float3(), float3())); - ^ -tint_ktuoWy.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), gradientcube(float3(), float3())); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.msl index 57e6ed3928..f946dad827 100644 --- a/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_872f00() { - float4 res = arg_0.sample(arg_1, float2(), 1, gradient2d(float2(), float2()), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_872f00(texture2d_array tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), 1, gradient2d(float2(), float2()), int2()); } -vertex void vertex_main() { - textureSampleGrad_872f00(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_872f00(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_872f00(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_872f00(); +kernel void compute_main(texture2d_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_872f00(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_872f00(); - return; -} - - -tint_9yqds2.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1, gradient2d(float2(), float2()), int2()); - ^ -tint_9yqds2.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1, gradient2d(float2(), float2()), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.msl index 12a18a8720..e25de9bd58 100644 --- a/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_e383db() { - float4 res = arg_0.sample(arg_1, float3(), 1, gradientcube(float3(), float3())); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_e383db(texturecube_array tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), 1, gradientcube(float3(), float3())); } -vertex void vertex_main() { - textureSampleGrad_e383db(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_e383db(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_e383db(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_e383db(); +kernel void compute_main(texturecube_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_e383db(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_e383db(); - return; -} - - -tint_2um7ce.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), 1, gradientcube(float3(), float3())); - ^ -tint_2um7ce.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), 1, gradientcube(float3(), float3())); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.msl b/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.msl index a0423e84a0..814d619ee3 100644 --- a/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleGrad_e9a2f7() { - float4 res = arg_0.sample(arg_1, float3(), gradient3d(float3(), float3()), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleGrad_e9a2f7(texture3d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), gradient3d(float3(), float3()), int3()); } -vertex void vertex_main() { - textureSampleGrad_e9a2f7(); +vertex tint_symbol vertex_main(texture3d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleGrad_e9a2f7(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleGrad_e9a2f7(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleGrad_e9a2f7(); +kernel void compute_main(texture3d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleGrad_e9a2f7(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleGrad_e9a2f7(); - return; -} - - -tint_XTrY0h.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), gradient3d(float3(), float3()), int3()); - ^ -tint_XTrY0h.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), gradient3d(float3(), float3()), int3()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.msl index 2f21bc3077..1883817bfb 100644 --- a/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_02be59() { - float res = arg_0.sample(arg_1, float2(), level(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_02be59(depth2d tint_symbol_2, sampler tint_symbol_3) { + float res = tint_symbol_2.sample(tint_symbol_3, float2(), level(1)); } -vertex void vertex_main() { - textureSampleLevel_02be59(); +vertex tint_symbol vertex_main(depth2d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_02be59(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_02be59(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_02be59(); +kernel void compute_main(depth2d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_02be59(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_02be59(); - return; -} - - -tint_MlSwdA.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2(), level(1)); - ^ -tint_MlSwdA.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2(), level(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.msl index 6880ef209a..b3008f4e50 100644 --- a/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_0bdd9a() { - float4 res = arg_0.sample(arg_1, float3(), 1, level(1.0f)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_0bdd9a(texturecube_array tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), 1, level(1.0f)); } -vertex void vertex_main() { - textureSampleLevel_0bdd9a(); +vertex tint_symbol vertex_main(texturecube_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_0bdd9a(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_0bdd9a(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_0bdd9a(); +kernel void compute_main(texturecube_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_0bdd9a(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_0bdd9a(); - return; -} - - -tint_y7pPKt.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), 1, level(1.0f)); - ^ -tint_y7pPKt.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), 1, level(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.msl index da76cd6e3c..f380dd0ef3 100644 --- a/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_1b0291() { - float res = arg_0.sample(arg_1, float3(), level(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_1b0291(depthcube tint_symbol_2, sampler tint_symbol_3) { + float res = tint_symbol_2.sample(tint_symbol_3, float3(), level(1)); } -vertex void vertex_main() { - textureSampleLevel_1b0291(); +vertex tint_symbol vertex_main(depthcube tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_1b0291(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_1b0291(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_1b0291(); +kernel void compute_main(depthcube tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_1b0291(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_1b0291(); - return; -} - - -tint_i62KS7.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float3(), level(1)); - ^ -tint_i62KS7.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float3(), level(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.msl index c5e9d5aef2..8e3c20e408 100644 --- a/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_1bf73e() { - float res = arg_0.sample(arg_1, float2(), 1, level(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_1bf73e(depth2d_array tint_symbol_2, sampler tint_symbol_3) { + float res = tint_symbol_2.sample(tint_symbol_3, float2(), 1, level(1)); } -vertex void vertex_main() { - textureSampleLevel_1bf73e(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_1bf73e(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_1bf73e(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_1bf73e(); +kernel void compute_main(depth2d_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_1bf73e(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_1bf73e(); - return; -} - - -tint_tekcGc.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2(), 1, level(1)); - ^ -tint_tekcGc.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2(), 1, level(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.msl index 06532a11cf..67386fc86b 100644 --- a/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_302be4() { - float4 res = arg_0.sample(arg_1, float2(), 1, level(1.0f)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_302be4(texture2d_array tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), 1, level(1.0f)); } -vertex void vertex_main() { - textureSampleLevel_302be4(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_302be4(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_302be4(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_302be4(); +kernel void compute_main(texture2d_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_302be4(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_302be4(); - return; -} - - -tint_tJxVCK.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1, level(1.0f)); - ^ -tint_tJxVCK.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1, level(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.msl index 62a1918bc3..565f8c0f0d 100644 --- a/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_47daa4() { - float res = arg_0.sample(arg_1, float2(), level(1), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_47daa4(depth2d tint_symbol_2, sampler tint_symbol_3) { + float res = tint_symbol_2.sample(tint_symbol_3, float2(), level(1), int2()); } -vertex void vertex_main() { - textureSampleLevel_47daa4(); +vertex tint_symbol vertex_main(depth2d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_47daa4(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_47daa4(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_47daa4(); +kernel void compute_main(depth2d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_47daa4(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_47daa4(); - return; -} - - -tint_NueDXP.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2(), level(1), int2()); - ^ -tint_NueDXP.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2(), level(1), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.msl index d1c3c2bb83..19335c7a90 100644 --- a/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_690d95() { - float4 res = arg_0.sample(arg_1, float2(), level(1.0f), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_690d95(texture2d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), level(1.0f), int2()); } -vertex void vertex_main() { - textureSampleLevel_690d95(); +vertex tint_symbol vertex_main(texture2d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_690d95(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_690d95(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_690d95(); +kernel void compute_main(texture2d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_690d95(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_690d95(); - return; -} - - -tint_QmnI4P.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), level(1.0f), int2()); - ^ -tint_QmnI4P.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), level(1.0f), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.msl index fb4f07252d..52e5e0dc8e 100644 --- a/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_979816() { - float4 res = arg_0.sample(arg_1, float2(), level(0.0f)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_979816(texture2d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), level(0.0f)); } -vertex void vertex_main() { - textureSampleLevel_979816(); +vertex tint_symbol vertex_main(texture2d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_979816(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_979816(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_979816(); +kernel void compute_main(texture2d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_979816(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_979816(); - return; -} - - -tint_iGu5by.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), level(0.0f)); - ^ -tint_iGu5by.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), level(0.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.msl index 75bb3f356c..f7ba24598e 100644 --- a/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_9bd37b() { - float4 res = arg_0.sample(arg_1, float3(), level(1.0f), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_9bd37b(texture3d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), level(1.0f), int3()); } -vertex void vertex_main() { - textureSampleLevel_9bd37b(); +vertex tint_symbol vertex_main(texture3d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_9bd37b(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_9bd37b(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_9bd37b(); +kernel void compute_main(texture3d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_9bd37b(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_9bd37b(); - return; -} - - -tint_F0xrSV.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), level(1.0f), int3()); - ^ -tint_F0xrSV.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), level(1.0f), int3()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.msl index dd8a62ed58..777e17ea32 100644 --- a/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_a4af26() { - float4 res = arg_0.sample(arg_1, float2(), 1, level(1.0f), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_a4af26(texture2d_array tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), 1, level(1.0f), int2()); } -vertex void vertex_main() { - textureSampleLevel_a4af26(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_a4af26(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_a4af26(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_a4af26(); +kernel void compute_main(texture2d_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_a4af26(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_a4af26(); - return; -} - - -tint_SXV7wz.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), 1, level(1.0f), int2()); - ^ -tint_SXV7wz.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), 1, level(1.0f), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.msl index 5e889aa4a5..16820040ef 100644 --- a/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_abfcc0() { - float4 res = arg_0.sample(arg_1, float3(), level(1.0f)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_abfcc0(texture3d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), level(1.0f)); } -vertex void vertex_main() { - textureSampleLevel_abfcc0(); +vertex tint_symbol vertex_main(texture3d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_abfcc0(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_abfcc0(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_abfcc0(); +kernel void compute_main(texture3d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_abfcc0(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_abfcc0(); - return; -} - - -tint_Utz1cx.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), level(1.0f)); - ^ -tint_Utz1cx.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), level(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.msl index f37b48b2c5..955ed3a20b 100644 --- a/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_ae5e39() { - float res = arg_0.sample(arg_1, float3(), 1, level(1)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_ae5e39(depthcube_array tint_symbol_2, sampler tint_symbol_3) { + float res = tint_symbol_2.sample(tint_symbol_3, float3(), 1, level(1)); } -vertex void vertex_main() { - textureSampleLevel_ae5e39(); +vertex tint_symbol vertex_main(depthcube_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_ae5e39(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depthcube_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_ae5e39(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_ae5e39(); +kernel void compute_main(depthcube_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_ae5e39(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_ae5e39(); - return; -} - - -tint_mqWfoh.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float3(), 1, level(1)); - ^ -tint_mqWfoh.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float3(), 1, level(1)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.msl index 3c49e31c55..6c24df624d 100644 --- a/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_ba93b3() { - float res = arg_0.sample(arg_1, float2(), 1, level(1), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_ba93b3(depth2d_array tint_symbol_2, sampler tint_symbol_3) { + float res = tint_symbol_2.sample(tint_symbol_3, float2(), 1, level(1), int2()); } -vertex void vertex_main() { - textureSampleLevel_ba93b3(); +vertex tint_symbol vertex_main(depth2d_array tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_ba93b3(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(depth2d_array tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_ba93b3(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_ba93b3(); +kernel void compute_main(depth2d_array tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_ba93b3(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_ba93b3(); - return; -} - - -tint_HAD0Zn.metal:5:15: error: use of undeclared identifier 'arg_0' - float res = arg_0.sample(arg_1, float2(), 1, level(1), int2()); - ^ -tint_HAD0Zn.metal:5:28: error: use of undeclared identifier 'arg_1' - float res = arg_0.sample(arg_1, float2(), 1, level(1), int2()); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.msl index 02d477ca90..62943cadfc 100644 --- a/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_c32df7() { - float4 res = arg_0.sample(arg_1, float3(), level(1.0f)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_c32df7(texturecube tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float3(), level(1.0f)); } -vertex void vertex_main() { - textureSampleLevel_c32df7(); +vertex tint_symbol vertex_main(texturecube tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_c32df7(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texturecube tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_c32df7(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_c32df7(); +kernel void compute_main(texturecube tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_c32df7(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_c32df7(); - return; -} - - -tint_OIsoHc.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float3(), level(1.0f)); - ^ -tint_OIsoHc.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float3(), level(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.msl b/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.msl index 4e4b5a47f2..bbe79664b3 100644 --- a/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.msl @@ -1,35 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureSampleLevel_c6aca6() { - float4 res = arg_0.sample(arg_1, float2(), level(1.0f)); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureSampleLevel_c6aca6(texture2d tint_symbol_2, sampler tint_symbol_3) { + float4 res = tint_symbol_2.sample(tint_symbol_3, float2(), level(1.0f)); } -vertex void vertex_main() { - textureSampleLevel_c6aca6(); +vertex tint_symbol vertex_main(texture2d tint_symbol_4 [[texture(0)]], sampler tint_symbol_5 [[sampler(1)]]) { + textureSampleLevel_c6aca6(tint_symbol_4, tint_symbol_5); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_6 [[texture(0)]], sampler tint_symbol_7 [[sampler(1)]]) { + textureSampleLevel_c6aca6(tint_symbol_6, tint_symbol_7); return; } -fragment void fragment_main() { - textureSampleLevel_c6aca6(); +kernel void compute_main(texture2d tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(1)]]) { + textureSampleLevel_c6aca6(tint_symbol_8, tint_symbol_9); return; } -kernel void compute_main() { - textureSampleLevel_c6aca6(); - return; -} - - -tint_fS8Xzw.metal:5:16: error: use of undeclared identifier 'arg_0' - float4 res = arg_0.sample(arg_1, float2(), level(1.0f)); - ^ -tint_fS8Xzw.metal:5:29: error: use of undeclared identifier 'arg_1' - float4 res = arg_0.sample(arg_1, float2(), level(1.0f)); - ^ -2 errors generated. diff --git a/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.msl b/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.msl index 6882d8133d..905ce5adab 100644 --- a/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_05ce15() { - arg_0.write(float4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_05ce15(texture2d tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_05ce15(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_05ce15(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_05ce15(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_05ce15(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_05ce15(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_05ce15(); - return; -} - - -tint_9eeMzw.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.msl index 65538ec466..fecd34efe1 100644 --- a/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_064c7f() { - arg_0.write(float4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_064c7f(texture2d tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_064c7f(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_064c7f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_064c7f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_064c7f(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_064c7f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_064c7f(); - return; -} - - -tint_HPJeZt.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/068641.wgsl.expected.msl b/test/intrinsics/gen/textureStore/068641.wgsl.expected.msl index 4b9e7b99e6..efeb713525 100644 --- a/test/intrinsics/gen/textureStore/068641.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/068641.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_068641() { - arg_0.write(uint4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_068641(texture3d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_068641(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_068641(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_068641(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_068641(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_068641(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_068641(); - return; -} - - -tint_yRIG80.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.msl b/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.msl index cb8727bd4e..c8f9a600da 100644 --- a/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_0af6b5() { - arg_0.write(float4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_0af6b5(texture2d tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_0af6b5(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_0af6b5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_0af6b5(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_0af6b5(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_0af6b5(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_0af6b5(); - return; -} - - -tint_XLLIfe.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.msl b/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.msl index 9290996b94..181dcde059 100644 --- a/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_0c3dff() { - arg_0.write(uint4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_0c3dff(texture2d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_0c3dff(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_0c3dff(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_0c3dff(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_0c3dff(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_0c3dff(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_0c3dff(); - return; -} - - -tint_U5Oofe.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/102722.wgsl.expected.msl b/test/intrinsics/gen/textureStore/102722.wgsl.expected.msl index dc52f88b62..e6798fe346 100644 --- a/test/intrinsics/gen/textureStore/102722.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/102722.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_102722() { - arg_0.write(uint4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_102722(texture1d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint(1)); } -vertex void vertex_main() { - textureStore_102722(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_102722(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_102722(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_102722(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_102722(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_102722(); - return; -} - - -tint_FWnulI.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.msl b/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.msl index e5f3aa7b90..358a92c825 100644 --- a/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_1bbd08() { - arg_0.write(float4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_1bbd08(texture3d tint_symbol_2) { + tint_symbol_2.write(float4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_1bbd08(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_1bbd08(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_1bbd08(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_1bbd08(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_1bbd08(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_1bbd08(); - return; -} - - -tint_dwpRke.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.msl b/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.msl index 61d0b7a5f8..dbadaba2f3 100644 --- a/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_1c02e7() { - arg_0.write(int4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_1c02e7(texture2d_array tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_1c02e7(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_1c02e7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_1c02e7(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_1c02e7(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_1c02e7(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_1c02e7(); - return; -} - - -tint_CpbCeH.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/22d955.wgsl.expected.msl b/test/intrinsics/gen/textureStore/22d955.wgsl.expected.msl index cd4b05ebde..96ab7caef1 100644 --- a/test/intrinsics/gen/textureStore/22d955.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/22d955.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_22d955() { - arg_0.write(uint4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_22d955(texture2d_array tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_22d955(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_22d955(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_22d955(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_22d955(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_22d955(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_22d955(); - return; -} - - -tint_4GbpDy.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.msl b/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.msl index 30ff0a8f6f..0478e59a98 100644 --- a/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_26bf70() { - arg_0.write(uint4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_26bf70(texture2d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_26bf70(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_26bf70(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_26bf70(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_26bf70(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_26bf70(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_26bf70(); - return; -} - - -tint_u7QeEL.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.msl b/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.msl index aff37f8532..22b40b0c4f 100644 --- a/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_2796b4() { - arg_0.write(int4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_2796b4(texture3d tint_symbol_2) { + tint_symbol_2.write(int4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_2796b4(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_2796b4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_2796b4(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_2796b4(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_2796b4(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_2796b4(); - return; -} - - -tint_hHByVz.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.msl b/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.msl index c73714bb7d..2262931487 100644 --- a/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_2ac6c7() { - arg_0.write(float4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_2ac6c7(texture1d tint_symbol_2) { + tint_symbol_2.write(float4(), uint(1)); } -vertex void vertex_main() { - textureStore_2ac6c7(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_2ac6c7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_2ac6c7(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_2ac6c7(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_2ac6c7(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_2ac6c7(); - return; -} - - -tint_FUFaCJ.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.msl b/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.msl index 87d35c0efe..b0c20f5672 100644 --- a/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_2eb2a4() { - arg_0.write(uint4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_2eb2a4(texture1d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint(1)); } -vertex void vertex_main() { - textureStore_2eb2a4(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_2eb2a4(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_2eb2a4(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_2eb2a4(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_2eb2a4(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_2eb2a4(); - return; -} - - -tint_PNmP6G.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.msl b/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.msl index c592342596..c5dfae2e41 100644 --- a/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_2ed2a3() { - arg_0.write(float4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_2ed2a3(texture1d tint_symbol_2) { + tint_symbol_2.write(float4(), uint(1)); } -vertex void vertex_main() { - textureStore_2ed2a3(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_2ed2a3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_2ed2a3(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_2ed2a3(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_2ed2a3(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_2ed2a3(); - return; -} - - -tint_k1UauU.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/31745b.wgsl.expected.msl b/test/intrinsics/gen/textureStore/31745b.wgsl.expected.msl index b29dadbf60..a57589a999 100644 --- a/test/intrinsics/gen/textureStore/31745b.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/31745b.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_31745b() { - arg_0.write(int4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_31745b(texture2d tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_31745b(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_31745b(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_31745b(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_31745b(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_31745b(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_31745b(); - return; -} - - -tint_4hXtaI.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/32f368.wgsl.expected.msl b/test/intrinsics/gen/textureStore/32f368.wgsl.expected.msl index d915febcd5..71c924526f 100644 --- a/test/intrinsics/gen/textureStore/32f368.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/32f368.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_32f368() { - arg_0.write(float4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_32f368(texture2d_array tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_32f368(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_32f368(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_32f368(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_32f368(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_32f368(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_32f368(); - return; -} - - -tint_bxPhKa.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/331aee.wgsl.expected.msl b/test/intrinsics/gen/textureStore/331aee.wgsl.expected.msl index 975862cc57..0eeef88f92 100644 --- a/test/intrinsics/gen/textureStore/331aee.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/331aee.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_331aee() { - arg_0.write(float4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_331aee(texture3d tint_symbol_2) { + tint_symbol_2.write(float4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_331aee(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_331aee(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_331aee(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_331aee(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_331aee(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_331aee(); - return; -} - - -tint_kixkHt.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.msl b/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.msl index a29fc2971a..ac9cdd5fb7 100644 --- a/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_38e8d7() { - arg_0.write(uint4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_38e8d7(texture2d_array tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_38e8d7(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_38e8d7(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_38e8d7(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_38e8d7(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_38e8d7(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_38e8d7(); - return; -} - - -tint_x2IjFo.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.msl b/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.msl index 1468a7e06b..0c932b198b 100644 --- a/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_3a52ac() { - arg_0.write(int4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_3a52ac(texture2d_array tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_3a52ac(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_3a52ac(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_3a52ac(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_3a52ac(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_3a52ac(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_3a52ac(); - return; -} - - -tint_N2pxwW.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.msl b/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.msl index d4b0d0d0a8..1ae07e4a38 100644 --- a/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_3bb7a1() { - arg_0.write(float4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_3bb7a1(texture2d_array tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_3bb7a1(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_3bb7a1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_3bb7a1(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_3bb7a1(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_3bb7a1(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_3bb7a1(); - return; -} - - -tint_L0adSp.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.msl b/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.msl index 9a4bb4555a..cda786e535 100644 --- a/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_3bec15() { - arg_0.write(uint4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_3bec15(texture1d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint(1)); } -vertex void vertex_main() { - textureStore_3bec15(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_3bec15(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_3bec15(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_3bec15(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_3bec15(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_3bec15(); - return; -} - - -tint_7THBtQ.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.msl b/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.msl index 6c5454beaa..4dd21a5444 100644 --- a/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_441ba8() { - arg_0.write(uint4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_441ba8(texture3d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_441ba8(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_441ba8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_441ba8(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_441ba8(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_441ba8(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_441ba8(); - return; -} - - -tint_FcfuwY.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.msl b/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.msl index e0e9cc6b27..39d0e12e59 100644 --- a/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_4fc057() { - arg_0.write(float4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_4fc057(texture2d_array tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_4fc057(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_4fc057(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_4fc057(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_4fc057(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_4fc057(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_4fc057(); - return; -} - - -tint_xwVRdI.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.msl index 123767fe98..2fa1d0efac 100644 --- a/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_5a2f8f() { - arg_0.write(int4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_5a2f8f(texture1d tint_symbol_2) { + tint_symbol_2.write(int4(), uint(1)); } -vertex void vertex_main() { - textureStore_5a2f8f(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_5a2f8f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_5a2f8f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_5a2f8f(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_5a2f8f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_5a2f8f(); - return; -} - - -tint_iDp0i1.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/60975f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/60975f.wgsl.expected.msl index 0b6f3e689b..1cde839abb 100644 --- a/test/intrinsics/gen/textureStore/60975f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/60975f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_60975f() { - arg_0.write(float4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_60975f(texture2d_array tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_60975f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_60975f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_60975f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_60975f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_60975f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_60975f(); - return; -} - - -tint_K8XxnZ.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.msl b/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.msl index 85a3f53eef..6b9bd649ff 100644 --- a/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_682fd6() { - arg_0.write(uint4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_682fd6(texture2d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_682fd6(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_682fd6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_682fd6(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_682fd6(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_682fd6(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_682fd6(); - return; -} - - -tint_7adx7Y.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.msl b/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.msl index a1e85878bd..bbedf08b88 100644 --- a/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_6b75c3() { - arg_0.write(float4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_6b75c3(texture1d tint_symbol_2) { + tint_symbol_2.write(float4(), uint(1)); } -vertex void vertex_main() { - textureStore_6b75c3(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_6b75c3(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_6b75c3(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_6b75c3(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_6b75c3(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_6b75c3(); - return; -} - - -tint_0jiMIP.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.msl b/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.msl index 5db01bc4f7..e6d79a840d 100644 --- a/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_6b80d2() { - arg_0.write(int4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_6b80d2(texture1d tint_symbol_2) { + tint_symbol_2.write(int4(), uint(1)); } -vertex void vertex_main() { - textureStore_6b80d2(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_6b80d2(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_6b80d2(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_6b80d2(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_6b80d2(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_6b80d2(); - return; -} - - -tint_GXJj7s.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.msl b/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.msl index e1bd31aaaf..46eb274c5a 100644 --- a/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_6cff2e() { - arg_0.write(uint4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_6cff2e(texture2d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_6cff2e(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_6cff2e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_6cff2e(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_6cff2e(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_6cff2e(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_6cff2e(); - return; -} - - -tint_UZX5yc.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/6da692.wgsl.expected.msl b/test/intrinsics/gen/textureStore/6da692.wgsl.expected.msl index 69ef6cc494..d29caadc23 100644 --- a/test/intrinsics/gen/textureStore/6da692.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/6da692.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_6da692() { - arg_0.write(uint4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_6da692(texture2d_array tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_6da692(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_6da692(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_6da692(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_6da692(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_6da692(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_6da692(); - return; -} - - -tint_efhqMi.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/731349.wgsl.expected.msl b/test/intrinsics/gen/textureStore/731349.wgsl.expected.msl index 7fb91681de..fe597ead2e 100644 --- a/test/intrinsics/gen/textureStore/731349.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/731349.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_731349() { - arg_0.write(float4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_731349(texture2d tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_731349(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_731349(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_731349(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_731349(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_731349(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_731349(); - return; -} - - -tint_3Zm8LE.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/752da6.wgsl.expected.msl b/test/intrinsics/gen/textureStore/752da6.wgsl.expected.msl index 4199b3f359..28e75f76e3 100644 --- a/test/intrinsics/gen/textureStore/752da6.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/752da6.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_752da6() { - arg_0.write(int4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_752da6(texture2d tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_752da6(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_752da6(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_752da6(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_752da6(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_752da6(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_752da6(); - return; -} - - -tint_zgq0Dl.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.msl b/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.msl index dcc371e2f6..7ea0267ee2 100644 --- a/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_77c0ae() { - arg_0.write(uint4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_77c0ae(texture2d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_77c0ae(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_77c0ae(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_77c0ae(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_77c0ae(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_77c0ae(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_77c0ae(); - return; -} - - -tint_zmPi8W.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.msl b/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.msl index 1acbb0495f..af5784bdb5 100644 --- a/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_7cec8d() { - arg_0.write(int4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_7cec8d(texture2d_array tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_7cec8d(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_7cec8d(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_7cec8d(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_7cec8d(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_7cec8d(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_7cec8d(); - return; -} - - -tint_YM1K5G.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.msl b/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.msl index 9fb1788190..0ace63b1d4 100644 --- a/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_7f7fae() { - arg_0.write(float4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_7f7fae(texture1d tint_symbol_2) { + tint_symbol_2.write(float4(), uint(1)); } -vertex void vertex_main() { - textureStore_7f7fae(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_7f7fae(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_7f7fae(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_7f7fae(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_7f7fae(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_7f7fae(); - return; -} - - -tint_l2ha2e.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/804942.wgsl.expected.msl b/test/intrinsics/gen/textureStore/804942.wgsl.expected.msl index 691a370d24..93097c5cc8 100644 --- a/test/intrinsics/gen/textureStore/804942.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/804942.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_804942() { - arg_0.write(int4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_804942(texture2d tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_804942(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_804942(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_804942(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_804942(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_804942(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_804942(); - return; -} - - -tint_bnGq7U.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/805dae.wgsl.expected.msl b/test/intrinsics/gen/textureStore/805dae.wgsl.expected.msl index 2351b98acc..a1c32f73a7 100644 --- a/test/intrinsics/gen/textureStore/805dae.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/805dae.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_805dae() { - arg_0.write(float4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_805dae(texture2d tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_805dae(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_805dae(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_805dae(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_805dae(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_805dae(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_805dae(); - return; -} - - -tint_5ZPxWj.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.msl b/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.msl index 7199f26be1..81093f4236 100644 --- a/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_83bcc1() { - arg_0.write(uint4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_83bcc1(texture1d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint(1)); } -vertex void vertex_main() { - textureStore_83bcc1(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_83bcc1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_83bcc1(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_83bcc1(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_83bcc1(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_83bcc1(); - return; -} - - -tint_ZAiGAn.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/872747.wgsl.expected.msl b/test/intrinsics/gen/textureStore/872747.wgsl.expected.msl index eef8b467fe..3b310db38c 100644 --- a/test/intrinsics/gen/textureStore/872747.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/872747.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_872747() { - arg_0.write(float4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_872747(texture1d tint_symbol_2) { + tint_symbol_2.write(float4(), uint(1)); } -vertex void vertex_main() { - textureStore_872747(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_872747(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_872747(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_872747(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_872747(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_872747(); - return; -} - - -tint_AifgyA.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.msl b/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.msl index 9b8b6ce1b5..18d1a53be2 100644 --- a/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_8e0479() { - arg_0.write(uint4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_8e0479(texture2d_array tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_8e0479(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_8e0479(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_8e0479(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_8e0479(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_8e0479(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_8e0479(); - return; -} - - -tint_scQig0.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.msl b/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.msl index 55376ea61c..b05a0078e3 100644 --- a/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_8f71a1() { - arg_0.write(int4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_8f71a1(texture3d tint_symbol_2) { + tint_symbol_2.write(int4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_8f71a1(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_8f71a1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_8f71a1(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_8f71a1(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_8f71a1(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_8f71a1(); - return; -} - - -tint_GBFPAJ.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/969534.wgsl.expected.msl b/test/intrinsics/gen/textureStore/969534.wgsl.expected.msl index 3f41d7792b..031459809a 100644 --- a/test/intrinsics/gen/textureStore/969534.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/969534.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_969534() { - arg_0.write(int4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_969534(texture1d tint_symbol_2) { + tint_symbol_2.write(int4(), uint(1)); } -vertex void vertex_main() { - textureStore_969534(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_969534(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_969534(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_969534(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_969534(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_969534(); - return; -} - - -tint_9ZMPd8.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.msl b/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.msl index 9275ac3dff..922ad72c53 100644 --- a/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_9a3ecc() { - arg_0.write(int4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_9a3ecc(texture3d tint_symbol_2) { + tint_symbol_2.write(int4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_9a3ecc(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_9a3ecc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_9a3ecc(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_9a3ecc(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_9a3ecc(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_9a3ecc(); - return; -} - - -tint_WyUTaF.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.msl b/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.msl index 7c96ca723f..2b264c549a 100644 --- a/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_9d9cd5() { - arg_0.write(float4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_9d9cd5(texture2d_array tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_9d9cd5(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_9d9cd5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_9d9cd5(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_9d9cd5(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_9d9cd5(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_9d9cd5(); - return; -} - - -tint_7LP9Um.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.msl b/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.msl index eef2b2f67c..85aa4c977e 100644 --- a/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_9e3ec5() { - arg_0.write(int4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_9e3ec5(texture2d tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_9e3ec5(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_9e3ec5(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_9e3ec5(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_9e3ec5(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_9e3ec5(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_9e3ec5(); - return; -} - - -tint_X1Wg39.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.msl b/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.msl index bd81135b28..6d6474648d 100644 --- a/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_ac67aa() { - arg_0.write(uint4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_ac67aa(texture3d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_ac67aa(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_ac67aa(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_ac67aa(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_ac67aa(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_ac67aa(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_ac67aa(); - return; -} - - -tint_uE9lGE.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.msl b/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.msl index fb1410d656..1136938b29 100644 --- a/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_b706b1() { - arg_0.write(int4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_b706b1(texture3d tint_symbol_2) { + tint_symbol_2.write(int4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_b706b1(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_b706b1(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_b706b1(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_b706b1(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_b706b1(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_b706b1(); - return; -} - - -tint_3D3Uvl.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.msl index b3d7d99248..2d4ab0fdc9 100644 --- a/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_bbcb7f() { - arg_0.write(int4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_bbcb7f(texture2d tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_bbcb7f(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_bbcb7f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_bbcb7f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_bbcb7f(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_bbcb7f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_bbcb7f(); - return; -} - - -tint_GQyBB7.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.msl b/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.msl index d93712f3cf..a9134c6bab 100644 --- a/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_be6e30() { - arg_0.write(float4(), int2()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_be6e30(texture2d tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2())); } -vertex void vertex_main() { - textureStore_be6e30(); +vertex tint_symbol vertex_main(texture2d tint_symbol_3 [[texture(0)]]) { + textureStore_be6e30(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d tint_symbol_4 [[texture(0)]]) { + textureStore_be6e30(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_be6e30(); +kernel void compute_main(texture2d tint_symbol_5 [[texture(0)]]) { + textureStore_be6e30(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_be6e30(); - return; -} - - -tint_FLv41D.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.msl b/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.msl index 4037b9b8ed..524037d9ca 100644 --- a/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_bf775c() { - arg_0.write(int4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_bf775c(texture1d tint_symbol_2) { + tint_symbol_2.write(int4(), uint(1)); } -vertex void vertex_main() { - textureStore_bf775c(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_bf775c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_bf775c(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_bf775c(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_bf775c(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_bf775c(); - return; -} - - -tint_41mJPt.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.msl b/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.msl index f5bf9cee7e..15d4ba3f8c 100644 --- a/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_c5af1e() { - arg_0.write(float4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_c5af1e(texture3d tint_symbol_2) { + tint_symbol_2.write(float4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_c5af1e(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_c5af1e(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_c5af1e(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_c5af1e(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_c5af1e(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_c5af1e(); - return; -} - - -tint_agFxJI.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/c863be.wgsl.expected.msl b/test/intrinsics/gen/textureStore/c863be.wgsl.expected.msl index 5c6fb3aba0..880329213a 100644 --- a/test/intrinsics/gen/textureStore/c863be.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/c863be.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_c863be() { - arg_0.write(float4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_c863be(texture2d_array tint_symbol_2) { + tint_symbol_2.write(float4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_c863be(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_c863be(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_c863be(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_c863be(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_c863be(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_c863be(); - return; -} - - -tint_GI47uE.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.msl b/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.msl index d62d4084e6..fda662dd1c 100644 --- a/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_d73b5c() { - arg_0.write(int4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_d73b5c(texture1d tint_symbol_2) { + tint_symbol_2.write(int4(), uint(1)); } -vertex void vertex_main() { - textureStore_d73b5c(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_d73b5c(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_d73b5c(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_d73b5c(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_d73b5c(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_d73b5c(); - return; -} - - -tint_PXkRSh.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.msl b/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.msl index 935b0c7e6f..a838752601 100644 --- a/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_dd7d81() { - arg_0.write(float4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_dd7d81(texture3d tint_symbol_2) { + tint_symbol_2.write(float4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_dd7d81(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_dd7d81(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_dd7d81(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_dd7d81(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_dd7d81(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_dd7d81(); - return; -} - - -tint_liWDoV.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/dde364.wgsl.expected.msl b/test/intrinsics/gen/textureStore/dde364.wgsl.expected.msl index 0592dbab3a..aaea0199e2 100644 --- a/test/intrinsics/gen/textureStore/dde364.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/dde364.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_dde364() { - arg_0.write(uint4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_dde364(texture2d_array tint_symbol_2) { + tint_symbol_2.write(uint4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_dde364(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_dde364(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_dde364(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_dde364(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_dde364(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_dde364(); - return; -} - - -tint_uY3wST.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.msl b/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.msl index deb4e3e6b2..9d476ea3ae 100644 --- a/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_e885e8() { - arg_0.write(float4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_e885e8(texture1d tint_symbol_2) { + tint_symbol_2.write(float4(), uint(1)); } -vertex void vertex_main() { - textureStore_e885e8(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_e885e8(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_e885e8(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_e885e8(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_e885e8(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_e885e8(); - return; -} - - -tint_EfGtQR.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.msl index eec733b69d..6047f22b54 100644 --- a/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_eb702f() { - arg_0.write(float4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_eb702f(texture3d tint_symbol_2) { + tint_symbol_2.write(float4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_eb702f(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_eb702f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_eb702f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_eb702f(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_eb702f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_eb702f(); - return; -} - - -tint_mkqzHD.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.msl b/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.msl index f989309b70..966e81b670 100644 --- a/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_eb78b9() { - arg_0.write(int4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_eb78b9(texture3d tint_symbol_2) { + tint_symbol_2.write(int4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_eb78b9(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_eb78b9(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_eb78b9(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_eb78b9(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_eb78b9(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_eb78b9(); - return; -} - - -tint_Vp5fbQ.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.msl b/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.msl index 9ba323da42..54dd77b134 100644 --- a/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_ee6acc() { - arg_0.write(float4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_ee6acc(texture3d tint_symbol_2) { + tint_symbol_2.write(float4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_ee6acc(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_ee6acc(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_ee6acc(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_ee6acc(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_ee6acc(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_ee6acc(); - return; -} - - -tint_Cu9b6y.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(float4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.msl index 73d6331238..155a2392ca 100644 --- a/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_ef9f2f() { - arg_0.write(uint4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_ef9f2f(texture3d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_ef9f2f(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_ef9f2f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_ef9f2f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_ef9f2f(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_ef9f2f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_ef9f2f(); - return; -} - - -tint_BKGK1I.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.msl b/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.msl index fb37bc85f1..21a8db295f 100644 --- a/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_f8dead() { - arg_0.write(uint4(), int3()); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_f8dead(texture3d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint3(int3())); } -vertex void vertex_main() { - textureStore_f8dead(); +vertex tint_symbol vertex_main(texture3d tint_symbol_3 [[texture(0)]]) { + textureStore_f8dead(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture3d tint_symbol_4 [[texture(0)]]) { + textureStore_f8dead(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_f8dead(); +kernel void compute_main(texture3d tint_symbol_5 [[texture(0)]]) { + textureStore_f8dead(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_f8dead(); - return; -} - - -tint_Agnpo0.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), int3()); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.msl b/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.msl index 98469159b6..b01a1a8c6b 100644 --- a/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_f9be83() { - arg_0.write(int4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_f9be83(texture2d_array tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_f9be83(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_f9be83(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_f9be83(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_f9be83(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_f9be83(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_f9be83(); - return; -} - - -tint_EfgEDv.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.msl index 7eede7bdff..f324700a02 100644 --- a/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_fb9a8f() { - arg_0.write(uint4(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_fb9a8f(texture1d tint_symbol_2) { + tint_symbol_2.write(uint4(), uint(1)); } -vertex void vertex_main() { - textureStore_fb9a8f(); +vertex tint_symbol vertex_main(texture1d tint_symbol_3 [[texture(0)]]) { + textureStore_fb9a8f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture1d tint_symbol_4 [[texture(0)]]) { + textureStore_fb9a8f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_fb9a8f(); +kernel void compute_main(texture1d tint_symbol_5 [[texture(0)]]) { + textureStore_fb9a8f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_fb9a8f(); - return; -} - - -tint_qJBlCj.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(uint4(), 1); - ^ -1 error generated. diff --git a/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.msl b/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.msl index ecabc8c0e0..ba5cb0cfa6 100644 --- a/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.msl +++ b/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.msl @@ -1,32 +1,27 @@ -SKIP: FAILED - - - -Validation Failure: #include using namespace metal; -void textureStore_fbf53f() { - arg_0.write(int4(), int2(), 1); +struct tint_symbol { + float4 value [[position]]; +}; + +void textureStore_fbf53f(texture2d_array tint_symbol_2) { + tint_symbol_2.write(int4(), uint2(int2()), 1); } -vertex void vertex_main() { - textureStore_fbf53f(); +vertex tint_symbol vertex_main(texture2d_array tint_symbol_3 [[texture(0)]]) { + textureStore_fbf53f(tint_symbol_3); + tint_symbol const tint_symbol_1 = {.value=float4()}; + return tint_symbol_1; +} + +fragment void fragment_main(texture2d_array tint_symbol_4 [[texture(0)]]) { + textureStore_fbf53f(tint_symbol_4); return; } -fragment void fragment_main() { - textureStore_fbf53f(); +kernel void compute_main(texture2d_array tint_symbol_5 [[texture(0)]]) { + textureStore_fbf53f(tint_symbol_5); return; } -kernel void compute_main() { - textureStore_fbf53f(); - return; -} - - -tint_bdJTN4.metal:5:3: error: use of undeclared identifier 'arg_0' - arg_0.write(int4(), int2(), 1); - ^ -1 error generated.