Fix path canonicalization in witx use statements (#434)

* Add a (failing) test case

This test case demonstrates a bug identified with the semantics of `use`
statements in witx documents.

No fix is provided in this commit, so `cargo test` will fail at this
commit.

* Add some temporary printlns

Because who doesn't love println debugging?

Now, running the (failing) test case added in the previous commit, we'll
see:

```
---- toplevel::test::multi_use_with_layered_dirs stdout ----
parsing file at path='"root.witx"' root='"/"'
canonical-path='"/root.witx"'

found a use statement, parsing file at "subdir/child.witx"
parsing file at path='"subdir/child.witx"' root='"/"'
canonical-path='"/subdir/child.witx"'

found a use statement, parsing file at "sibling.witx"
parsing file at path='"sibling.witx"' root='"/"'
canonical-path='"/sibling.witx"'
thread 'toplevel::test::multi_use_with_layered_dirs' panicked at 'parse: Io("/sibling.witx", Custom { kind: Other, error: "mock fs: file not found" })', src/toplevel.rs:151:10
```

Note that root is always `/` even when we're evaluating the paths found
in a document that lives in a subdirectory! See how the canonical path
in the last block resolves to '/sibling.witx'?

We found you, Mr. Bug 🐛 🔍😃

* Fix the bug

* Remove temproary printlns

This reverts commit 07c1ae9.

* oh no, windows paths

* add review suggestion

Co-authored-by: Pat Hickey <[email protected]>

Co-authored-by: Pat Hickey <[email protected]>

Author: katelyn martin

tools/witx/src/io.rs

@@ -52,23 +52,23 @@ impl WitxIo for Filesystem {
 }
 
 pub struct MockFs {
-    map: HashMap<String, String>,
+    map: HashMap<PathBuf, String>,
 }
 
 impl MockFs {
     pub fn new(strings: &[(&str, &str)]) -> Self {
         MockFs {
             map: strings
                 .iter()
-                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .map(|(k, v)| (PathBuf::from(k), v.to_string()))
                 .collect(),
         }
     }
 }
 
 impl WitxIo for MockFs {
     fn fgets(&self, path: &Path) -> Result<String, WitxError> {
-        if let Some(entry) = self.map.get(path.to_str().unwrap()) {
+        if let Some(entry) = self.map.get(path) {
             Ok(entry.to_string())
         } else {
             Err(WitxError::Io(
@@ -78,7 +78,7 @@ impl WitxIo for MockFs {
         }
     }
     fn fget_line(&self, path: &Path, line: usize) -> Result<String, WitxError> {
-        if let Some(entry) = self.map.get(path.to_str().unwrap()) {
+        if let Some(entry) = self.map.get(path) {
             entry
                 .lines()
                 .skip(line - 1)

tools/witx/src/toplevel.rs

@@ -66,6 +66,7 @@ fn parse_file(
                     .map_err(WitxError::Validation)?;
             }
             TopLevelSyntax::Use(u) => {
+                let root = path.parent().unwrap_or(root);
                 parse_file(u.as_ref(), io, root, validator, definitions, parsed)?;
             }
         }
@@ -138,6 +139,37 @@ mod test {
         );
     }
 
+    #[test]
+    fn multi_use_with_layered_dirs() {
+        let doc = parse_witx_with(
+            &[Path::new("/root.witx")],
+            &MockFs::new(&[
+                ("/root.witx", "(use \"subdir/child.witx\")"),
+                (
+                    "/subdir/child.witx",
+                    "(use \"sibling.witx\")\n(typename $b_float f64)",
+                ),
+                ("/subdir/sibling.witx", "(typename $c_int u32)"),
+                // This definition looks just like subdir/sibling.witx but
+                // defines c_int differently - this test shows it does Not get
+                // included by subdir/child.witx's use.
+                ("/sibling.witx", "(typename $c_int u64)"),
+            ]),
+        )
+        .expect("parse");
+
+        let b_float = doc.typename(&Id::new("b_float")).unwrap();
+        assert_eq!(**b_float.type_(), Type::Builtin(BuiltinType::F64));
+
+        let c_int = doc.typename(&Id::new("c_int")).unwrap();
+        assert_eq!(
+            **c_int.type_(),
+            Type::Builtin(BuiltinType::U32 {
+                lang_ptr_size: false
+            })
+        );
+    }
+
     #[test]
     fn use_not_found() {
         match parse_witx_with(&[Path::new("/a")], &MockFs::new(&[("/a", "(use \"b\")")]))