Allow implicit top-level namespaces when parsing files

.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/compile.rs

@@ -33,6 +33,7 @@ pub enum ErrorKind {
     Lint(#[from] qsc_linter::Lint),
 }
 
+/// Compiles a package from its AST representation.
 #[must_use]
 #[allow(clippy::module_name_repetitions)]
 pub fn compile_ast(
@@ -54,6 +55,7 @@ pub fn compile_ast(
     process_compile_unit(store, package_type, capabilities, unit)
 }
 
+/// Compiles a package from its source representation.
 #[must_use]
 pub fn compile(
     store: &PackageStore,

compiler/qsc/src/interpret/debug.rs

@@ -10,6 +10,7 @@ use qsc_frontend::compile::PackageStore;
 use qsc_hir::hir;
 use qsc_hir::hir::{Item, ItemKind};
 use qsc_lowerer::map_fir_package_to_hir;
+use std::rc::Rc;
 
 #[must_use]
 pub(crate) fn format_call_stack(
@@ -82,10 +83,9 @@ 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())
-    } else {
-        None
-    }
+fn get_ns_name(item: &Item) -> Option<Rc<str>> {
+    let ItemKind::Namespace(ns, _) = &item.kind else {
+        return None;
+    };
+    Some(ns.name())
 }

compiler/qsc/src/interpret/tests.rs

@@ -1785,11 +1785,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

@@ -34,7 +34,7 @@ pub mod project {
 }
 
 pub use qsc_data_structures::{
-    language_features::LanguageFeatures, span::Span, target::TargetCapabilityFlags,
+    language_features::LanguageFeatures, namespaces::*, span::Span, target::TargetCapabilityFlags,
 };
 
 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: Idents,
     /// 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(Idents, 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<Idents>,
     /// The declaration name.
     pub name: Box<Ident>,
 }
@@ -1306,6 +1306,133 @@ pub struct Ident {
     pub name: Rc<str>,
 }
 
+/// A [`Idents`] 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 Idents(pub Box<[Ident]>);
+
+impl From<Idents> for Vec<Rc<str>> {
+    fn from(v: Idents) -> Self {
+        v.0.iter().map(|i| i.name.clone()).collect()
+    }
+}
+
+impl From<&Idents> for Vec<Rc<str>> {
+    fn from(v: &Idents) -> Self {
+        v.0.iter().map(|i| i.name.clone()).collect()
+    }
+}
+
+impl From<Vec<Ident>> for Idents {
+    fn from(v: Vec<Ident>) -> Self {
+        Idents(v.into_boxed_slice())
+    }
+}
+
+impl From<Idents> for Vec<Ident> {
+    fn from(v: Idents) -> Self {
+        v.0.to_vec()
+    }
+}
+
+impl Display for Idents {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let mut buf = Vec::with_capacity(self.0.len());
+
+        for ident in self.0.iter() {
+            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 Idents {
+    type IntoIter = std::slice::Iter<'a, Ident>;
+    type Item = &'a Ident;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a> From<&'a Idents> for IdentsStrIter<'a> {
+    fn from(v: &'a Idents) -> Self {
+        IdentsStrIter(v)
+    }
+}
+
+/// An iterator which yields string slices of the names of the idents in a [`Idents`].
+/// Note that [`Idents`] itself only implements [`IntoIterator`] where the item is an [`Ident`].
+pub struct IdentsStrIter<'a>(pub &'a Idents);
+
+impl<'a> IntoIterator for IdentsStrIter<'a> {
+    type IntoIter = std::iter::Map<std::slice::Iter<'a, Ident>, fn(&'a Ident) -> &'a str>;
+    type Item = &'a str;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter().map(|i| i.name.as_ref())
+    }
+}
+
+impl FromIterator<Ident> for Idents {
+    fn from_iter<T: IntoIterator<Item = Ident>>(iter: T) -> Self {
+        Idents(iter.into_iter().collect())
+    }
+}
+
+impl From<Path> for Idents {
+    fn from(p: Path) -> Self {
+        let mut buf = p.namespace.unwrap_or_default().0.to_vec();
+        buf.push(*p.name);
+        Self(buf.into_boxed_slice())
+    }
+}
+
+impl Idents {
+    /// constructs an iterator over the [Ident]s that this contains.
+    /// see [`Self::str_iter`] for an iterator over the string slices of the [Ident]s.
+    pub fn iter(&self) -> std::slice::Iter<'_, Ident> {
+        self.0.iter()
+    }
+
+    /// constructs an iterator over the elements of `self` as string slices.
+    /// see [`Self::iter`] for an iterator over the [Ident]s.
+    #[must_use]
+    pub fn str_iter(&self) -> IdentsStrIter {
+        self.into()
+    }
+
+    /// the conjoined span of all idents in the `Idents`
+    #[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 [`Idents`]
+    /// E.g. `a.b.c`
+    #[must_use]
+    pub fn name(&self) -> Rc<str> {
+        if self.0.len() == 1 {
+            return self.0[0].name.clone();
+        }
+        let mut buf = String::new();
+        for ident in self.0.iter() {
+            if !buf.is_empty() {
+                buf.push('.');
+            }
+            buf.push_str(&ident.name);
+        }
+        Rc::from(buf)
+    }
+}
+
 impl Default for Ident {
     fn default() -> Self {
         Ident {

compiler/qsc_ast/src/mut_visit.rs

@@ -76,6 +76,10 @@ pub trait MutVisitor: Sized {
         walk_ident(self, ident);
     }
 
+    fn visit_idents(&mut self, ident: &mut crate::ast::Idents) {
+        walk_idents(self, ident);
+    }
+
     fn visit_span(&mut self, _: &mut Span) {}
 }
 
@@ -89,7 +93,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_idents(&mut namespace.name);
+
     namespace.items.iter_mut().for_each(|i| vis.visit_item(i));
 }
 
@@ -104,7 +109,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_idents(ns);
             alias.iter_mut().for_each(|a| vis.visit_ident(a));
         }
         ItemKind::Ty(ident, def) => {
@@ -333,10 +338,18 @@ 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 ns) = path.namespace {
+        vis.visit_idents(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_idents(vis: &mut impl MutVisitor, ident: &mut crate::ast::Idents) {
+    for ref mut ident in ident.0.iter_mut() {
+        vis.visit_ident(ident);
+    }
+}

compiler/qsc_ast/src/visit.rs

@@ -3,9 +3,9 @@
 
 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,
+    Idents, Item, ItemKind, Namespace, Package, Pat, PatKind, Path, QubitInit, QubitInitKind,
+    SpecBody, SpecDecl, Stmt, StmtKind, StringComponent, TopLevelNode, Ty, TyDef, TyDefKind,
+    TyKind, Visibility,
 };
 
 pub trait Visitor<'a>: Sized {
@@ -72,6 +72,10 @@ pub trait Visitor<'a>: Sized {
     }
 
     fn visit_ident(&mut self, _: &'a Ident) {}
+
+    fn visit_idents(&mut self, idents: &'a Idents) {
+        walk_idents(self, idents);
+    }
 }
 
 pub fn walk_package<'a>(vis: &mut impl Visitor<'a>, package: &'a Package) {
@@ -83,7 +87,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_idents(&namespace.name);
     namespace.items.iter().for_each(|i| vis.visit_item(i));
 }
 
@@ -94,7 +98,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_idents(ns);
             alias.iter().for_each(|a| vis.visit_ident(a));
         }
         ItemKind::Ty(ident, def) => {
@@ -300,6 +304,12 @@ 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_idents(ns);
+    }
     vis.visit_ident(&path.name);
 }
+
+pub fn walk_idents<'a>(vis: &mut impl Visitor<'a>, idents: &'a Idents) {
+    idents.iter().for_each(|i| vis.visit_ident(i));
+}

compiler/qsc_circuit/src/operations/tests.rs

@@ -32,7 +32,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
         }
@@ -46,7 +46,7 @@ fn compile_one_operation(code: &str) -> (Item, String) {
     );
     (
         only_callable.clone(),
-        format!("{only_namespace}.{callable_name}"),
+        format!("{}.{callable_name}", only_namespace.name()),
     )
 }