Coverage for tests/codegen/generated/variants/exports/e.py: 90%

1from ..intrinsics import _clamp, _f32_to_i32, _f64_to_i64, _load 

2from ..types import Err, Ok, Result, Some 

3import ctypes 

4from dataclasses import dataclass 

5from enum import Enum 

6from typing import Optional, Tuple, Union 

7import wasmtime 

8 

9from typing import TYPE_CHECKING 

10if TYPE_CHECKING: 

11 from .. import Root 

12 

13class E1(Enum): 

14 A = 0 

15 B = 1 

16 

17@dataclass 

18class C1A: 

19 value: int 

20 

21@dataclass 

22class C1B: 

23 value: int 

24 

25C1 = Union[C1A, C1B] 

26 

27@dataclass 

28class C2A: 

29 value: int 

30 

31@dataclass 

32class C2B: 

33 value: float 

34 

35C2 = Union[C2A, C2B] 

36 

37@dataclass 

38class C3A: 

39 value: int 

40 

41@dataclass 

42class C3B: 

43 value: float 

44 

45C3 = Union[C3A, C3B] 

46 

47@dataclass 

48class C4A: 

49 value: int 

50 

51@dataclass 

52class C4B: 

53 value: float 

54 

55C4 = Union[C4A, C4B] 

56 

57@dataclass 

58class C5A: 

59 value: int 

60 

61@dataclass 

62class C5B: 

63 value: float 

64 

65C5 = Union[C5A, C5B] 

66 

67@dataclass 

68class C6A: 

69 value: float 

70 

71@dataclass 

72class C6B: 

73 value: float 

74 

75C6 = Union[C6A, C6B] 

76 

77Casts = Tuple[C1, C2, C3, C4, C5, C6] 

78@dataclass 

79class Z1A: 

80 value: int 

81 

82@dataclass 

83class Z1B: 

84 pass 

85 

86Z1 = Union[Z1A, Z1B] 

87 

88@dataclass 

89class Z2A: 

90 value: int 

91 

92@dataclass 

93class Z2B: 

94 pass 

95 

96Z2 = Union[Z2A, Z2B] 

97 

98@dataclass 

99class Z3A: 

100 value: float 

101 

102@dataclass 

103class Z3B: 

104 pass 

105 

106Z3 = Union[Z3A, Z3B] 

107 

108@dataclass 

109class Z4A: 

110 value: float 

111 

112@dataclass 

113class Z4B: 

114 pass 

115 

116Z4 = Union[Z4A, Z4B] 

117 

118Zeros = Tuple[Z1, Z2, Z3, Z4] 

119@dataclass 

120class AllIntegersBool: 

121 value: bool 

122 

123@dataclass 

124class AllIntegersU8: 

125 value: int 

126 

127@dataclass 

128class AllIntegersU16: 

129 value: int 

130 

131@dataclass 

132class AllIntegersU32: 

133 value: int 

134 

135@dataclass 

136class AllIntegersU64: 

137 value: int 

138 

139@dataclass 

140class AllIntegersS8: 

141 value: int 

142 

143@dataclass 

144class AllIntegersS16: 

145 value: int 

146 

147@dataclass 

148class AllIntegersS32: 

149 value: int 

150 

151@dataclass 

152class AllIntegersS64: 

153 value: int 

154 

155AllIntegers = Union[AllIntegersBool, AllIntegersU8, AllIntegersU16, AllIntegersU32, AllIntegersU64, AllIntegersS8, AllIntegersS16, AllIntegersS32, AllIntegersS64] 

156 

157@dataclass 

158class AllFloatsF32: 

159 value: float 

160 

161@dataclass 

162class AllFloatsF64: 

163 value: float 

164 

165AllFloats = Union[AllFloatsF32, AllFloatsF64] 

166 

167@dataclass 

168class DuplicatedS32C1: 

169 value: int 

170 

171@dataclass 

172class DuplicatedS32C2: 

173 value: int 

174 

175@dataclass 

176class DuplicatedS32C3: 

177 value: int 

178 

179DuplicatedS32 = Union[DuplicatedS32C1, DuplicatedS32C2, DuplicatedS32C3] 

180 

181@dataclass 

182class DistinguishedS32: 

183 value: int 

184 

185@dataclass 

186class DistinguishedFloat32: 

187 value: float 

188 

189Distinguished = Union[DistinguishedS32, DistinguishedFloat32] 

190 

191@dataclass 

192class NestedUnionD: 

