Fix UDT re-exports

compiler/qsc_frontend/src/compile/tests/multiple_packages.rs

@@ -509,3 +509,39 @@ fn aliased_export_via_aliased_import() {
         ),
     ]);
 }
+
+#[test]
+fn udt_reexport() {
+    multiple_package_check(vec![
+        (
+            "A",
+            "struct Foo { content: Bool }
+                export Foo as Bar;",
+        ),
+        (
+            "B",
+            "           @EntryPoint()
+            operation Main() : Unit {
+                let x = new A.A.Bar { content = true };
+            }",
+        ),
+    ]);
+}
+
+#[test]
+fn callable_reexport() {
+    multiple_package_check(vec![
+        (
+            "A",
+            "function Foo() : Unit {  }
+                export Foo as Bar;",
+        ),
+        (
+            "B",
+            "           @EntryPoint()
+            operation Main() : Unit {
+                let x = A.A.Bar();
+            }",
+        ),
+    ]);
+}

compiler/qsc_frontend/src/resolve.rs

@@ -1676,10 +1676,10 @@ impl GlobalTable {
                                 .insert_or_find_namespace(ns.iter().map(|s| s.name.clone()));
                         }
                         hir::ItemKind::Ty(..) => {
-                            self.scope
-                                .tys
-                                .get_mut_or_default(namespace)
-                                .insert(global.name.clone(), Res::ExportedItem(item_id, None));
+                            self.scope.tys.get_mut_or_default(namespace).insert(
+                                global.name.clone(),
+                                Res::Item(item_id, ItemStatus::Available),
+                            );
                         }
                         hir::ItemKind::Export(_, _) => {
                             unreachable!("find_item will never return an Export")

compiler/qsc_frontend/src/typeck/convert.rs

@@ -117,13 +117,12 @@ pub(super) fn ty_from_path(names: &Names, path: &Path) -> Ty {
         // So realistically, by construction, `Param` here is unreachable.
         // A path can also never resolve to an export, because in typeck/check,
         // we resolve exports to their original definition.
-        Some(
-            resolve::Res::Local(_) | resolve::Res::Param { .. } | resolve::Res::ExportedItem(_, _),
-        ) => {
-            unreachable!(
-                "A path should never resolve \
+        Some(resolve::Res::Local(_) | resolve::Res::Param { .. }) => unreachable!(
+            " A path should never resolve \
             to a local or a parameter, as there is syntactic differentiation."
-            )
+        ),
+        Some(resolve::Res::ExportedItem(item_id, alias)) => {
+            unreachable!("Exported items should have been resolved to their original definition in type checking. Found {:?} with alias {:?}", item_id, alias);
         }
         None => Ty::Err,
     }