wasmtime 19.0.2 → 20.0.0

data/ext/cargo-vendor/wit-parser-0.202.0/src/serde_.rs

@@ -0,0 +1,108 @@
+use crate::{Params, Type};
+use id_arena::{Arena, Id};
+use indexmap::IndexMap;
+use serde::ser::{SerializeMap, SerializeSeq, Serializer};
+use serde::Serialize;
+
+pub fn serialize_none<S>(serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_none()
+}
+
+pub fn serialize_arena<T, S>(arena: &Arena<T>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    T: Serialize,
+    S: Serializer,
+{
+    let mut seq = serializer.serialize_seq(Some(arena.len()))?;
+    for (_, item) in arena.iter() {
+        seq.serialize_element(&item)?;
+    }
+    seq.end()
+}
+
+pub fn serialize_id<T, S>(id: &Id<T>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_u64(id.index() as u64)
+}
+
+pub fn serialize_optional_id<T, S>(id: &Option<Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match id {
+        Some(id) => serialize_id(&id, serializer),
+        None => serializer.serialize_none(),
+    }
+}
+
+pub fn serialize_id_map<K, T, S>(map: &IndexMap<K, Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    K: Serialize,
+    S: Serializer,
+{
+    let mut s = serializer.serialize_map(Some(map.len()))?;
+    for (key, id) in map.iter() {
+        s.serialize_entry(key, &(id.index() as u64))?;
+    }
+    s.end()
+}
+
+impl Serialize for Type {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Type::Bool => serializer.serialize_str("bool"),
+            Type::U8 => serializer.serialize_str("u8"),
+            Type::U16 => serializer.serialize_str("u16"),
+            Type::U32 => serializer.serialize_str("u32"),
+            Type::U64 => serializer.serialize_str("u64"),
+            Type::S8 => serializer.serialize_str("s8"),
+            Type::S16 => serializer.serialize_str("s16"),
+            Type::S32 => serializer.serialize_str("s32"),
+            Type::S64 => serializer.serialize_str("s64"),
+            Type::F32 => serializer.serialize_str("f32"),
+            Type::F64 => serializer.serialize_str("f64"),
+            Type::Char => serializer.serialize_str("char"),
+            Type::String => serializer.serialize_str("string"),
+            Type::Id(type_id) => serializer.serialize_u64(type_id.index() as u64),
+        }
+    }
+}
+
+pub fn serialize_anon_result<S>(typ: &Type, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let params: Params = vec![(String::default(), *typ)];
+    serialize_params(&params, serializer)
+}
+
+pub fn serialize_params<S>(params: &Params, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut seq = serializer.serialize_seq(Some(params.len()))?;
+    for (name, typ) in params.iter() {
+        let param = Param {
+            name: name.to_string(),
+            typ: *typ,
+        };
+        seq.serialize_element(&param)?;
+    }
+    seq.end()
+}
+
+#[derive(Debug, Clone, PartialEq, serde_derive::Serialize)]
+struct Param {
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub name: String,
+    #[serde(rename = "type")]
+    pub typ: Type,
+}

data/ext/cargo-vendor/wit-parser-0.202.0/src/sizealign.rs