193 value: Distinguished 

194 

195@dataclass 

196class NestedUnionS32: 

197 value: int 

198 

199@dataclass 

200class NestedUnionFloat32: 

201 value: float 

202 

203NestedUnion = Union[NestedUnionD, NestedUnionS32, NestedUnionFloat32] 

204 

205@dataclass 

206class OptionInUnionO: 

207 value: Optional[int] 

208 

209@dataclass 

210class OptionInUnionI: 

211 value: int 

212 

213OptionInUnion = Union[OptionInUnionO, OptionInUnionI] 

214 

215class E: 

216 component: 'Root' 

217 

218 def __init__(self, component: 'Root') -> None: 

219 self.component = component 

220 def roundtrip_option(self, caller: wasmtime.Store, a: Optional[float]) -> Optional[int]: 

221 if a is None: 

222 variant = 0 

223 variant1 = 0.0 

224 else: 

225 payload0 = a 

226 variant = 1 

227 variant1 = payload0 

228 ret = self.component.lift_callee0(caller, variant, variant1) 

229 assert(isinstance(ret, int)) 

230 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

231 option: Optional[int] 

232 if load == 0: 

233 option = None 

234 elif load == 1: 

235 load2 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 1) 

236 option = _clamp(load2, 0, 255) 

237 else: 

238 raise TypeError("invalid variant discriminant for option") 

239 tmp = option 

240 return tmp 

241 def roundtrip_enum(self, caller: wasmtime.Store, a: E1) -> E1: 

242 ret = self.component.lift_callee1(caller, (a).value) 

243 assert(isinstance(ret, int)) 

244 return E1(ret) 

245 def add_one_nested_union(self, caller: wasmtime.Store, a: NestedUnion) -> NestedUnion: 

246 if isinstance(a, NestedUnionD): 

247 payload = a.value 

248 if isinstance(payload, DistinguishedS32): 

249 payload0 = payload.value 

250 variant = 0 

251 variant2 = _clamp(payload0, -2147483648, 2147483647) 

252 elif isinstance(payload, DistinguishedFloat32): 

253 payload1 = payload.value 

254 variant = 1 

255 variant2 = _f32_to_i32(payload1) 

256 else: 

257 raise TypeError("invalid variant specified for Distinguished") 

258 variant5 = 0 

259 variant6 = variant 

260 variant7 = variant2 

261 elif isinstance(a, NestedUnionS32): 

262 payload3 = a.value 

263 variant5 = 1 

264 variant6 = _clamp(payload3, -2147483648, 2147483647) 

265 variant7 = 0 

266 elif isinstance(a, NestedUnionFloat32): 

267 payload4 = a.value 

268 variant5 = 2 

269 variant6 = _f32_to_i32(payload4) 

270 variant7 = 0 

271 else: 

272 raise TypeError("invalid variant specified for NestedUnion") 

273 ret = self.component.lift_callee2(caller, variant5, variant6, variant7) 

274 assert(isinstance(ret, int)) 

275 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

276 variant14: NestedUnion 

277 if load == 0: 

278 load8 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 4) 

279 variant11: Distinguished 

280 if load8 == 0: 

281 load9 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 8) 

282 variant11 = DistinguishedS32(load9) 

283 elif load8 == 1: 

284 load10 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 8) 

285 variant11 = DistinguishedFloat32(load10) 

286 else: 

287 raise TypeError("invalid variant discriminant for Distinguished") 

288 variant14 = NestedUnionD(variant11) 

289 elif load == 1: 

290 load12 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4) 

291 variant14 = NestedUnionS32(load12) 

292 elif load == 2: 

293 load13 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 4) 

294 variant14 = NestedUnionFloat32(load13) 

295 else: 

296 raise TypeError("invalid variant discriminant for NestedUnion") 

297 tmp = variant14 

298 return tmp 

299 def add_one_option_in_union(self, caller: wasmtime.Store, a: OptionInUnion) -> OptionInUnion: 

300 if isinstance(a, OptionInUnionO): 

301 payload = a.value 

302 if payload is None: 

303 variant = 0 

304 variant2 = 0 

305 else: 

306 payload1 = payload 

307 variant = 1 

308 variant2 = _clamp(payload1, -2147483648, 2147483647) 

309 variant4 = 0 

310 variant5 = variant 

311 variant6 = variant2 

312 elif isinstance(a, OptionInUnionI): 

313 payload3 = a.value 

314 variant4 = 1 

