fix Mismatch in stability attributes error in wit-parser

When a new interface is marked as @unstable (feature = somefeaturegate) and it uses a stable type from another package via use package:interface/type.{name} the resulting package should be able to be imported into other packages that use it. The use case for this is adding a unstable interface such as wasi-tls to wasi-cli.  Once we get to resolve_include's processing we've already verified that everything checks out from a feature/version perspective for those features. i.e. we can't be trying to consolidate an interface type with a feature that hasn't already been resolved.

Signed-off-by: James Sturtevant <[email protected]>

Author: jsturtevant

Diff for: crates/wit-parser/src/resolve.rs

@@ -3404,17 +3404,13 @@ impl Remap {
                 let prev = items.entry(key.clone()).or_insert(item.1.clone());
                 match (&item.1, prev) {
                     (
-                        WorldItem::Interface {
-                            id: aid,
-                            stability: astability,
-                        },
-                        WorldItem::Interface {
-                            id: bid,
-                            stability: bstability,
-                        },
+                        WorldItem::Interface { id: aid, .. },
+                        WorldItem::Interface { id: bid, .. },
                     ) => {
+                        // At this point in processing we care that the interfaces are the same
+                        // but don't need to verify stability.  We've already confirmed that the interface should be
+                        // apart of the component and versions/features are enabled so if they are the same it can be used.
                         assert_eq!(*aid, *bid);
-                        update_stability(astability, bstability)?;
                     }
                     (WorldItem::Interface { .. }, _) => unreachable!(),
                     (WorldItem::Function(_), _) => unreachable!(),
@@ -3833,7 +3829,7 @@ fn update_stability(from: &Stability, into: &mut Stability) -> Result<()> {
 
     // Failing all that this means that the two attributes are different so
     // generate an error.
-    bail!("mismatch in stability attributes")
+    bail!("mismatch in stability from '{:?}' to '{:?}'", from, into)
 }
 
 /// An error that can be returned during "world elaboration" during various

Diff for: crates/wit-parser/tests/ui/gated-include-use-with-stable.wit

@@ -0,0 +1,75 @@
+package wasmtime:test;
+
+world test{
+    @unstable(feature = active)
+    include wasi:unstable/imports@0.2.3; 
+    include wasi:foo/imports@0.2.3;
+} 
+
+world test-ordered{
+    include wasi:foo/imports@0.2.3;
+    @unstable(feature = active)
+    include wasi:unstable/imports@0.2.3; 
+} 
+
+package wasi:unstable@0.2.3 {
+    @unstable(feature = active)
+    world imports {
+        @unstable(feature = active)
+        use wasi:dep2/[email protected].{stable-resource};
+        @unstable(feature = active)
+        use wasi:dep-unversioned/unversioned.{unversioned-resource};
+        @unstable(feature = active)
+        use wasi:dep-unstable/unstable.{unstable-resource};
+    }
+}
+
+package wasi:foo@0.2.3 {
+    @since(version = 0.2.0)
+    world imports {
+        @since(version = 0.2.0)
+        include wasi:dep2/[email protected];
+        include wasi:dep-unversioned/imports;
+        include wasi:dep-unstable/imports;
+    }
+}
+
+package wasi:dep2@0.2.3 {
+    @since(version = 0.2.0)
+    world imports {
+        @since(version = 0.2.0)
+        import stable;
+    }
+    @since(version = 0.2.1)
+    interface stable {
+        resource stable-resource {
+        }
+    }
+}
+
+package wasi:dep-unversioned{
+    world imports {
+        import unversioned;
+    }
+    interface unversioned {
+        resource unversioned-resource {
+
+        }
+    }
+}
+
+package wasi:dep-unstable{
+    @unstable(feature = active)
+    world imports {
+        @unstable(feature = active)
+        import unstable;
+    }
+    @unstable(feature = active)
+    interface unstable {
+        @unstable(feature = active)
+        resource unstable-resource {
+
+        }
+    }
+}
+