Tidy CABI: renaming 'results' to 'result' when it's 0-or-1

Author: lukewagner

design/mvp/CanonicalABI.md

@@ -973,11 +973,11 @@ dropped all borrowed handles by the time `task.return` is called which means
 that the caller can assume that all its lent handles have been returned to it
 when it receives the `SUBTASK` `RETURNED` event.
 ```python
-  def return_(self, results):
+  def return_(self, result):
     trap_if(self.state == Task.State.RESOLVED)
     trap_if(self.num_borrows > 0)
-    assert(results is not None)
-    self.on_resolve(results)
+    assert(result is not None)
+    self.on_resolve(result)
     self.state = Task.State.RESOLVED
 ```
 
@@ -1061,11 +1061,11 @@ transitions:
       self.state = Subtask.State.STARTED
       return on_start()
 
-    def sync_on_resolve(results):
-      assert(results is not None)
+    def sync_on_resolve(result):
+      assert(result is not None)
       assert(self.state == Subtask.State.STARTED)
       self.state = Subtask.State.RETURNED
-      on_resolve(results)
+      on_resolve(result)
 
     await Task.call_sync(self.supertask, callee, sync_on_start, sync_on_resolve)
 ```
@@ -1114,8 +1114,8 @@ cancellation:
       self.state = Subtask.State.STARTED
       return on_start()
 
-    def async_on_resolve(results):
-      if results is None:
+    def async_on_resolve(result):
+      if result is None:
         if self.state == Subtask.State.STARTING:
           self.state = Subtask.State.CANCELLED_BEFORE_STARTED
         else:
@@ -1124,7 +1124,7 @@ cancellation:
       else:
         assert(self.state == Subtask.State.STARTED)
         self.state = Subtask.State.RETURNED
-      on_resolve(results)
+      on_resolve(result)
 
     async def async_on_block(awaitable):
       relinquish_control()
@@ -1690,7 +1690,7 @@ def contains(t, p):
     case VariantType(cases):
       return p(t) or any(contains(c.t, p) for c in cases)
     case FuncType():
-      return any(p(u) for u in t.param_types() + t.result_types())
+      return any(p(u) for u in t.param_types() + t.result_type())
     case _:
       assert(False)
 ```
@@ -2595,7 +2595,7 @@ MAX_FLAT_RESULTS = 1
 
 def flatten_functype(opts, ft, context):
   flat_params = flatten_types(ft.param_types())
-  flat_results = flatten_types(ft.result_types())
+  flat_results = flatten_types(ft.result_type())
   if opts.sync:
     if len(flat_params) > MAX_FLAT_PARAMS:
       flat_params = ['i32']
