wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/src/bindgen.rs

@@ -1,316 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use syn::parse::{Error, Parse, ParseStream, Result};
-use syn::punctuated::Punctuated;
-use syn::{braced, token, Ident, Token};
-use wasmtime_wit_bindgen::{Opts, TrappableError};
-use wit_parser::{PackageId, Resolve, UnresolvedPackage, WorldId};
-
-pub struct Config {
-    opts: Opts,
-    resolve: Resolve,
-    world: WorldId,
-    files: Vec<PathBuf>,
-}
-
-pub fn expand(input: &Config) -> Result<TokenStream> {
-    if !cfg!(feature = "async") && input.opts.async_ {
-        return Err(Error::new(
-            Span::call_site(),
-            "cannot enable async bindings unless `async` crate feature is active",
-        ));
-    }
-
-    let src = input.opts.generate(&input.resolve, input.world);
-    let mut contents = src.parse::<TokenStream>().unwrap();
-
-    // Include a dummy `include_str!` for any files we read so rustc knows that
-    // we depend on the contents of those files.
-    for file in input.files.iter() {
-        contents.extend(
-            format!("const _: &str = include_str!(r#\"{}\"#);\n", file.display())
-                .parse::<TokenStream>()
-                .unwrap(),
-        );
-    }
-
-    Ok(contents)
-}
-
-impl Parse for Config {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let call_site = Span::call_site();
-        let mut opts = Opts::default();
-        let mut world = None;
-        let mut inline = None;
-        let mut path = None;
-
-        if input.peek(token::Brace) {
-            let content;
-            syn::braced!(content in input);
-            let fields = Punctuated::<Opt, Token![,]>::parse_terminated(&content)?;
-            for field in fields.into_pairs() {
-                match field.into_value() {
-                    Opt::Path(s) => {
-                        if path.is_some() {
-                            return Err(Error::new(s.span(), "cannot specify second path"));
-                        }
-                        path = Some(s.value());
-                    }
-                    Opt::World(s) => {
-                        if world.is_some() {
-                            return Err(Error::new(s.span(), "cannot specify second world"));
-                        }
-                        world = Some(s.value());
-                    }
-                    Opt::Inline(s) => {
-                        if inline.is_some() {
-                            return Err(Error::new(s.span(), "cannot specify second source"));
-                        }
-                        inline = Some(s.value());
-                    }
-                    Opt::Tracing(val) => opts.tracing = val,
-                    Opt::Async(val) => opts.async_ = val,
-                    Opt::TrappableErrorType(val) => opts.trappable_error_type = val,
-                    Opt::DuplicateIfNecessary(val) => opts.duplicate_if_necessary = val,
-                    Opt::Interfaces(s) => {
-                        if inline.is_some() {
-                            return Err(Error::new(s.span(), "cannot specify a second source"));
-                        }
-                        inline = Some(format!("default world interfaces {{ {} }}", s.value()));
-
-                        if world.is_some() {
-                            return Err(Error::new(
-                                s.span(),
-                                "cannot specify a world with `interfaces`",
-                            ));
-                        }
-                        world = Some("macro-input.interfaces".to_string());
-
-                        opts.only_interfaces = true;
-                    }
-                    Opt::With(val) => opts.with.extend(val),
-                }
-            }
-        } else {
-            world = input.parse::<Option<syn::LitStr>>()?.map(|s| s.value());
-            if input.parse::<Option<syn::token::In>>()?.is_some() {
-                path = Some(input.parse::<syn::LitStr>()?.value());
-            }
-        }
-        let (resolve, pkg, files) = parse_source(&path, &inline)
-            .map_err(|err| Error::new(call_site, format!("{err:?}")))?;
-
-        let world = resolve
-            .select_world(pkg, world.as_deref())
-            .map_err(|e| Error::new(call_site, format!("{e:?}")))?;
-        Ok(Config {
-            opts,
-            resolve,
-            world,
-            files,
-        })
-    }
-}
-
-fn parse_source(
-    path: &Option<String>,
-    inline: &Option<String>,
-) -> anyhow::Result<(Resolve, PackageId, Vec<PathBuf>)> {
-    let mut resolve = Resolve::default();
-    let mut files = Vec::new();
-    let root = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
-
-    let mut parse = |resolve: &mut Resolve, path: &Path| -> anyhow::Result<_> {
-        if path.is_dir() {
-            let (pkg, sources) = resolve.push_dir(path)?;
-            files = sources;
-            Ok(pkg)
-        } else {
-            let pkg = UnresolvedPackage::parse_file(path)?;
-            files.extend(pkg.source_files().map(|s| s.to_owned()));
-            resolve.push(pkg, &Default::default())
-        }
-    };
-
-    let path_pkg = if let Some(path) = path {
-        Some(parse(&mut resolve, &root.join(&path))?)
-    } else {
-        None
-    };
-
-    let inline_pkg = if let Some(inline) = inline {
-        let deps = resolve
-            .packages
-            .iter()
-            .map(|(id, p)| (p.name.clone(), id))
-            .collect();
-
-        Some(resolve.push(
-            UnresolvedPackage::parse("macro-input".as_ref(), &inline)?,
-            &deps,
-        )?)
-    } else {
-        None
-    };
-
-    let pkg = inline_pkg
-        .or(path_pkg)
-        .map_or_else(|| parse(&mut resolve, &root.join("wit")), Ok)?;
-
-    Ok((resolve, pkg, files))
-}
-
-mod kw {
-    syn::custom_keyword!(inline);
-    syn::custom_keyword!(path);
-    syn::custom_keyword!(tracing);
-    syn::custom_keyword!(trappable_error_type);
-    syn::custom_keyword!(world);
-    syn::custom_keyword!(duplicate_if_necessary);
-    syn::custom_keyword!(interfaces);
-    syn::custom_keyword!(with);
-}
-
-enum Opt {
-    World(syn::LitStr),
-    Path(syn::LitStr),
-    Inline(syn::LitStr),
-    Tracing(bool),
-    Async(bool),
-    TrappableErrorType(Vec<TrappableError>),
-    DuplicateIfNecessary(bool),
-    Interfaces(syn::LitStr),
-    With(HashMap<String, String>),
-}
-
-impl Parse for Opt {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let l = input.lookahead1();
-        if l.peek(kw::path) {
-            input.parse::<kw::path>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::Path(input.parse()?))
-        } else if l.peek(kw::inline) {
-            input.parse::<kw::inline>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::Inline(input.parse()?))
-        } else if l.peek(kw::world) {
-            input.parse::<kw::world>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::World(input.parse()?))
-        } else if l.peek(kw::tracing) {
-            input.parse::<kw::tracing>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::Tracing(input.parse::<syn::LitBool>()?.value))
-        } else if l.peek(Token![async]) {
-            input.parse::<Token![async]>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::Async(input.parse::<syn::LitBool>()?.value))
-        } else if l.peek(kw::duplicate_if_necessary) {
-            input.parse::<kw::duplicate_if_necessary>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::DuplicateIfNecessary(
-                input.parse::<syn::LitBool>()?.value,
-            ))
-        } else if l.peek(kw::trappable_error_type) {
-            input.parse::<kw::trappable_error_type>()?;
-            input.parse::<Token![:]>()?;
-            let contents;
-            let _lbrace = braced!(contents in input);
-            let fields: Punctuated<(String, String, String), Token![,]> =
-                contents.parse_terminated(trappable_error_field_parse)?;
-            Ok(Opt::TrappableErrorType(
-                fields
-                    .into_iter()
-                    .map(|(wit_owner, wit_name, rust_name)| TrappableError {
-                        wit_owner: Some(wit_owner),
-                        wit_name,
-                        rust_name,
-                    })
-                    .collect(),
-            ))
-        } else if l.peek(kw::interfaces) {
-            input.parse::<kw::interfaces>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::Interfaces(input.parse::<syn::LitStr>()?))
-        } else if l.peek(kw::with) {
-            input.parse::<kw::with>()?;
-            input.parse::<Token![:]>()?;
-            let contents;
-            let _lbrace = braced!(contents in input);
-            let fields: Punctuated<(String, String), Token![,]> =
-                contents.parse_terminated(with_field_parse)?;
-            Ok(Opt::With(HashMap::from_iter(fields.into_iter())))
-        } else {
-            Err(l.error())
-        }
-    }
-}
-
-fn trappable_error_field_parse(input: ParseStream<'_>) -> Result<(String, String, String)> {
-    // Accept a Rust identifier or a string literal. This is required
-    // because not all wit identifiers are Rust identifiers, so we can
-    // smuggle the invalid ones inside quotes.
-    fn ident_or_str(input: ParseStream<'_>) -> Result<String> {
-        let l = input.lookahead1();
-        if l.peek(syn::LitStr) {
-            Ok(input.parse::<syn::LitStr>()?.value())
-        } else if l.peek(syn::Ident) {
-            Ok(input.parse::<syn::Ident>()?.to_string())
-        } else {
-            Err(l.error())
-        }
-    }
-
-    let interface = ident_or_str(input)?;
-    input.parse::<Token![::]>()?;
-    let type_ = ident_or_str(input)?;
-    input.parse::<Token![:]>()?;
-    let rust_type = input.parse::<Ident>()?.to_string();
-    Ok((interface, type_, rust_type))
-}
-
-fn with_field_parse(input: ParseStream<'_>) -> Result<(String, String)> {
-    let interface = input.parse::<syn::LitStr>()?.value();
-    input.parse::<Token![:]>()?;
-    let start = input.span();
-    let path = input.parse::<syn::Path>()?;
-
-    // It's not possible for the segments of a path to be empty
-    let span = start
-        .join(path.segments.last().unwrap().ident.span())
-        .unwrap_or(start);
-
-    let mut buf = String::new();
-    let append = |buf: &mut String, segment: syn::PathSegment| -> Result<()> {
-        if segment.arguments != syn::PathArguments::None {
-            return Err(Error::new(
-                span,
-                "Module path must not contain angles or parens",
-            ));
-        }
-
-        buf.push_str(&segment.ident.to_string());
-
-        Ok(())
-    };
-
-    if path.leading_colon.is_some() {
-        buf.push_str("::");
-    }
-
-    let mut segments = path.segments.into_iter();
-
-    if let Some(segment) = segments.next() {
-        append(&mut buf, segment)?;
-    }
-
-    for segment in segments {
-        buf.push_str("::");
-        append(&mut buf, segment)?;
-    }
-
-    Ok((interface, buf))
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/char.wit

@@ -1,11 +0,0 @@
-interface chars {
-  /// A function that accepts a character
-  take-char: func(x: char)
-  /// A function that returns a character
-  return-char: func() -> char
-}
-
-default world the-world {
-  import imports: self.chars
-  export exports: self.chars
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/conventions.wit

@@ -1,38 +0,0 @@
-// hello 🐱 world
-
-interface conventions {
-  kebab-case: func()
-
-  record ludicrous-speed {
-    how-fast-are-you-going: u32,
-    i-am-going-extremely-slow: u64,
-  }
-
-  foo: func(x: ludicrous-speed)
-  %function-with-dashes: func()
-  %function-with-no-weird-characters: func()
-
-  apple: func()
-  apple-pear: func()
-  apple-pear-grape: func()
-  a0: func()
-
-  // Comment out identifiers that collide when mapped to snake_case, for now; see
-  // https://github.com/WebAssembly/component-model/issues/118
-  //APPLE: func()
-  //APPLE-pear-GRAPE: func()
-  //apple-PEAR-grape: func()
-
-  is-XML: func()
-
-  %explicit: func()
-  %explicit-kebab: func()
-
-  // Identifiers with the same name as keywords are quoted.
-  %bool: func()
-}
-
-default world the-world {
-  import imports: self.conventions
-  export exports: self.conventions
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/direct-import.wit

@@ -1,3 +0,0 @@
-default world foo {
-  import foo: func()
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/empty.wit

@@ -1 +0,0 @@
-default world empty {}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/flags.wit

@@ -1,53 +0,0 @@
-interface flegs {
-  flags flag1 {
-    b0,
-  }
-
-  flags flag2 {
-    b0, b1,
-  }
-
-  flags flag4 {
-    b0, b1, b2, b3,
-  }
-
-  flags flag8 {
-    b0, b1, b2, b3, b4, b5, b6, b7,
-  }
-
-  flags flag16 {
-    b0, b1, b2, b3, b4, b5, b6, b7,
-    b8, b9, b10, b11, b12, b13, b14, b15,
-  }
-
-  flags flag32 {
-    b0, b1, b2, b3, b4, b5, b6, b7,
-    b8, b9, b10, b11, b12, b13, b14, b15,
-    b16, b17, b18, b19, b20, b21, b22, b23,
-    b24, b25, b26, b27, b28, b29, b30, b31,
-  }
-
-  flags flag64 {
-    b0, b1, b2, b3, b4, b5, b6, b7,
-    b8, b9, b10, b11, b12, b13, b14, b15,
-    b16, b17, b18, b19, b20, b21, b22, b23,
-    b24, b25, b26, b27, b28, b29, b30, b31,
-    b32, b33, b34, b35, b36, b37, b38, b39,
-    b40, b41, b42, b43, b44, b45, b46, b47,
-    b48, b49, b50, b51, b52, b53, b54, b55,
-    b56, b57, b58, b59, b60, b61, b62, b63,
-  }
-
-  roundtrip-flag1: func(x: flag1) -> flag1
-  roundtrip-flag2: func(x: flag2) -> flag2
-  roundtrip-flag4: func(x: flag4) -> flag4
-  roundtrip-flag8: func(x: flag8) -> flag8
-  roundtrip-flag16: func(x: flag16) -> flag16
-  roundtrip-flag32: func(x: flag32) -> flag32
-  roundtrip-flag64: func(x: flag64) -> flag64
-}
-
-default world the-flags {
-  import import-flags: self.flegs
-  export export-flags: self.flegs
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/floats.wit

@@ -1,11 +0,0 @@
-interface floats {
-  float32-param: func(x: float32)
-  float64-param: func(x: float64)
-  float32-result: func() -> float32
-  float64-result: func() -> float64
-}
-
-default world the-world {
-  import imports: self.floats
-  export exports: self.floats
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/function-new.wit

@@ -1,3 +0,0 @@
-default world foo {
-  export new: func()
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/integers.wit

@@ -1,38 +0,0 @@
-interface integers {
-  a1: func(x: u8)
-  a2: func(x: s8)
-  a3: func(x: u16)
-  a4: func(x: s16)
-  a5: func(x: u32)
-  a6: func(x: s32)
-  a7: func(x: u64)
-  a8: func(x: s64)
-
-  a9: func(
-    p1: u8,
-    p2: s8,
-    p3: u16,
-    p4: s16,
-    p5: u32,
-    p6: s32,
-    p7: u64,
-    p8: s64,
-  )
-
-
-  r1: func() -> u8
-  r2: func() -> s8
-  r3: func() -> u16
-  r4: func() -> s16
-  r5: func() -> u32
-  r6: func() -> s32
-  r7: func() -> u64
-  r8: func() -> s64
-
-  pair-ret: func() -> tuple<s64, u8>
-}
-
-default world the-world {
-  import imports: self.integers
-  export exports: self.integers
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/lists.wit

@@ -1,83 +0,0 @@
-interface lists {
-  list-u8-param: func(x: list<u8>)
-  list-u16-param: func(x: list<u16>)
-  list-u32-param: func(x: list<u32>)
-  list-u64-param: func(x: list<u64>)
-  list-s8-param: func(x: list<s8>)
-  list-s16-param: func(x: list<s16>)
-  list-s32-param: func(x: list<s32>)
-  list-s64-param: func(x: list<s64>)
-  list-float32-param: func(x: list<float32>)
-  list-float64-param: func(x: list<float64>)
-
-  list-u8-ret: func() -> list<u8>
-  list-u16-ret: func() -> list<u16>
-  list-u32-ret: func() -> list<u32>
-  list-u64-ret: func() -> list<u64>
-  list-s8-ret: func() -> list<s8>
-  list-s16-ret: func() -> list<s16>
-  list-s32-ret: func() -> list<s32>
-  list-s64-ret: func() -> list<s64>
-  list-float32-ret: func() -> list<float32>
-  list-float64-ret: func() -> list<float64>
-
-  tuple-list: func(x: list<tuple<u8, s8>>) -> list<tuple<s64, u32>>
-  string-list-arg: func(a: list<string>)
-  string-list-ret: func() -> list<string>
-  tuple-string-list: func(x: list<tuple<u8, string>>) -> list<tuple<string, u8>>
-  string-list: func(x: list<string>) -> list<string>
-
-  record some-record {
-    x: string,
-    y: other-record,
-    z: list<other-record>,
-    c1: u32,
-    c2: u64,
-    c3: s32,
-    c4: s64,
-  }
-  record other-record {
-    a1: u32,
-    a2: u64,
-    a3: s32,
-    a4: s64,
-    b: string,
-    c: list<u8>,
-  }
-  record-list: func(x: list<some-record>) -> list<other-record>
-  record-list-reverse: func(x: list<other-record>) -> list<some-record>
-
-  variant some-variant {
-    a(string),
-    b,
-    c(u32),
-    d(list<other-variant>),
-  }
-  variant other-variant {
-    a,
-    b(u32),
-    c(string),
-  }
-  variant-list: func(x: list<some-variant>) -> list<other-variant>
-
-  type load-store-all-sizes = list<tuple<
-    string,
-    u8,
-    s8,
-    u16,
-    s16,
-    u32,
-    s32,
-    u64,
-    s64,
-    float32,
-    float64,
-    char,
-  >>
-  load-store-everything: func(a: load-store-all-sizes) -> load-store-all-sizes
-}
-
-default world the-lists {
-  import import-lists: self.lists
-  export export-lists: self.lists
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/many-arguments.wit

@@ -1,50 +0,0 @@
-interface manyarg {
-  many-args: func(
-    a1: u64,
-    a2: u64,
-    a3: u64,
-    a4: u64,
-    a5: u64,
-    a6: u64,
-    a7: u64,
-    a8: u64,
-    a9: u64,
-    a10: u64,
-    a11: u64,
-    a12: u64,
-    a13: u64,
-    a14: u64,
-    a15: u64,
-    a16: u64,
-  )
-
-  record big-struct {
-    a1: string,
-    a2: string,
-    a3: string,
-    a4: string,
-    a5: string,
-    a6: string,
-    a7: string,
-    a8: string,
-    a9: string,
-    a10: string,
-    a11: string,
-    a12: string,
-    a13: string,
-    a14: string,
-    a15: string,
-    a16: string,
-    a17: string,
-    a18: string,
-    a19: string,
-    a20: string,
-  }
-
-  big-argument: func(x: big-struct)
-}
-
-default world the-world {
-  import imports: self.manyarg
-  export exports: self.manyarg
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/multi-return.wit

@@ -1,12 +0,0 @@
-interface multi-return {
-  mra: func()
-  mrb: func() -> ()
-  mrc: func() -> u32
-  mrd: func() -> (a: u32)
-  mre: func() -> (a: u32, b: float32)
-}
-
-default world the-world {
-  import imports: self.multi-return
-  export exports: self.multi-return
-}

data/ext/cargo-vendor/wasmtime-component-macro-9.0.4/tests/codegen/records.wit

@@ -1,59 +0,0 @@
-interface records {
-  tuple-arg: func(x: tuple<char, u32>)
-  tuple-result: func() -> tuple<char, u32>
-
-  record empty {}
-
-  empty-arg: func(x: empty)
-  empty-result: func() -> empty
-
-  /// A record containing two scalar fields
-  /// that both have the same type
-  record scalars {
-      /// The first field, named a
-      a: u32,
-      /// The second field, named b
-      b: u32,
-  }
-
-  scalar-arg: func(x: scalars)
-  scalar-result: func() -> scalars
-
-  /// A record that is really just flags
-  /// All of the fields are bool
-  record really-flags {
-      a: bool,
-      b: bool,
-      c: bool,
-      d: bool,
-      e: bool,
-      f: bool,
-      g: bool,
-      h: bool,
-      i: bool,
-  }
-
-  flags-arg: func(x: really-flags)
-  flags-result: func() -> really-flags
-
-  record aggregates {
-      a: scalars,
-      b: u32,
-      c: empty,
-      d: string,
-      e: really-flags,
-  }
-
-  aggregate-arg: func(x: aggregates)
-  aggregate-result: func() -> aggregates
-
-  type tuple-typedef = tuple<s32>
-  type int-typedef = s32
-  type tuple-typedef2 = tuple<int-typedef>
-  typedef-inout: func(e: tuple-typedef2) -> s32
-}
-
-default world the-world {
-  import imports: self.records
-  export exports: self.records
-}