Shuffle around the wiggle crates (#1414)

* Shuffle around the wiggle crates

This commit reorganizes the wiggle crates slightly by performing the
following transforms:

* The `crates/wiggle` crate, previously named `wiggle`, was moved to
  `crates/wiggle/crates/macro` and is renamed to `wiggle-macro`.

* The `crates/wiggle/crates/runtime` crate, previously named
  `wiggle-runtime`, was moved to `crates/wiggle` and is renamed to
  `wiggle`.

* The new `wiggle` crate depends on `wiggle-macro` and reexports the macro.

The goal here is that consumers only deal with the `wiggle` crate
itself. No more crates depend on `wiggle-runtime` and all dependencies
are entirely on just the `wiggle` crate.

* Remove the `crates/wiggle/crates` directory

Move everything into `crates/wiggle` directly, like `wasi-common`

* Add wiggle-macro to test-all script

* Fixup a test

crates/wiggle/generate/src/config.rs

@@ -0,0 +1,117 @@
+use std::path::{Path, PathBuf};
+
+use proc_macro2::Span;
+use syn::{
+    braced, bracketed,
+    parse::{Parse, ParseStream},
+    punctuated::Punctuated,
+    Error, Ident, LitStr, Result, Token,
+};
+
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub witx: WitxConf,
+    pub ctx: CtxConf,
+    pub emit_metadata: bool,
+}
+
+#[derive(Debug, Clone)]
+pub enum ConfigField {
+    Witx(WitxConf),
+    Ctx(CtxConf),
+}
+
+impl ConfigField {
+    pub fn parse_pair(ident: &str, value: ParseStream, err_loc: Span) -> Result<Self> {
+        match ident {
+            "witx" => Ok(ConfigField::Witx(value.parse()?)),
+            "ctx" => Ok(ConfigField::Ctx(value.parse()?)),
+            _ => Err(Error::new(err_loc, "expected `witx` or `ctx`")),
+        }
+    }
+}
+
+impl Parse for ConfigField {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let id: Ident = input.parse()?;
+        let _colon: Token![:] = input.parse()?;
+        Self::parse_pair(id.to_string().as_ref(), input, id.span())
+    }
+}
+
+impl Config {
+    pub fn build(fields: impl Iterator<Item = ConfigField>, err_loc: Span) -> Result<Self> {
+        let mut witx = None;
+        let mut ctx = None;
+        for f in fields {
+            match f {
+                ConfigField::Witx(c) => {
+                    witx = Some(c);
+                }
+                ConfigField::Ctx(c) => {
+                    ctx = Some(c);
+                }
+            }
+        }
+        Ok(Config {
+            witx: witx
+                .take()
+                .ok_or_else(|| Error::new(err_loc, "`witx` field required"))?,
+            ctx: ctx
+                .take()
+                .ok_or_else(|| Error::new(err_loc, "`ctx` field required"))?,
+            emit_metadata: false,
+        })
+    }
+}
+
+impl Parse for Config {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        let _lbrace = braced!(contents in input);
+        let fields: Punctuated<ConfigField, Token![,]> =
+            contents.parse_terminated(ConfigField::parse)?;
+        Ok(Config::build(fields.into_iter(), input.span())?)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct WitxConf {
+    pub paths: Vec<PathBuf>,
+}
+
+impl WitxConf {
+    pub fn make_paths_relative_to<P: AsRef<Path>>(&mut self, root: P) {
+        self.paths.iter_mut().for_each(|p| {
+            if !p.is_absolute() {
+                *p = PathBuf::from(root.as_ref()).join(p.clone());
+            }
+        });
+    }
+}
+
+impl Parse for WitxConf {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let content;
+        let _ = bracketed!(content in input);
+        let path_lits: Punctuated<LitStr, Token![,]> = content.parse_terminated(Parse::parse)?;
+        let paths = path_lits
+            .iter()
+            .map(|lit| PathBuf::from(lit.value()))
+            .collect();
+        Ok(WitxConf { paths })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CtxConf {
+    pub name: Ident,
+}
+
+impl Parse for CtxConf {
+    fn parse(input: ParseStream) -> Result<Self> {
+        Ok(CtxConf {
+            name: input.parse()?,
+        })
+    }
+}