@@ -3067,7 +3067,7 @@ validation is performed:
 * requires options based on [`lift(param)`](#canonopt-validation) for all parameters in `ft`
 * requires options based on [`lower(result)`](#canonopt-validation) if `ft` has a result
 * if `len(flatten_types(ft.param_types())) > MAX_FLAT_PARAMS`, `realloc` is required
-* if `len(flatten_types(ft.result_types())) > MAX_FLAT_RESULTS`, `memory` is required
+* if `len(flatten_types(ft.result_type())) > MAX_FLAT_RESULTS`, `memory` is required
 
 When instantiating component instance `$inst`:
 * Define `$f` to be the partially-bound closure `canon_lift($opts, $inst, $ft, $callee)`
@@ -3114,8 +3114,8 @@ with compound return values.
   if opts.sync:
     flat_results = await call_and_trap_on_throw(callee, task, flat_args)
     assert(types_match_values(flat_ft.results, flat_results))
-    results = lift_flat_values(cx, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_types())
-    task.return_(results)
+    result = lift_flat_values(cx, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_type())
+    task.return_(result)
     if opts.post_return is not None:
       task.inst.may_leave = False
       [] = await call_and_trap_on_throw(opts.post_return, task, flat_results)
@@ -3218,7 +3218,7 @@ validation is performed where `$callee` has type `$ft`:
 * requires options [based on `lower(param)`](#canonopt-validation) for all parameters in `ft`
 * requires options [based on `lift(result)`](#canonopt-validation) if `ft` has a result
 * if `len(flatten_types(ft.param_types())) > max_flat_params`, `memory` is required
-* if `len(flatten_types(ft.result_types())) > max_flat_results`, `realloc` is required
+* if `len(flatten_types(ft.result_type())) > max_flat_results`, `realloc` is required
 * 🔀 if `async` is specified, `memory` must be present
 
 When instantiating component instance `$inst`:
@@ -3252,9 +3252,9 @@ In the synchronous case, `Subtask.call_sync` ensures a fully-synchronous call to
       return lift_flat_values(cx, MAX_FLAT_PARAMS, flat_args, ft.param_types())
 
     flat_results = None
-    def on_resolve(results):
+    def on_resolve(result):
       nonlocal flat_results
-      flat_results = lower_flat_values(cx, MAX_FLAT_RESULTS, results, ft.result_types(), flat_args)
+      flat_results = lower_flat_values(cx, MAX_FLAT_RESULTS, result, ft.result_type(), flat_args)
 
     await subtask.call_sync(callee, on_start, on_resolve)
     assert(types_match_values(flat_ft.results, flat_results))
@@ -3269,10 +3269,10 @@ always returns control flow back to the caller without blocking:
     on_progress()
     return lift_flat_values(cx, MAX_FLAT_ASYNC_PARAMS, flat_args, ft.param_types())
 
-  def on_resolve(results):
+  def on_resolve(result):
     on_progress()
-    if results is not None:
-      [] = lower_flat_values(cx, 0, results, ft.result_types(), flat_args)
+    if result is not None:
+      [] = lower_flat_values(cx, 0, result, ft.result_type(), flat_args)
 
   subtaski = None
   def on_progress():
@@ -3494,8 +3494,8 @@ async def canon_task_return(task, result_type, opts: LiftOptions, flat_args):
   trap_if(result_type != task.ft.results)
   trap_if(not LiftOptions.equal(opts, task.opts))
   cx = LiftLowerContext(opts, task.inst, task)
-  results = lift_flat_values(cx, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_types())
-  task.return_(results)
+  result = lift_flat_values(cx, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_type())
+  task.return_(result)
   return []
 ```
 The `trap_if(task.opts.sync)` prevents `task.return` from being called by

design/mvp/canonical-abi/definitions.py

@@ -88,7 +88,7 @@ class FuncType(ExternType):
   results: list[ValType|tuple[str,ValType]]
   def param_types(self):
     return self.extract_types(self.params)
-  def result_types(self):
+  def result_type(self):
     return self.extract_types(self.results)
   def extract_types(self, vec):
     if len(vec) == 0:
@@ -606,11 +606,11 @@ async def poll_for_event(self, waitable_set, sync) -> Optional[EventTuple]:
     else:
       return (EventCode.NONE, 0, 0)
 
-  def return_(self, results):
+  def return_(self, result):
     trap_if(self.state == Task.State.RESOLVED)
     trap_if(self.num_borrows > 0)
-    assert(results is not None)
-    self.on_resolve(results)
+    assert(result is not None)
+    self.on_resolve(result)
     self.state = Task.State.RESOLVED
 
   def cancel(self):
@@ -658,11 +658,11 @@ def sync_on_start():
       self.state = Subtask.State.STARTED
       return on_start()
 
-    def sync_on_resolve(results):
-      assert(results is not None)
+    def sync_on_resolve(result):
+      assert(result is not None)
       assert(self.state == Subtask.State.STARTED)
       self.state = Subtask.State.RETURNED
-      on_resolve(results)
+      on_resolve(result)
 
     await Task.call_sync(self.supertask, callee, sync_on_start, sync_on_resolve)
 
@@ -694,8 +694,8 @@ def async_on_start():
       self.state = Subtask.State.STARTED
       return on_start()
 
-    def async_on_resolve(results):
-      if results is None:
+    def async_on_resolve(result):
+      if result is None:
         if self.state == Subtask.State.STARTING:
           self.state = Subtask.State.CANCELLED_BEFORE_STARTED
         else:
@@ -704,7 +704,7 @@ def async_on_resolve(results):
       else:
         assert(self.state == Subtask.State.STARTED)
         self.state = Subtask.State.RETURNED
-      on_resolve(results)
+      on_resolve(result)
 
     async def async_on_block(awaitable):
       relinquish_control()
@@ -1003,7 +1003,7 @@ def contains(t, p):
     case VariantType(cases):
       return p(t) or any(contains(c.t, p) for c in cases)
     case FuncType():
-      return any(p(u) for u in t.param_types() + t.result_types())
+      return any(p(u) for u in t.param_types() + t.result_type())
     case _:
       assert(False)
 
@@ -1619,7 +1619,7 @@ def lower_future(cx, v, t):
 
 def flatten_functype(opts, ft, context):
   flat_params = flatten_types(ft.param_types())
-  flat_results = flatten_types(ft.result_types())
+  flat_results = flatten_types(ft.result_type())
   if opts.sync:
     if len(flat_params) > MAX_FLAT_PARAMS:
       flat_params = ['i32']
@@ -1940,8 +1940,8 @@ async def canon_lift(opts, inst, ft, callee, caller, on_start, on_resolve, on_bl
   if opts.sync:
     flat_results = await call_and_trap_on_throw(callee, task, flat_args)
     assert(types_match_values(flat_ft.results, flat_results))
-    results = lift_flat_values(cx, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_types())
-    task.return_(results)
+    result = lift_flat_values(cx, MAX_FLAT_RESULTS, CoreValueIter(flat_results), ft.result_type())
+    task.return_(result)
     if opts.post_return is not None:
       task.inst.may_leave = False
       [] = await call_and_trap_on_throw(opts.post_return, task, flat_results)
@@ -2011,9 +2011,9 @@ def on_start():
       return lift_flat_values(cx, MAX_FLAT_PARAMS, flat_args, ft.param_types())
 
     flat_results = None
-    def on_resolve(results):
+    def on_resolve(result):
       nonlocal flat_results
-      flat_results = lower_flat_values(cx, MAX_FLAT_RESULTS, results, ft.result_types(), flat_args)
+      flat_results = lower_flat_values(cx, MAX_FLAT_RESULTS, result, ft.result_type(), flat_args)
 
     await subtask.call_sync(callee, on_start, on_resolve)
     assert(types_match_values(flat_ft.results, flat_results))
@@ -2024,10 +2024,10 @@ def on_start():
     on_progress()
     return lift_flat_values(cx, MAX_FLAT_ASYNC_PARAMS, flat_args, ft.param_types())
 
-  def on_resolve(results):
+  def on_resolve(result):
     on_progress()
-    if results is not None:
-      [] = lower_flat_values(cx, 0, results, ft.result_types(), flat_args)
+    if result is not None:
+      [] = lower_flat_values(cx, 0, result, ft.result_type(), flat_args)
 
   subtaski = None
   def on_progress():
@@ -2122,8 +2122,8 @@ async def canon_task_return(task, result_type, opts: LiftOptions, flat_args):
   trap_if(result_type != task.ft.results)
   trap_if(not LiftOptions.equal(opts, task.opts))
   cx = LiftLowerContext(opts, task.inst, task)
-  results = lift_flat_values(cx, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_types())
-  task.return_(results)
+  result = lift_flat_values(cx, MAX_FLAT_PARAMS, CoreValueIter(flat_args), task.ft.result_type())
+  task.return_(result)
   return []
 
 ### 🔀 `canon task.cancel`