Revert "update future.{write,read} ABIs (bytecodealliance#2222)"

This reverts commit 95f36d2.

Alex, Luke, and I decided to scale back these changes.  I'll open a new PR next
week which reflects that discussion.

Author: dicej

crates/wasm-encoder/src/component/builder.rs

@@ -481,15 +481,15 @@ impl ComponentBuilder {
         inc(&mut self.core_funcs)
     }
 
-    /// Declares a new `stream.drop-readable` intrinsic.
-    pub fn stream_drop_readable(&mut self, ty: u32) -> u32 {
-        self.canonical_functions().stream_drop_readable(ty);
+    /// Declares a new `stream.close-readable` intrinsic.
+    pub fn stream_close_readable(&mut self, ty: u32) -> u32 {
+        self.canonical_functions().stream_close_readable(ty);
         inc(&mut self.core_funcs)
     }
 
-    /// Declares a new `stream.drop-writable` intrinsic.
-    pub fn stream_drop_writable(&mut self, ty: u32) -> u32 {
-        self.canonical_functions().stream_drop_writable(ty);
+    /// Declares a new `stream.close-writable` intrinsic.
+    pub fn stream_close_writable(&mut self, ty: u32) -> u32 {
+        self.canonical_functions().stream_close_writable(ty);
         inc(&mut self.core_funcs)
     }
 
@@ -531,15 +531,15 @@ impl ComponentBuilder {
         inc(&mut self.core_funcs)
     }
 
-    /// Declares a new `future.drop-readable` intrinsic.
-    pub fn future_drop_readable(&mut self, ty: u32) -> u32 {
-        self.canonical_functions().future_drop_readable(ty);
+    /// Declares a new `future.close-readable` intrinsic.
+    pub fn future_close_readable(&mut self, ty: u32) -> u32 {
+        self.canonical_functions().future_close_readable(ty);
         inc(&mut self.core_funcs)
     }
 
-    /// Declares a new `future.drop-writable` intrinsic.
-    pub fn future_drop_writable(&mut self, ty: u32) -> u32 {
-        self.canonical_functions().future_drop_writable(ty);
+    /// Declares a new `future.close-writable` intrinsic.
+    pub fn future_close_writable(&mut self, ty: u32) -> u32 {
+        self.canonical_functions().future_close_writable(ty);
         inc(&mut self.core_funcs)
     }
 

crates/wasm-encoder/src/component/canonicals.rs

@@ -327,18 +327,18 @@ impl CanonicalFunctionSection {
         self
     }
 
-    /// Defines a function to drop the readable end of a `stream` of the
+    /// Defines a function to close the readable end of a `stream` of the
     /// specified type.
-    pub fn stream_drop_readable(&mut self, ty: u32) -> &mut Self {
+    pub fn stream_close_readable(&mut self, ty: u32) -> &mut Self {
         self.bytes.push(0x13);
         ty.encode(&mut self.bytes);
         self.num_added += 1;
         self
     }
 
-    /// Defines a function to drop the writable end of a `stream` of the
+    /// Defines a function to close the writable end of a `stream` of the
     /// specified type.
-    pub fn stream_drop_writable(&mut self, ty: u32) -> &mut Self {
+    pub fn stream_close_writable(&mut self, ty: u32) -> &mut Self {
         self.bytes.push(0x14);
         ty.encode(&mut self.bytes);
         self.num_added += 1;
@@ -400,18 +400,18 @@ impl CanonicalFunctionSection {
         self
     }
 
-    /// Defines a function to drop the readable end of a `future` of the
+    /// Defines a function to close the readable end of a `future` of the
     /// specified type.
-    pub fn future_drop_readable(&mut self, ty: u32) -> &mut Self {
+    pub fn future_close_readable(&mut self, ty: u32) -> &mut Self {
         self.bytes.push(0x1a);
         ty.encode(&mut self.bytes);
         self.num_added += 1;
         self
     }
 
-    /// Defines a function to drop the writable end of a `future` of the
+    /// Defines a function to close the writable end of a `future` of the
     /// specified type.
-    pub fn future_drop_writable(&mut self, ty: u32) -> &mut Self {
+    pub fn future_close_writable(&mut self, ty: u32) -> &mut Self {
         self.bytes.push(0x1b);
         ty.encode(&mut self.bytes);
         self.num_added += 1;

crates/wasm-encoder/src/reencode/component.rs

@@ -436,7 +436,7 @@ pub mod component_utils {
                 ..
             } => (),
             wasmparser::Payload::Version { .. } => {
-                return Err(Error::UnexpectedNonComponentSection);
+                return Err(Error::UnexpectedNonComponentSection)
             }
             wasmparser::Payload::TypeSection(_)
             | wasmparser::Payload::ImportSection(_)
@@ -452,7 +452,7 @@ pub mod component_utils {
             | wasmparser::Payload::DataSection(_)
             | wasmparser::Payload::CodeSectionStart { .. }
             | wasmparser::Payload::CodeSectionEntry(_) => {
-                return Err(Error::UnexpectedNonComponentSection);
+                return Err(Error::UnexpectedNonComponentSection)
             }
             wasmparser::Payload::ComponentTypeSection(section) => {
                 let mut types = crate::ComponentTypeSection::new();
@@ -1027,11 +1027,11 @@ pub mod component_utils {
             wasmparser::CanonicalFunction::StreamCancelWrite { ty, async_ } => {
                 section.stream_cancel_write(ty, async_);
             }
-            wasmparser::CanonicalFunction::StreamDropReadable { ty } => {
-                section.stream_drop_readable(reencoder.component_type_index(ty));
+            wasmparser::CanonicalFunction::StreamCloseReadable { ty } => {
+                section.stream_close_readable(reencoder.component_type_index(ty));
             }
-            wasmparser::CanonicalFunction::StreamDropWritable { ty } => {
-                section.stream_drop_writable(reencoder.component_type_index(ty));
+            wasmparser::CanonicalFunction::StreamCloseWritable { ty } => {
+                section.stream_close_writable(reencoder.component_type_index(ty));
             }
             wasmparser::CanonicalFunction::FutureNew { ty } => {
                 section.future_new(reencoder.component_type_index(ty));
@@ -1056,11 +1056,11 @@ pub mod component_utils {
             wasmparser::CanonicalFunction::FutureCancelWrite { ty, async_ } => {
                 section.future_cancel_write(ty, async_);
             }
-            wasmparser::CanonicalFunction::FutureDropReadable { ty } => {
-                section.future_drop_readable(reencoder.component_type_index(ty));
+            wasmparser::CanonicalFunction::FutureCloseReadable { ty } => {
+                section.future_close_readable(reencoder.component_type_index(ty));
             }
-            wasmparser::CanonicalFunction::FutureDropWritable { ty } => {
-                section.future_drop_writable(reencoder.component_type_index(ty));
+            wasmparser::CanonicalFunction::FutureCloseWritable { ty } => {
+                section.future_close_writable(reencoder.component_type_index(ty));
             }
             wasmparser::CanonicalFunction::ErrorContextNew { options } => {
                 let options = options

crates/wasm-wave/Cargo.toml

@@ -11,9 +11,6 @@ categories = ["wasm", "encoding", "parser-implementations"]
 repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasm-wave"
 readme = "README.md"
 
-[lints]
-workspace = true
-
 [features]
 default = ["wit"]
 wit = ["dep:wit-parser"]

crates/wasmparser/src/readers/component/canonicals.rs

@@ -161,15 +161,15 @@ pub enum CanonicalFunction {
         /// `BLOCKED`.
         async_: bool,
     },
-    /// A function to drop the readable end of a `stream` of the specified
+    /// A function to close the readable end of a `stream` of the specified
     /// type.
-    StreamDropReadable {
+    StreamCloseReadable {
         /// The `stream` type to expect.
         ty: u32,
     },
-    /// A function to drop the writable end of a `stream` of the specified
+    /// A function to close the writable end of a `stream` of the specified
     /// type.
-    StreamDropWritable {
+    StreamCloseWritable {
         /// The `stream` type to expect.
         ty: u32,
     },
@@ -212,15 +212,15 @@ pub enum CanonicalFunction {
         /// `BLOCKED`.
         async_: bool,
     },
-    /// A function to drop the readable end of a `future` of the specified
+    /// A function to close the readable end of a `future` of the specified
     /// type.
-    FutureDropReadable {
+    FutureCloseReadable {
         /// The `future` type to expect.
         ty: u32,
     },
-    /// A function to drop the writable end of a `future` of the specified
+    /// A function to close the writable end of a `future` of the specified
     /// type.
-    FutureDropWritable {
+    FutureCloseWritable {
         /// The `future` type to expect.
         ty: u32,
     },
@@ -331,8 +331,8 @@ impl<'a> FromReader<'a> for CanonicalFunction {
                 ty: reader.read()?,
                 async_: reader.read()?,
             },
-            0x13 => CanonicalFunction::StreamDropReadable { ty: reader.read()? },
-            0x14 => CanonicalFunction::StreamDropWritable { ty: reader.read()? },
+            0x13 => CanonicalFunction::StreamCloseReadable { ty: reader.read()? },
+            0x14 => CanonicalFunction::StreamCloseWritable { ty: reader.read()? },
             0x15 => CanonicalFunction::FutureNew { ty: reader.read()? },
             0x16 => CanonicalFunction::FutureRead {
                 ty: reader.read()?,
@@ -350,8 +350,8 @@ impl<'a> FromReader<'a> for CanonicalFunction {
                 ty: reader.read()?,
                 async_: reader.read()?,
             },
-            0x1a => CanonicalFunction::FutureDropReadable { ty: reader.read()? },
-            0x1b => CanonicalFunction::FutureDropWritable { ty: reader.read()? },
+            0x1a => CanonicalFunction::FutureCloseReadable { ty: reader.read()? },
+            0x1b => CanonicalFunction::FutureCloseWritable { ty: reader.read()? },
             0x1c => CanonicalFunction::ErrorContextNew {
                 options: read_opts(reader)?,
             },