Fix scoping resolution for defs

Author: idavis

compiler/qsc_qasm3/src/semantic/symbols.rs

@@ -447,7 +447,7 @@ impl SymbolTable {
         if let Some(scope) = last_false {
             if let Some((id, symbol)) = scope.get_symbol_by_name(name.as_ref()) {
                 if symbol.ty.is_const()
-                    || matches!(symbol.ty, Type::Gate(..) | Type::Void)
+                    || matches!(symbol.ty, Type::Gate(..) | Type::Void | Type::Function(..))
                     || self.is_scope_rooted_in_global()
                 {
                     return Some((id, symbol));
@@ -457,7 +457,9 @@ impl SymbolTable {
         // we should be at the global, function, or gate scope now
         for scope in scopes {
             if let Some((id, symbol)) = scope.get_symbol_by_name(name.as_ref()) {
-                if symbol.ty.is_const() || matches!(symbol.ty, Type::Gate(..) | Type::Void) {
+                if symbol.ty.is_const()
+                    || matches!(symbol.ty, Type::Gate(..) | Type::Void | Type::Function(..))
+                {
                     return Some((id, symbol));
                 }
             }

compiler/qsc_qasm3/src/tests/scopes.rs

@@ -54,3 +54,173 @@ fn cannot_access_mutable_decls_from_global_scope() {
     };
     expect![r#"Undefined symbol: i."#].assert_eq(&errors[0].to_string());
 }
+
+#[test]
+fn gates_can_call_previously_declared_gates() -> miette::Result<(), Vec<Report>> {
+    let source = r#"
+        include "stdgates.inc";
+        gate my_h q {
+            h q;
+        }
+        gate my_hx q {
+            my_h q;
+            x q;
+        }
+        qubit q;
+        my_hx q;
+    "#;
+
+    let qsharp = compile_qasm_to_qsharp(source)?;
+    expect![[r#"
+        import QasmStd.Angle.*;
+        import QasmStd.Convert.*;
+        import QasmStd.Intrinsic.*;
+        let my_h : (Qubit) => Unit = (q) => {
+            h(q);
+        };
+        let my_hx : (Qubit) => Unit = (q) => {
+            my_h(q);
+            x(q);
+        };
+        let q = QIR.Runtime.__quantum__rt__qubit_allocate();
+        my_hx(q);
+    "#]]
+    .assert_eq(&qsharp);
+    Ok(())
+}
+
+#[test]
+fn def_can_call_previously_declared_def() -> miette::Result<(), Vec<Report>> {
+    let source = r#"
+        include "stdgates.inc";
+        def apply_h(qubit q) {
+            h q;
+        }
+        def apply_hx(qubit q) {
+            apply_h(q);
+            x q;
+        }
+        qubit q;
+        apply_hx(q);
+    "#;
+
+    let qsharp = compile_qasm_to_qsharp(source)?;
+    expect![[r#"
+        import QasmStd.Angle.*;
+        import QasmStd.Convert.*;
+        import QasmStd.Intrinsic.*;
+        let apply_h : (Qubit) => Unit = (q) => {
+            h(q);
+        };
+        let apply_hx : (Qubit) => Unit = (q) => {
+            apply_h(q);
+            x(q);
+        };
+        let q = QIR.Runtime.__quantum__rt__qubit_allocate();
+        apply_hx(q);
+    "#]]
+    .assert_eq(&qsharp);
+    Ok(())
+}
+
+#[test]
+fn gate_can_call_previously_declared_def() -> miette::Result<(), Vec<Report>> {
+    let source = r#"
+        include "stdgates.inc";
+        def apply_h(qubit q) {
+            h q;
+        }
+        gate my_hx q {
+            apply_h(q);
+            x q;
+        }
+        qubit q;
+        my_hx q;
+    "#;
+
+    let qsharp = compile_qasm_to_qsharp(source)?;
+    expect![[r#"
+        import QasmStd.Angle.*;
+        import QasmStd.Convert.*;
+        import QasmStd.Intrinsic.*;
+        let apply_h : (Qubit) => Unit = (q) => {
+            h(q);
+        };
+        let my_hx : (Qubit) => Unit = (q) => {
+            apply_h(q);
+            x(q);
+        };
+        let q = QIR.Runtime.__quantum__rt__qubit_allocate();
+        my_hx(q);
+    "#]]
+    .assert_eq(&qsharp);
+    Ok(())
+}
+
+#[test]
+fn def_can_call_previously_declared_gate() -> miette::Result<(), Vec<Report>> {
+    let source = r#"
+        include "stdgates.inc";
+        gate my_h q {
+            h q;
+        }
+        def apply_hx(qubit q) {
+            my_h q;
+            x q;
+        }
+        qubit q;
+        apply_hx(q);
+    "#;
+
+    let qsharp = compile_qasm_to_qsharp(source)?;
+    expect![[r#"
+        import QasmStd.Angle.*;
+        import QasmStd.Convert.*;
+        import QasmStd.Intrinsic.*;
+        let my_h : (Qubit) => Unit = (q) => {
+            h(q);
+        };
+        let apply_hx : (Qubit) => Unit = (q) => {
+            my_h(q);
+            x(q);
+        };
+        let q = QIR.Runtime.__quantum__rt__qubit_allocate();
+        apply_hx(q);
+    "#]]
+    .assert_eq(&qsharp);
+    Ok(())
+}
+
+#[test]
+fn def_can_call_itself_recursively() -> miette::Result<(), Vec<Report>> {
+    let source = r#"
+        include "stdgates.inc";
+        def apply_hx(int limit, qubit q) {
+            if (limit > 0) {
+                apply_hx(limit - 1, q);
+                x q;
+            }
+            h q;
+        }
+        qubit q;
+        apply_hx(2, q);
+    "#;
+
+    let qsharp = compile_qasm_to_qsharp(source)?;
+    expect![[r#"
+        import QasmStd.Angle.*;
+        import QasmStd.Convert.*;
+        import QasmStd.Intrinsic.*;
+        let apply_hx : (Int, Qubit) => Unit = (limit, q) => {
+            if limit > 0 {
+                apply_hx(limit - 1, q);
+                x(q);
+            };
+            h(q);
+        };
+        let q = QIR.Runtime.__quantum__rt__qubit_allocate();
+        apply_hx(2, q);
+    "#]]
+    .assert_eq(&qsharp);
+    Ok(())
+}