@@ -0,0 +1,179 @@
+use crate::{FlagsRepr, Int, Resolve, Type, TypeDef, TypeDefKind};
+
+#[derive(Default)]
+pub enum AddressSize {
+    #[default]
+    Wasm32,
+    Wasm64,
+}
+
+#[derive(Default)]
+pub struct SizeAlign {
+    map: Vec<(usize, usize)>,
+    wasm_type: AddressSize,
+}
+
+impl SizeAlign {
+    pub fn new(wasm_type: AddressSize) -> Self {
+        Self {
+            map: Vec::new(),
+            wasm_type,
+        }
+    }
+
+    pub fn fill(&mut self, resolve: &Resolve) {
+        self.map = Vec::new();
+        for (_, ty) in resolve.types.iter() {
+            let pair = self.calculate(ty);
+            self.map.push(pair);
+        }
+    }
+
+    fn calculate(&self, ty: &TypeDef) -> (usize, usize) {
+        match &ty.kind {
+            TypeDefKind::Type(t) => (self.size(t), self.align(t)),
+            TypeDefKind::List(_) => {
+                if matches!(self.wasm_type, AddressSize::Wasm64) {
+                    (16, 8)
+                } else {
+                    (8, 4)
+                }
+            }
+            TypeDefKind::Record(r) => self.record(r.fields.iter().map(|f| &f.ty)),
+            TypeDefKind::Tuple(t) => self.record(t.types.iter()),
+            TypeDefKind::Flags(f) => match f.repr() {
+                FlagsRepr::U8 => (1, 1),
+                FlagsRepr::U16 => (2, 2),
+                FlagsRepr::U32(n) => (n * 4, 4),
+            },
+            TypeDefKind::Variant(v) => self.variant(v.tag(), v.cases.iter().map(|c| c.ty.as_ref())),
+            TypeDefKind::Enum(e) => self.variant(e.tag(), []),
+            TypeDefKind::Option(t) => self.variant(Int::U8, [Some(t)]),
+            TypeDefKind::Result(r) => self.variant(Int::U8, [r.ok.as_ref(), r.err.as_ref()]),
+            // A resource is represented as an index.
+            TypeDefKind::Handle(_) => (4, 4),
+            // A future is represented as an index.
+            TypeDefKind::Future(_) => (4, 4),
+            // A stream is represented as an index.
+            TypeDefKind::Stream(_) => (4, 4),
+            // This shouldn't be used for anything since raw resources aren't part of the ABI -- just handles to
+            // them.
+            TypeDefKind::Resource => (usize::MAX, usize::MAX),
+            TypeDefKind::Unknown => unreachable!(),
+        }
+    }
+
+    pub fn size(&self, ty: &Type) -> usize {
+        match ty {
+            Type::Bool | Type::U8 | Type::S8 => 1,
+            Type::U16 | Type::S16 => 2,
+            Type::U32 | Type::S32 | Type::F32 | Type::Char => 4,
+            Type::U64 | Type::S64 | Type::F64 => 8,
+            Type::String => {
+                if matches!(self.wasm_type, AddressSize::Wasm64) {
+                    16
+                } else {
+                    8
+                }
+            }
+            Type::Id(id) => self.map[id.index()].0,
+        }
+    }
+
+    pub fn align(&self, ty: &Type) -> usize {
+        match ty {
+            Type::Bool | Type::U8 | Type::S8 => 1,
+            Type::U16 | Type::S16 => 2,
+            Type::U32 | Type::S32 | Type::F32 | Type::Char => 4,
+            Type::U64 | Type::S64 | Type::F64 => 8,
+            Type::String => {
+                if matches!(self.wasm_type, AddressSize::Wasm64) {
+                    8
+                } else {
+                    4
+                }
+            }
+            Type::Id(id) => self.map[id.index()].1,
+        }
+    }
+
+    pub fn field_offsets<'a>(
+        &self,
+        types: impl IntoIterator<Item = &'a Type>,
+    ) -> Vec<(usize, &'a Type)> {
+        let mut cur = 0;
+        types
+            .into_iter()
+            .map(|ty| {
+                let ret = align_to(cur, self.align(ty));
+                cur = ret + self.size(ty);
+                (ret, ty)
+            })
+            .collect()
+    }
+
+    pub fn payload_offset<'a>(
+        &self,
+        tag: Int,
+        cases: impl IntoIterator<Item = Option<&'a Type>>,
+    ) -> usize {
+        let mut max_align = 1;
+        for ty in cases {
+            if let Some(ty) = ty {
+                max_align = max_align.max(self.align(ty));
+            }
+        }
+        let tag_size = int_size_align(tag).0;
+        align_to(tag_size, max_align)
+    }
+
+    pub fn record<'a>(&self, types: impl Iterator<Item = &'a Type>) -> (usize, usize) {
+        let mut size = 0;
+        let mut align = 1;
+        for ty in types {
+            let field_size = self.size(ty);
+            let field_align = self.align(ty);
+            size = align_to(size, field_align) + field_size;
+            align = align.max(field_align);
+        }
+        (align_to(size, align), align)
+    }
+
+    pub fn params<'a>(&self, types: impl IntoIterator<Item = &'a Type>) -> (usize, usize) {
+        self.record(types.into_iter())
+    }
+
+    fn variant<'a>(
+        &self,
+        tag: Int,
+        types: impl IntoIterator<Item = Option<&'a Type>>,
+    ) -> (usize, usize) {
+        let (discrim_size, discrim_align) = int_size_align(tag);
+        let mut case_size = 0;
+        let mut case_align = 1;
+        for ty in types {
+            if let Some(ty) = ty {
+                case_size = case_size.max(self.size(ty));
+                case_align = case_align.max(self.align(ty));
+            }
+        }
+        let align = discrim_align.max(case_align);
+        (
+            align_to(align_to(discrim_size, case_align) + case_size, align),
+            align,
+        )
+    }
+}
+
+fn int_size_align(i: Int) -> (usize, usize) {
+    match i {
+        Int::U8 => (1, 1),
+        Int::U16 => (2, 2),
+        Int::U32 => (4, 4),
+        Int::U64 => (8, 8),
+    }
+}
+
+pub(crate) fn align_to(val: usize, align: usize) -> usize {
+    (val + align - 1) & !(align - 1)
+}