315 variant5 = _clamp(payload3, -2147483648, 2147483647) 

316 variant6 = 0 

317 else: 

318 raise TypeError("invalid variant specified for OptionInUnion") 

319 ret = self.component.lift_callee3(caller, variant4, variant5, variant6) 

320 assert(isinstance(ret, int)) 

321 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

322 variant10: OptionInUnion 

323 if load == 0: 

324 load7 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 4) 

325 option: Optional[int] 

326 if load7 == 0: 

327 option = None 

328 elif load7 == 1: 

329 load8 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 8) 

330 option = load8 

331 else: 

332 raise TypeError("invalid variant discriminant for option") 

333 variant10 = OptionInUnionO(option) 

334 elif load == 1: 

335 load9 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4) 

336 variant10 = OptionInUnionI(load9) 

337 else: 

338 raise TypeError("invalid variant discriminant for OptionInUnion") 

339 tmp = variant10 

340 return tmp 

341 def add_one_all_floats(self, caller: wasmtime.Store, a: AllFloats) -> AllFloats: 

342 if isinstance(a, AllFloatsF32): 

343 payload = a.value 

344 variant = 0 

345 variant1 = _f32_to_i32(payload) 

346 elif isinstance(a, AllFloatsF64): 

347 payload0 = a.value 

348 variant = 1 

349 variant1 = _f64_to_i64(payload0) 

350 else: 

351 raise TypeError("invalid variant specified for AllFloats") 

352 ret = self.component.lift_callee4(caller, variant, variant1) 

353 assert(isinstance(ret, int)) 

354 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

355 variant4: AllFloats 

356 if load == 0: 

357 load2 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 8) 

358 variant4 = AllFloatsF32(load2) 

359 elif load == 1: 

360 load3 = _load(ctypes.c_double, self.component._core_memory0, caller, ret, 8) 

361 variant4 = AllFloatsF64(load3) 

362 else: 

363 raise TypeError("invalid variant discriminant for AllFloats") 

364 tmp = variant4 

365 return tmp 

366 def add_one_duplicated_s32(self, caller: wasmtime.Store, a: DuplicatedS32) -> DuplicatedS32: 

367 if isinstance(a, DuplicatedS32C1): 

368 payload = a.value 

369 variant = 0 

370 variant2 = _clamp(payload, -2147483648, 2147483647) 

371 elif isinstance(a, DuplicatedS32C2): 

372 payload0 = a.value 

373 variant = 1 

374 variant2 = _clamp(payload0, -2147483648, 2147483647) 

375 elif isinstance(a, DuplicatedS32C3): 

376 payload1 = a.value 

377 variant = 2 

378 variant2 = _clamp(payload1, -2147483648, 2147483647) 

379 else: 

380 raise TypeError("invalid variant specified for DuplicatedS32") 

381 ret = self.component.lift_callee5(caller, variant, variant2) 

382 assert(isinstance(ret, int)) 

383 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

384 variant6: DuplicatedS32 

385 if load == 0: 

386 load3 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4) 

387 variant6 = DuplicatedS32C1(load3) 

388 elif load == 1: 

389 load4 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4) 

390 variant6 = DuplicatedS32C2(load4) 

391 elif load == 2: 

392 load5 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4) 

393 variant6 = DuplicatedS32C3(load5) 

394 else: 

395 raise TypeError("invalid variant discriminant for DuplicatedS32") 

396 tmp = variant6 

397 return tmp 

398 def add_one_distinguished(self, caller: wasmtime.Store, a: Distinguished) -> Distinguished: 

399 if isinstance(a, DistinguishedS32): 

400 payload = a.value 

401 variant = 0 

402 variant1 = _clamp(payload, -2147483648, 2147483647) 

403 elif isinstance(a, DistinguishedFloat32): 

404 payload0 = a.value 

405 variant = 1 

406 variant1 = _f32_to_i32(payload0) 

407 else: 

408 raise TypeError("invalid variant specified for Distinguished") 

409 ret = self.component.lift_callee6(caller, variant, variant1) 

410 assert(isinstance(ret, int)) 

411 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

412 variant4: Distinguished 

413 if load == 0: 

414 load2 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4) 

415 variant4 = DistinguishedS32(load2) 

416 elif load == 1: 

417 load3 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 4) 

418 variant4 = DistinguishedFloat32(load3) 

419 else: 

420 raise TypeError("invalid variant discriminant for Distinguished") 

421 tmp = variant4 

