Change context_get and context_set

Author: TartanLlama

crates/c/src/lib.rs

@@ -772,8 +772,10 @@ typedef enum {snake}_waitable_state {{
 
 void {snake}_backpressure_inc(void);
 void {snake}_backpressure_dec(void);
-void* {snake}_context_get(size_t index);
-void {snake}_context_set(size_t index, void* value);
+void* {snake}_context_get_0(void);
+void {snake}_context_set_0(void* value);
+void* {snake}_context_get_1(void);
+void {snake}_context_set_1(void* value);
 void {snake}_thread_yield(void);
 uint32_t {snake}_thread_yield_cancellable(void);
 uint32_t {snake}_thread_index(void);
@@ -865,10 +867,12 @@ extern void* __context_get_0(void);
 __attribute__((__import_module__("$root"), __import_name__("[context-get-1]")))
 extern void* __context_get_1(void);
 
-void* {snake}_context_get(size_t index) {{
-    if (index == 0) return __context_get_0();
-    if (index == 1) return __context_get_1();
-    return NULL;
+void* {snake}_context_get_0(void) {{
+    return __context_get_0();
+}}
+
+void* {snake}_context_get_1(void) {{
+    return __context_get_1();
 }}
 
 __attribute__((__import_module__("$root"), __import_name__("[context-set-0]")))
@@ -877,9 +881,12 @@ extern void __context_set_0(void*);
 __attribute__((__import_module__("$root"), __import_name__("[context-set-1]")))
 extern void __context_set_1(void*);
 
-void {snake}_context_set(size_t index, void *value) {{
-    if (index == 0) __context_set_0(value);
-    else if (index == 1) __context_set_1(value);
+void {snake}_context_set_0(void *value) {{
+    __context_set_0(value);
+}}
+
+void {snake}_context_set_1(void *value) {{
+    __context_set_1(value);
 }}
 
 __attribute__((__import_module__("$root"), __import_name__("[thread-yield]")))

tests/runtime-async/async/cancel-import/test.c

@@ -18,12 +18,12 @@ test_callback_code_t exports_test_pending_import(exports_test_future_void_t x) {
   task->set = test_waitable_set_new();
   test_waitable_join(task->future, task->set);
 
-  test_context_set(0, task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_pending_import_callback(test_event_t *event) {
-  struct my_task *task = (struct my_task*) test_context_get(0);
+  struct my_task *task = (struct my_task*) test_context_get_0();
   if (event->event == TEST_EVENT_CANCEL) {
     assert(event->waitable == 0);
     assert(event->code == 0);

tests/runtime-async/async/future-cancel-read/test.c

@@ -58,13 +58,13 @@ test_callback_code_t exports_test_start_read_then_cancel(
 
   test_waitable_join(signal, state->set);
 
-  test_context_set(0, state);
+  test_context_set_0(state);
   return TEST_CALLBACK_CODE_WAIT(state->set);
 }
 
 test_callback_code_t exports_test_start_read_then_cancel_callback(test_event_t *event) {
   struct start_read_then_cancel_state *state =
-    (struct start_read_then_cancel_state*) test_context_get(0);
+    (struct start_read_then_cancel_state*) test_context_get_0();
   assert(event->event == TEST_EVENT_FUTURE_READ);
   assert(event->waitable == state->signal);
   assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);

tests/runtime-async/async/pending-import/test.c

@@ -18,12 +18,12 @@ test_callback_code_t exports_test_pending_import(exports_test_future_void_t x) {
   task->set = test_waitable_set_new();
   test_waitable_join(task->future, task->set);
 
-  test_context_set(0, task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_pending_import_callback(test_event_t *event) {
-  struct my_task *task = (struct my_task*) test_context_get(0);
+  struct my_task *task = (struct my_task*) test_context_get_0();
   assert(event->event == TEST_EVENT_FUTURE_READ);
   assert(event->waitable == task->future);
   assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);

tests/runtime-async/async/ping-pong/test.c

@@ -33,12 +33,12 @@ test_callback_code_t exports_test_ping(exports_test_future_string_t x, test_stri
 
   // Register ourselves as waiting on the future, then block our task.
   test_waitable_join(task->future, task->set);
-  test_context_set(0, task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_ping_callback(test_event_t *event) {
-  struct ping_task *task = (struct ping_task*) test_context_get(0);
+  struct ping_task *task = (struct ping_task*) test_context_get_0();
   switch (task->state) {
     case PING_S1: {
       // Assert that our future read completed and discard the read end of the
@@ -126,12 +126,12 @@ test_callback_code_t exports_test_pong(exports_test_future_string_t x) {
   assert(status == TEST_WAITABLE_STATUS_BLOCKED);
   test_waitable_join(task->future, task->set);
 
-  test_context_set(0, task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_pong_callback(test_event_t *event) {
-  struct pong_task *task = (struct pong_task*) test_context_get(0);
+  struct pong_task *task = (struct pong_task*) test_context_get_0();
 
   // assert this event is a future read completion
   assert(event->event == TEST_EVENT_FUTURE_READ);