data/ext/cargo-vendor/wit-parser-0.202.0/tests/all.rs

@@ -0,0 +1,153 @@
+//! You can run this test suite with:
+//!
+//!     cargo test --test all
+//!
+//! An argument can be passed as well to filter, based on filename, which test
+//! to run
+//!
+//!     cargo test --test all foo.wit
+
+use anyhow::{bail, Context, Result};
+use libtest_mimic::{Arguments, Trial};
+use pretty_assertions::StrComparison;
+use std::env;
+use std::ffi::OsStr;
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::str;
+use wit_parser::*;
+
+fn main() {
+    env_logger::init();
+    let tests = find_tests();
+
+    let mut trials = Vec::new();
+    for test in tests {
+        let trial = Trial::test(format!("{test:?}"), move || {
+            Runner {}
+                .run(&test)
+                .context(format!("test {:?} failed", test))
+                .map_err(|e| format!("{e:?}").into())
+        });
+        trials.push(trial);
+    }
+
+    let mut args = Arguments::from_args();
+    if cfg!(target_family = "wasm") && !cfg!(target_feature = "atomics") {
+        args.test_threads = Some(1);
+    }
+    libtest_mimic::run(&args, trials).exit();
+}
+
+/// Recursively finds all tests in a whitelisted set of directories which we
+/// then load up and test in parallel.
+fn find_tests() -> Vec<PathBuf> {
+    let mut tests = Vec::new();
+    find_tests("tests/ui".as_ref(), &mut tests);
+    find_tests("tests/ui/parse-fail".as_ref(), &mut tests);
+    tests.sort();
+    return tests;
+
+    fn find_tests(path: &Path, tests: &mut Vec<PathBuf>) {
+        for f in path.read_dir().unwrap() {
+            let f = f.unwrap();
+            let path = f.path();
+            if path.file_name().unwrap().to_str().unwrap() == "parse-fail" {
+                continue;
+            }
+            if f.file_type().unwrap().is_dir() {
+                tests.push(path);
+                continue;
+            }
+
+            match path.extension().and_then(|s| s.to_str()) {
+                Some("md") | Some("wit") | Some("wat") | Some("wasm") => {}
+                _ => continue,
+            }
+            tests.push(path);
+        }
+    }
+}
+
+struct Runner {}
+
+impl Runner {
+    fn run(&mut self, test: &Path) -> Result<()> {
+        let mut resolve = Resolve::new();
+        let result = resolve.push_path(test);
+        let result = if test.iter().any(|s| s == "parse-fail") {
+            match result {
+                Ok(_) => bail!("expected test to not parse but it did"),
+                Err(mut e) => {
+                    if let Some(err) = e.downcast_mut::<io::Error>() {
+                        *err = io::Error::new(
+                            io::ErrorKind::Other,
+                            "some generic platform-agnostic error message",
+                        );
+                    }
+                    format!("{:?}", e)
+                }
+            }
+        } else {
+            result?;
+            // format json string to human readable
+            let json_result = serde_json::to_string_pretty(&resolve)?;
+            // "foo.wit" => "foo.wit.json"
+            self.read_or_write_to_file(test, &json_result, "json")?;
+            return Ok(());
+        };
+
+        // "foo.wit" => "foo.wit.result"
+        // "foo.wit.md" => "foo.wit.md.result"
+        self.read_or_write_to_file(test, &result, "result")?;
+        return Ok(());
+    }
+
+    fn read_or_write_to_file(
+        &mut self,
+        test: &Path,
+        result: &str,
+        extension: &str,
+    ) -> Result<(), anyhow::Error> {
+        let result_file = if test.extension() == Some(OsStr::new("md"))
+            && test
+                .file_stem()
+                .and_then(|path| Path::new(path).extension())
+                == Some(OsStr::new("wit"))
+        {
+            test.with_extension(format!("md.{extension}"))
+        } else {
+            test.with_extension(format!("wit.{extension}"))
+        };
+        if env::var_os("BLESS").is_some() {
+            let normalized = normalize(&result, extension);
+            fs::write(&result_file, normalized)?;
+        } else {
+            let expected = fs::read_to_string(&result_file).context(format!(
+                "failed to read test expectation file {:?}\nthis can be fixed with BLESS=1",
+                result_file
+            ))?;
+            let expected = normalize(&expected, extension);
+            let result = normalize(&result, extension);
+            if expected != result {
+                bail!(
+                    "failed test: result is not as expected:{}",
+                    StrComparison::new(&expected, &result),
+                );
+            }
+        }
+        Ok(())
+    }
+}
+
+fn normalize(s: &str, extension: &str) -> String {
+    let s = s.trim();
+    match extension {
+        // .result files have error messages with paths, so normalize Windows \ separators to /
+        "result" => s.replace("\\", "/").replace("\r\n", "\n"),
+
+        // .json files escape strings with \, so leave them alone
+        _ => s.replace("\r\n", "\n"),
+    }
+}