422 return tmp 

423 def variant_casts(self, caller: wasmtime.Store, a: Casts) -> Casts: 

424 (tuplei,tuplei0,tuplei1,tuplei2,tuplei3,tuplei4,) = a 

425 if isinstance(tuplei, C1A): 

426 payload = tuplei.value 

427 variant = 0 

428 variant6 = _clamp(payload, -2147483648, 2147483647) 

429 elif isinstance(tuplei, C1B): 

430 payload5 = tuplei.value 

431 variant = 1 

432 variant6 = _clamp(payload5, -9223372036854775808, 9223372036854775807) 

433 else: 

434 raise TypeError("invalid variant specified for C1") 

435 if isinstance(tuplei0, C2A): 

436 payload7 = tuplei0.value 

437 variant9 = 0 

438 variant10 = _clamp(payload7, -2147483648, 2147483647) 

439 elif isinstance(tuplei0, C2B): 

440 payload8 = tuplei0.value 

441 variant9 = 1 

442 variant10 = _f32_to_i32(payload8) 

443 else: 

444 raise TypeError("invalid variant specified for C2") 

445 if isinstance(tuplei1, C3A): 

446 payload11 = tuplei1.value 

447 variant13 = 0 

448 variant14 = _clamp(payload11, -2147483648, 2147483647) 

449 elif isinstance(tuplei1, C3B): 

450 payload12 = tuplei1.value 

451 variant13 = 1 

452 variant14 = _f64_to_i64(payload12) 

453 else: 

454 raise TypeError("invalid variant specified for C3") 

455 if isinstance(tuplei2, C4A): 

456 payload15 = tuplei2.value 

457 variant17 = 0 

458 variant18 = _clamp(payload15, -9223372036854775808, 9223372036854775807) 

459 elif isinstance(tuplei2, C4B): 

460 payload16 = tuplei2.value 

461 variant17 = 1 

462 variant18 = _f32_to_i32(payload16) 

463 else: 

464 raise TypeError("invalid variant specified for C4") 

465 if isinstance(tuplei3, C5A): 

466 payload19 = tuplei3.value 

467 variant21 = 0 

468 variant22 = _clamp(payload19, -9223372036854775808, 9223372036854775807) 

469 elif isinstance(tuplei3, C5B): 

470 payload20 = tuplei3.value 

471 variant21 = 1 

472 variant22 = _f64_to_i64(payload20) 

473 else: 

474 raise TypeError("invalid variant specified for C5") 

475 if isinstance(tuplei4, C6A): 

476 payload23 = tuplei4.value 

477 variant25 = 0 

478 variant26 = _f32_to_i32(payload23) 

479 elif isinstance(tuplei4, C6B): 

480 payload24 = tuplei4.value 

481 variant25 = 1 

482 variant26 = _f64_to_i64(payload24) 

483 else: 

484 raise TypeError("invalid variant specified for C6") 

485 ret = self.component.lift_callee7(caller, variant, variant6, variant9, variant10, variant13, variant14, variant17, variant18, variant21, variant22, variant25, variant26) 

486 assert(isinstance(ret, int)) 

487 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

488 variant29: C1 

489 if load == 0: 

490 load27 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 8) 

491 variant29 = C1A(load27) 

492 elif load == 1: 

493 load28 = _load(ctypes.c_int64, self.component._core_memory0, caller, ret, 8) 

494 variant29 = C1B(load28) 

495 else: 

496 raise TypeError("invalid variant discriminant for C1") 

497 load30 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 16) 

498 variant33: C2 

499 if load30 == 0: 

500 load31 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 20) 

501 variant33 = C2A(load31) 

502 elif load30 == 1: 

503 load32 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 20) 

504 variant33 = C2B(load32) 

505 else: 

506 raise TypeError("invalid variant discriminant for C2") 

507 load34 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 24) 

508 variant37: C3 

509 if load34 == 0: 

510 load35 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 32) 

511 variant37 = C3A(load35) 

512 elif load34 == 1: 

513 load36 = _load(ctypes.c_double, self.component._core_memory0, caller, ret, 32) 

514 variant37 = C3B(load36) 

515 else: 

516 raise TypeError("invalid variant discriminant for C3") 

517 load38 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 40) 

518 variant41: C4 

519 if load38 == 0: 

520 load39 = _load(ctypes.c_int64, self.component._core_memory0, caller, ret, 48) 

521 variant41 = C4A(load39) 

522 elif load38 == 1: 

