Refactor resolution to use hierarchical namespaces

.gitignore

@@ -17,3 +17,4 @@ __pycache__/
 /fuzz/Cargo.lock
 .mypy_cache/
 .pytest_cache/
+.idea/

compiler/qsc/src/interpret/debug.rs

@@ -83,7 +83,7 @@ fn get_item_file_name(store: &PackageStore, id: StoreItemId) -> Option<String> {
 #[must_use]
 fn get_ns_name(item: &Item) -> Option<String> {
     if let ItemKind::Namespace(ns, _) = &item.kind {
-        Some(ns.name.to_string())
+        Some(ns.name().to_string())
     } else {
         None
     }

compiler/qsc/src/lib.rs

@@ -34,7 +34,7 @@ pub mod project {
     pub use qsc_project::{DirEntry, EntryType, FileSystem, Manifest, ManifestDescriptor};
 }
 
-pub use qsc_data_structures::{language_features::LanguageFeatures, span::Span};
+pub use qsc_data_structures::{language_features::LanguageFeatures, namespaces::*, span::Span};
 
 pub use qsc_passes::{PackageType, PassContext};
 

compiler/qsc_ast/src/ast.rs

@@ -164,7 +164,7 @@ pub struct Namespace {
     /// The documentation.
     pub doc: Rc<str>,
     /// The namespace name.
-    pub name: Box<Ident>,
+    pub name: VecIdent,
     /// The items in the namespace.
     pub items: Box<[Box<Item>]>,
 }
@@ -259,7 +259,7 @@ pub enum ItemKind {
     #[default]
     Err,
     /// An `open` item for a namespace with an optional alias.
-    Open(Box<Ident>, Option<Box<Ident>>),
+    Open(VecIdent, Option<Box<Ident>>),
     /// A `newtype` declaration.
     Ty(Box<Ident>, Box<TyDef>),
 }
@@ -1273,7 +1273,7 @@ pub struct Path {
     /// The span.
     pub span: Span,
     /// The namespace.
-    pub namespace: Option<Box<Ident>>,
+    pub namespace: Option<VecIdent>,
     /// The declaration name.
     pub name: Box<Ident>,
 }
@@ -1306,6 +1306,86 @@ pub struct Ident {
     pub name: Rc<str>,
 }
 
+/// A [`VecIdent`] represents a sequence of idents. It provides a helpful abstraction
+/// that is more powerful than a simple `Vec<Ident>`, and is primarily used to represent
+/// dot-separated paths.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Default)]
+pub struct VecIdent(pub Vec<Ident>);
+
+impl From<VecIdent> for Vec<Rc<str>> {
+    fn from(v: VecIdent) -> Self {
+        v.0.iter().map(|i| i.name.clone()).collect()
+    }
+}
+
+impl From<&VecIdent> for Vec<Rc<str>> {
+    fn from(v: &VecIdent) -> Self {
+        v.0.iter().map(|i| i.name.clone()).collect()
+    }
+}
+
+impl From<Vec<Ident>> for VecIdent {
+    fn from(v: Vec<Ident>) -> Self {
+        VecIdent(v)
+    }
+}
+
+impl From<VecIdent> for Vec<Ident> {
+    fn from(v: VecIdent) -> Self {
+        v.0
+    }
+}
+
+impl Display for VecIdent {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let mut buf = Vec::with_capacity(self.0.len());
+
+        for ident in &self.0 {
+            buf.push(format!("{ident}"));
+        }
+        if buf.len() > 1 {
+            // use square brackets only if there are more than one ident
+            write!(f, "[{}]", buf.join(", "))
+        } else {
+            write!(f, "{}", buf[0])
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a VecIdent {
+    type IntoIter = std::slice::Iter<'a, Ident>;
+    type Item = &'a Ident;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+impl VecIdent {
+    /// constructs an iter over the [Ident]s that this contains.
+    pub fn iter(&self) -> std::slice::Iter<'_, Ident> {
+        self.0.iter()
+    }
+
+    /// the conjoined span of all idents in the `VecIdent`
+    #[must_use]
+    pub fn span(&self) -> Span {
+        Span {
+            lo: self.0.first().map(|i| i.span.lo).unwrap_or_default(),
+            hi: self.0.last().map(|i| i.span.hi).unwrap_or_default(),
+        }
+    }
+
+    /// The stringified dot-separated path of the idents in this [`VecIdent`]
+    /// E.g. `a.b.c`
+    #[must_use]
+    pub fn name(&self) -> String {
+        self.0
+            .iter()
+            .map(|i| i.name.to_string())
+            .collect::<Vec<String>>()
+            .join(".")
+    }
+}
+
 impl Default for Ident {
     fn default() -> Self {
         Ident {

compiler/qsc_ast/src/mut_visit.rs

@@ -75,6 +75,9 @@ pub trait MutVisitor: Sized {
     fn visit_ident(&mut self, ident: &mut Ident) {
         walk_ident(self, ident);
     }
+    fn visit_vec_ident(&mut self, ident: &mut crate::ast::VecIdent) {
+        walk_vec_ident(self, ident);
+    }
 
     fn visit_span(&mut self, _: &mut Span) {}
 }
@@ -89,7 +92,8 @@ pub fn walk_package(vis: &mut impl MutVisitor, package: &mut Package) {
 
 pub fn walk_namespace(vis: &mut impl MutVisitor, namespace: &mut Namespace) {
     vis.visit_span(&mut namespace.span);
-    vis.visit_ident(&mut namespace.name);
+    vis.visit_vec_ident(&mut namespace.name);
+
     namespace.items.iter_mut().for_each(|i| vis.visit_item(i));
 }
 
@@ -104,7 +108,7 @@ pub fn walk_item(vis: &mut impl MutVisitor, item: &mut Item) {
         ItemKind::Callable(decl) => vis.visit_callable_decl(decl),
         ItemKind::Err => {}
         ItemKind::Open(ns, alias) => {
-            vis.visit_ident(ns);
+            vis.visit_vec_ident(ns);
             alias.iter_mut().for_each(|a| vis.visit_ident(a));
         }
         ItemKind::Ty(ident, def) => {
@@ -333,10 +337,20 @@ pub fn walk_qubit_init(vis: &mut impl MutVisitor, init: &mut QubitInit) {
 
 pub fn walk_path(vis: &mut impl MutVisitor, path: &mut Path) {
     vis.visit_span(&mut path.span);
-    path.namespace.iter_mut().for_each(|n| vis.visit_ident(n));
+    if let Some(ref mut namespace) = path.namespace {
+        vis.visit_vec_ident(namespace);
+    }
+    if let Some(ref mut ns) = path.namespace {
+        vis.visit_vec_ident(ns);
+    }
     vis.visit_ident(&mut path.name);
 }
 
 pub fn walk_ident(vis: &mut impl MutVisitor, ident: &mut Ident) {
     vis.visit_span(&mut ident.span);
 }
+pub fn walk_vec_ident(vis: &mut impl MutVisitor, ident: &mut crate::ast::VecIdent) {
+    for ref mut ident in &mut ident.0 {
+        vis.visit_ident(ident);
+    }
+}

compiler/qsc_ast/src/visit.rs

@@ -5,7 +5,7 @@ use crate::ast::{
     Attr, Block, CallableBody, CallableDecl, Expr, ExprKind, FunctorExpr, FunctorExprKind, Ident,
     Item, ItemKind, Namespace, Package, Pat, PatKind, Path, QubitInit, QubitInitKind, SpecBody,
     SpecDecl, Stmt, StmtKind, StringComponent, TopLevelNode, Ty, TyDef, TyDefKind, TyKind,
-    Visibility,
+    VecIdent, Visibility,
 };
 
 pub trait Visitor<'a>: Sized {
@@ -72,6 +72,8 @@ pub trait Visitor<'a>: Sized {
     }
 
     fn visit_ident(&mut self, _: &'a Ident) {}
+
+    fn visit_vec_ident(&mut self, _: &'a VecIdent) {}
 }
 
 pub fn walk_package<'a>(vis: &mut impl Visitor<'a>, package: &'a Package) {
@@ -83,7 +85,7 @@ pub fn walk_package<'a>(vis: &mut impl Visitor<'a>, package: &'a Package) {
 }
 
 pub fn walk_namespace<'a>(vis: &mut impl Visitor<'a>, namespace: &'a Namespace) {
-    vis.visit_ident(&namespace.name);
+    vis.visit_vec_ident(&namespace.name);
     namespace.items.iter().for_each(|i| vis.visit_item(i));
 }
 
@@ -94,7 +96,7 @@ pub fn walk_item<'a>(vis: &mut impl Visitor<'a>, item: &'a Item) {
         ItemKind::Err => {}
         ItemKind::Callable(decl) => vis.visit_callable_decl(decl),
         ItemKind::Open(ns, alias) => {
-            vis.visit_ident(ns);
+            vis.visit_vec_ident(ns);
             alias.iter().for_each(|a| vis.visit_ident(a));
         }
         ItemKind::Ty(ident, def) => {
@@ -300,6 +302,8 @@ pub fn walk_qubit_init<'a>(vis: &mut impl Visitor<'a>, init: &'a QubitInit) {
 }
 
 pub fn walk_path<'a>(vis: &mut impl Visitor<'a>, path: &'a Path) {
-    path.namespace.iter().for_each(|n| vis.visit_ident(n));
+    if let Some(ref ns) = path.namespace {
+        vis.visit_vec_ident(ns);
+    }
     vis.visit_ident(&path.name);
 }

compiler/qsc_circuit/src/operations/tests.rs

@@ -30,7 +30,7 @@ fn compile_one_operation(code: &str) -> (Item, String) {
     });
     let mut namespaces = unit.package.items.values().filter_map(|i| {
         if let ItemKind::Namespace(ident, _) = &i.kind {
-            Some(ident.name.clone())
+            Some(ident.clone())
         } else {
             None
         }
@@ -44,7 +44,7 @@ fn compile_one_operation(code: &str) -> (Item, String) {
     );
     (
         only_callable.clone(),
-        format!("{only_namespace}.{callable_name}"),
+        format!("{}.{callable_name}", only_namespace.name()),
     )
 }
 

compiler/qsc_data_structures/Cargo.toml

@@ -12,6 +12,7 @@ repository.workspace = true
 miette = { workspace = true }
 serde = { workspace = true }
 bitflags = { workspace = true }
+rustc-hash = { workspace = true }
 
 [dev-dependencies]
 expect-test = { workspace = true }

compiler/qsc_data_structures/src/lib.rs

@@ -6,4 +6,5 @@ pub mod functors;
 pub mod index_map;
 pub mod language_features;
 pub mod line_column;
+pub mod namespaces;
 pub mod span;