Use hierarchical namespaces in name resolution

.gitignore

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

Cargo.toml

@@ -82,8 +82,8 @@ missing_panics_doc = "allow"
 module_name_repetitions = "allow"
 
 [profile.release]
-debug = 1
-strip = true
+debug = "limited"
+strip = "symbols"
 lto = "fat"
 codegen-units = 1
 

compiler/qsc/src/interpret/debug.rs

@@ -84,7 +84,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/interpret/tests.rs

@@ -1769,11 +1769,14 @@ mod given_interpreter {
             let path = Path {
                 id: NodeId::default(),
                 span: Span::default(),
-                namespace: Some(Box::new(qsc_ast::ast::Ident {
-                    id: NodeId::default(),
-                    span: Span::default(),
-                    name: ns.into(),
-                })),
+                namespace: Some(
+                    std::iter::once(qsc_ast::ast::Ident {
+                        id: NodeId::default(),
+                        span: Span::default(),
+                        name: ns.into(),
+                    })
+                    .collect(),
+                ),
                 name: Box::new(qsc_ast::ast::Ident {
                     id: NodeId::default(),
                     span: Span::default(),

compiler/qsc/src/lib.rs

@@ -35,7 +35,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::{lower_hir_to_fir, 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,93 @@ 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 FromIterator<Ident> for VecIdent {
+    fn from_iter<T: IntoIterator<Item = Ident>>(iter: T) -> Self {
+        VecIdent(iter.into_iter().collect())
+    }
+}
+
+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_codegen/src/qsharp.rs

@@ -17,7 +17,7 @@ use qsc_ast::ast::{
     self, Attr, BinOp, Block, CallableBody, CallableDecl, CallableKind, Expr, ExprKind, Functor,
     FunctorExpr, FunctorExprKind, Ident, Item, ItemKind, Lit, Mutability, Pat, PatKind, Path,
     Pauli, QubitInit, QubitInitKind, QubitSource, SetOp, SpecBody, SpecDecl, SpecGen, Stmt,
-    StmtKind, StringComponent, TernOp, TopLevelNode, Ty, TyDef, TyDefKind, TyKind, UnOp,
+    StmtKind, StringComponent, TernOp, TopLevelNode, Ty, TyDef, TyDefKind, TyKind, UnOp, VecIdent,
     Visibility, VisibilityKind,
 };
 use qsc_ast::ast::{Namespace, Package};
@@ -104,7 +104,7 @@ impl<W: Write> Visitor<'_> for QSharpGen<W> {
 
     fn visit_namespace(&mut self, namespace: &'_ Namespace) {
         self.write("namespace ");
-        self.visit_ident(&namespace.name);
+        self.visit_vec_ident(&namespace.name);
         self.writeln("{");
         namespace.items.iter().for_each(|i| {
             self.visit_item(i);
@@ -124,7 +124,7 @@ impl<W: Write> Visitor<'_> for QSharpGen<W> {
             ItemKind::Callable(decl) => self.visit_callable_decl(decl),
             ItemKind::Open(ns, alias) => {
                 self.write("open ");
-                self.visit_ident(ns);
+                self.visit_vec_ident(ns);
                 if let Some(alias) = alias {
                     self.write(" as ");
                     self.visit_ident(alias);
@@ -710,8 +710,8 @@ impl<W: Write> Visitor<'_> for QSharpGen<W> {
     }
 
     fn visit_path(&mut self, path: &'_ Path) {
-        for ns in &path.namespace {
-            self.visit_ident(ns);
+        if let Some(ns) = &path.namespace {
+            self.visit_vec_ident(ns);
             self.write(".");
         }
         self.visit_ident(&path.name);
@@ -720,6 +720,10 @@ impl<W: Write> Visitor<'_> for QSharpGen<W> {
     fn visit_ident(&mut self, id: &'_ Ident) {
         self.write(&id.name);
     }
+
+    fn visit_vec_ident(&mut self, vec_ident: &'_ VecIdent) {
+        self.write(&vec_ident.name());
+    }
 }
 
 fn binop_as_str(op: &BinOp) -> &str {

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;