523 load40 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 48) 

524 variant41 = C4B(load40) 

525 else: 

526 raise TypeError("invalid variant discriminant for C4") 

527 load42 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 56) 

528 variant45: C5 

529 if load42 == 0: 

530 load43 = _load(ctypes.c_int64, self.component._core_memory0, caller, ret, 64) 

531 variant45 = C5A(load43) 

532 elif load42 == 1: 

533 load44 = _load(ctypes.c_double, self.component._core_memory0, caller, ret, 64) 

534 variant45 = C5B(load44) 

535 else: 

536 raise TypeError("invalid variant discriminant for C5") 

537 load46 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 72) 

538 variant49: C6 

539 if load46 == 0: 

540 load47 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 80) 

541 variant49 = C6A(load47) 

542 elif load46 == 1: 

543 load48 = _load(ctypes.c_double, self.component._core_memory0, caller, ret, 80) 

544 variant49 = C6B(load48) 

545 else: 

546 raise TypeError("invalid variant discriminant for C6") 

547 tmp = (variant29, variant33, variant37, variant41, variant45, variant49,) 

548 return tmp 

549 def variant_zeros(self, caller: wasmtime.Store, a: Zeros) -> Zeros: 

550 (tuplei,tuplei0,tuplei1,tuplei2,) = a 

551 if isinstance(tuplei, Z1A): 

552 payload = tuplei.value 

553 variant = 0 

554 variant4 = _clamp(payload, -2147483648, 2147483647) 

555 elif isinstance(tuplei, Z1B): 

556 variant = 1 

557 variant4 = 0 

558 else: 

559 raise TypeError("invalid variant specified for Z1") 

560 if isinstance(tuplei0, Z2A): 

561 payload5 = tuplei0.value 

562 variant7 = 0 

563 variant8 = _clamp(payload5, -9223372036854775808, 9223372036854775807) 

564 elif isinstance(tuplei0, Z2B): 

565 variant7 = 1 

566 variant8 = 0 

567 else: 

568 raise TypeError("invalid variant specified for Z2") 

569 if isinstance(tuplei1, Z3A): 

570 payload9 = tuplei1.value 

571 variant11 = 0 

572 variant12 = payload9 

573 elif isinstance(tuplei1, Z3B): 

574 variant11 = 1 

575 variant12 = 0.0 

576 else: 

577 raise TypeError("invalid variant specified for Z3") 

578 if isinstance(tuplei2, Z4A): 

579 payload13 = tuplei2.value 

580 variant15 = 0 

581 variant16 = payload13 

582 elif isinstance(tuplei2, Z4B): 

583 variant15 = 1 

584 variant16 = 0.0 

585 else: 

586 raise TypeError("invalid variant specified for Z4") 

587 ret = self.component.lift_callee8(caller, variant, variant4, variant7, variant8, variant11, variant12, variant15, variant16) 

588 assert(isinstance(ret, int)) 

589 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

590 variant18: Z1 

591 if load == 0: 

592 load17 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4) 

593 variant18 = Z1A(load17) 

594 elif load == 1: 

595 variant18 = Z1B() 

596 else: 

597 raise TypeError("invalid variant discriminant for Z1") 

598 load19 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 8) 

599 variant21: Z2 

600 if load19 == 0: 

601 load20 = _load(ctypes.c_int64, self.component._core_memory0, caller, ret, 16) 

602 variant21 = Z2A(load20) 

603 elif load19 == 1: 

604 variant21 = Z2B() 

605 else: 

606 raise TypeError("invalid variant discriminant for Z2") 

607 load22 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 24) 

608 variant24: Z3 

609 if load22 == 0: 

610 load23 = _load(ctypes.c_float, self.component._core_memory0, caller, ret, 28) 

611 variant24 = Z3A(load23) 

612 elif load22 == 1: 

613 variant24 = Z3B() 

614 else: 

615 raise TypeError("invalid variant discriminant for Z3") 

616 load25 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 32) 

617 variant27: Z4 

618 if load25 == 0: 

619 load26 = _load(ctypes.c_double, self.component._core_memory0, caller, ret, 40) 

620 variant27 = Z4A(load26) 

621 elif load25 == 1: 

622 variant27 = Z4B() 

623 else: 

624 raise TypeError("invalid variant discriminant for Z4") 

625 tmp = (variant18, variant21, variant24, variant27,) 

626 return tmp 