data/ext/cargo-vendor/wit-parser-0.202.0/tests/ui/functions.wit

@@ -0,0 +1,14 @@
+package foo:functions;
+
+interface functions {
+  f1: func();
+  f2: func(a: u32);
+  f3: func(a: u32,);
+  f4: func() -> u32;
+  f6: func() -> tuple<u32, u32>;
+  f7: func(a: f32, b: f32) -> tuple<u32, u32>;
+  f8: func(a: option<u32>) -> result<u32, f32>;
+  f9: func() -> (u: u32, f: f32);
+  f10: func() -> (u: u32);
+  f11: func() -> ();
+}

data/ext/cargo-vendor/wit-parser-0.202.0/tests/ui/functions.wit.json

@@ -0,0 +1,166 @@
+{
+  "worlds": [],
+  "interfaces": [
+    {
+      "name": "functions",
+      "types": {},
+      "functions": {
+        "f1": {
+          "name": "f1",
+          "kind": "freestanding",
+          "params": [],
+          "results": []
+        },
+        "f2": {
+          "name": "f2",
+          "kind": "freestanding",
+          "params": [
+            {
+              "name": "a",
+              "type": "u32"
+            }
+          ],
+          "results": []
+        },
+        "f3": {
+          "name": "f3",
+          "kind": "freestanding",
+          "params": [
+            {
+              "name": "a",
+              "type": "u32"
+            }
+          ],
+          "results": []
+        },
+        "f4": {
+          "name": "f4",
+          "kind": "freestanding",
+          "params": [],
+          "results": [
+            {
+              "type": "u32"
+            }
+          ]
+        },
+        "f6": {
+          "name": "f6",
+          "kind": "freestanding",
+          "params": [],
+          "results": [
+            {
+              "type": 0
+            }
+          ]
+        },
+        "f7": {
+          "name": "f7",
+          "kind": "freestanding",
+          "params": [
+            {
+              "name": "a",
+              "type": "f32"
+            },
+            {
+              "name": "b",
+              "type": "f32"
+            }
+          ],
+          "results": [
+            {
+              "type": 0
+            }
+          ]
+        },
+        "f8": {
+          "name": "f8",
+          "kind": "freestanding",
+          "params": [
+            {
+              "name": "a",
+              "type": 1
+            }
+          ],
+          "results": [
+            {
+              "type": 2
+            }
+          ]
+        },
+        "f9": {
+          "name": "f9",
+          "kind": "freestanding",
+          "params": [],
+          "results": [
+            {
+              "name": "u",
+              "type": "u32"
+            },
+            {
+              "name": "f",
+              "type": "f32"
+            }
+          ]
+        },
+        "f10": {
+          "name": "f10",
+          "kind": "freestanding",
+          "params": [],
+          "results": [
+            {
+              "name": "u",
+              "type": "u32"
+            }
+          ]
+        },
+        "f11": {
+          "name": "f11",
+          "kind": "freestanding",
+          "params": [],
+          "results": []
+        }
+      },
+      "package": 0
+    }
+  ],
+  "types": [
+    {
+      "name": null,
+      "kind": {
+        "tuple": {
+          "types": [
+            "u32",
+            "u32"
+          ]
+        }
+      },
+      "owner": null
+    },
+    {
+      "name": null,
+      "kind": {
+        "option": "u32"
+      },
+      "owner": null
+    },
+    {
+      "name": null,
+      "kind": {
+        "result": {
+          "ok": "u32",
+          "err": "f32"
+        }
+      },
+      "owner": null
+    }
+  ],
+  "packages": [
+    {
+      "name": "foo:functions",
+      "interfaces": {
+        "functions": 0
+      },
+      "worlds": {}
+    }
+  ]
+}

data/ext/cargo-vendor/wit-parser-0.202.0/tests/ui/resources-multiple.wit

@@ -0,0 +1,20 @@
+package foo:resources-multiple;
+
+interface resources-multiple {
+  t1: func(a: borrow<r1>) -> ();
+  t2: func(a: own<r1>) -> ();
+
+  resource r1 {
+    f1: func();
+    f2: func(a: u32);
+    f3: func(a: u32,);
+    f4: func() -> u32;
+    f6: func() -> tuple<u32, u32>;
+    f7: func(a: f32, b: f32) -> tuple<u32, u32>;
+    f8: func(a: option<u32>) -> result<u32, f32>;
+    f9: func() -> (u: u32, f: f32);
+    f10: func() -> (u: u32);
+    f11: func() -> ();
+  }
+}
+