627 def add_one_all_integers(self, caller: wasmtime.Store, a: AllIntegers) -> AllIntegers: 

628 if isinstance(a, AllIntegersBool): 

629 payload = a.value 

630 variant = 0 

631 variant8 = int(payload) 

632 elif isinstance(a, AllIntegersU8): 

633 payload0 = a.value 

634 variant = 1 

635 variant8 = _clamp(payload0, 0, 255) 

636 elif isinstance(a, AllIntegersU16): 

637 payload1 = a.value 

638 variant = 2 

639 variant8 = _clamp(payload1, 0, 65535) 

640 elif isinstance(a, AllIntegersU32): 

641 payload2 = a.value 

642 variant = 3 

643 variant8 = _clamp(payload2, 0, 4294967295) 

644 elif isinstance(a, AllIntegersU64): 

645 payload3 = a.value 

646 variant = 4 

647 variant8 = _clamp(payload3, 0, 18446744073709551615) 

648 elif isinstance(a, AllIntegersS8): 

649 payload4 = a.value 

650 variant = 5 

651 variant8 = _clamp(payload4, -128, 127) 

652 elif isinstance(a, AllIntegersS16): 

653 payload5 = a.value 

654 variant = 6 

655 variant8 = _clamp(payload5, -32768, 32767) 

656 elif isinstance(a, AllIntegersS32): 

657 payload6 = a.value 

658 variant = 7 

659 variant8 = _clamp(payload6, -2147483648, 2147483647) 

660 elif isinstance(a, AllIntegersS64): 

661 payload7 = a.value 

662 variant = 8 

663 variant8 = _clamp(payload7, -9223372036854775808, 9223372036854775807) 

664 else: 

665 raise TypeError("invalid variant specified for AllIntegers") 

666 ret = self.component.lift_callee9(caller, variant, variant8) 

667 assert(isinstance(ret, int)) 

668 load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0) 

669 variant18: AllIntegers 

670 if load == 0: 

671 load9 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 8) 

672 operand = load9 

673 if operand == 0: 

674 boolean = False 

675 elif operand == 1: 

676 boolean = True 

677 else: 

678 raise TypeError("invalid variant discriminant for bool") 

679 variant18 = AllIntegersBool(boolean) 

680 elif load == 1: 

681 load10 = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 8) 

682 variant18 = AllIntegersU8(_clamp(load10, 0, 255)) 

683 elif load == 2: 

684 load11 = _load(ctypes.c_uint16, self.component._core_memory0, caller, ret, 8) 

685 variant18 = AllIntegersU16(_clamp(load11, 0, 65535)) 

686 elif load == 3: 

687 load12 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 8) 

688 variant18 = AllIntegersU32(load12 & 0xffffffff) 

689 elif load == 4: 

690 load13 = _load(ctypes.c_int64, self.component._core_memory0, caller, ret, 8) 

691 variant18 = AllIntegersU64(load13 & 0xffffffffffffffff) 

692 elif load == 5: 

693 load14 = _load(ctypes.c_int8, self.component._core_memory0, caller, ret, 8) 

694 variant18 = AllIntegersS8(_clamp(load14, -128, 127)) 

695 elif load == 6: 

696 load15 = _load(ctypes.c_int16, self.component._core_memory0, caller, ret, 8) 

697 variant18 = AllIntegersS16(_clamp(load15, -32768, 32767)) 

698 elif load == 7: 

699 load16 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 8) 

700 variant18 = AllIntegersS32(load16) 

701 elif load == 8: 

702 load17 = _load(ctypes.c_int64, self.component._core_memory0, caller, ret, 8) 

703 variant18 = AllIntegersS64(load17) 

704 else: 

705 raise TypeError("invalid variant discriminant for AllIntegers") 

706 tmp = variant18 

707 return tmp 

708 def add_one_option_in_option(self, caller: wasmtime.Store, a: Optional[Some[Optional[int]]]) -> Optional[Some[Optional[int]]]: 

709 if a is None: 

710 variant4 = 0 

711 variant5 = 0 

712 variant6 = 0 

713 else: 

714 payload0 = a.value 

715 if payload0 is None: 

716 variant = 0 

717 variant3 = 0 

718 else: 

719 payload2 = payload0 

720 variant = 1 

721 variant3 = _clamp(payload2, -2147483648, 2147483647) 

722 variant4 = 1 

723 variant5 = variant 

724 variant6 = variant3 

725 ret = self.component.lift_callee10(caller, variant4, variant5, variant6)