Remove dead code

compiler/qsc/src/codegen.rs

@@ -5,7 +5,6 @@
 mod tests;
 
 pub mod qsharp {
-    pub use qsc_codegen::qsharp::write_item_string;
     pub use qsc_codegen::qsharp::write_package_string;
     pub use qsc_codegen::qsharp::write_stmt_string;
 }

compiler/qsc_codegen/src/qsharp.rs

@@ -61,22 +61,6 @@ pub fn write_package_string(package: &Package) -> String {
     format_str(&s)
 }
 
-#[must_use]
-pub fn write_item_string(item: &Item) -> String {
-    let mut output = Vec::new();
-    let mut gen = QSharpGen::new(&mut output);
-
-    gen.visit_item(item);
-
-    let s = match std::str::from_utf8(&output) {
-        Ok(v) => v.to_owned(),
-        Err(e) => format!("Invalid UTF-8 sequence: {e}"),
-    };
-
-    output.clear();
-    format_str(&s)
-}
-
 #[must_use]
 pub fn write_stmt_string(stmt: &ast::Stmt) -> String {
     let mut output = Vec::new();

compiler/qsc_qasm3/src/ast_builder.rs

@@ -248,6 +248,8 @@ pub(crate) fn build_expr_array_expr(values: Vec<qsc_ast::ast::Expr>, span: Span)
     }
 }
 
+// This will be used to compile arrays in the near future.
+#[allow(dead_code)]
 pub(crate) fn build_default_result_array_expr(len: usize, span: Span) -> Expr {
     let exprs: Vec<_> = (0..len)
         .map(|_| Box::new(build_lit_result_expr(ast::Result::Zero, Span::default())))
@@ -363,35 +365,6 @@ pub(crate) fn build_binary_expr(
     }
 }
 
-pub(crate) fn is_complex_binop_supported(op: qsc_ast::ast::BinOp) -> bool {
-    matches!(
-        op,
-        ast::BinOp::Add | ast::BinOp::Sub | ast::BinOp::Mul | ast::BinOp::Div | ast::BinOp::Exp
-    )
-}
-
-pub(crate) fn build_complex_binary_expr(
-    is_assignment: bool,
-    qsop: ast::BinOp,
-    lhs: ast::Expr,
-    rhs: ast::Expr,
-    span: Span,
-) -> ast::Expr {
-    let name = match qsop {
-        ast::BinOp::Add => "PlusC",
-        ast::BinOp::Sub => "MinusC",
-        ast::BinOp::Mul => "TimesC",
-        ast::BinOp::Div => "DividedByC",
-        ast::BinOp::Exp => "PowC",
-        _ => unreachable!("Unsupported complex binary operation"),
-    };
-
-    if is_assignment {
-        unreachable!("Unsupported complex binary operation");
-    }
-    build_math_call_from_exprs(name, vec![lhs, rhs], span)
-}
-
 pub(crate) fn build_math_call_from_exprs(name: &str, exprs: Vec<Expr>, span: Span) -> Expr {
     let alloc_ident = Ident {
         name: Rc::from(name),
@@ -942,14 +915,6 @@ pub(crate) fn build_wrapped_block_expr(block: Block) -> Expr {
     }
 }
 
-pub(crate) fn build_stmt_wrapped_block_expr(stmt: Stmt) -> Block {
-    Block {
-        id: NodeId::default(),
-        span: stmt.span,
-        stmts: Box::new([Box::new(stmt)]),
-    }
-}
-
 pub(crate) fn build_expr_wrapped_block_expr(expr: Expr) -> Block {
     Block {
         id: NodeId::default(),
@@ -1185,14 +1150,6 @@ pub(crate) fn build_top_level_ns_with_items<S: AsRef<str>>(
     })
 }
 
-pub(crate) fn build_top_level_ns_with_item<S: AsRef<str>>(
-    whole_span: Span,
-    ns: S,
-    entry: ast::Item,
-) -> TopLevelNode {
-    build_top_level_ns_with_items(whole_span, ns, vec![entry])
-}
-
 pub(crate) fn build_operation_with_stmts<S: AsRef<str>>(
     name: S,
     input_pats: Vec<Pat>,
@@ -1459,200 +1416,6 @@ pub(crate) fn build_barrier_call(span: Span) -> Stmt {
     build_stmt_semi_from_expr(expr)
 }
 
-pub(crate) fn build_gate_decl(
-    name: String,
-    cargs: Vec<(String, Ty, Pat)>,
-    qargs: Vec<(String, Ty, Pat)>,
-    body: Option<Block>,
-    name_span: Span,
-    body_span: Span,
-    gate_span: Span,
-) -> Stmt {
-    let args = cargs
-        .into_iter()
-        .chain(qargs)
-        .map(|(_, _, pat)| Box::new(pat))
-        .collect::<Vec<_>>();
-
-    let lo = args
-        .iter()
-        .min_by_key(|x| x.span.lo)
-        .map(|x| x.span.lo)
-        .unwrap_or_default();
-
-    let hi = args
-        .iter()
-        .max_by_key(|x| x.span.hi)
-        .map(|x| x.span.hi)
-        .unwrap_or_default();
-
-    let input_pat_kind = if args.len() > 1 {
-        PatKind::Tuple(args.into_boxed_slice())
-    } else {
-        PatKind::Paren(args[0].clone())
-    };
-
-    let input_pat = Pat {
-        kind: Box::new(input_pat_kind),
-        span: Span { lo, hi },
-        ..Default::default()
-    };
-    let body = CallableBody::Block(Box::new(body.unwrap_or_else(|| Block {
-        id: NodeId::default(),
-        span: body_span,
-        stmts: Box::new([]),
-    })));
-    let decl = CallableDecl {
-        id: NodeId::default(),
-        span: name_span,
-        kind: CallableKind::Operation,
-        name: Box::new(Ident {
-            name: name.into(),
-            ..Default::default()
-        }),
-        generics: Box::new([]),
-        input: Box::new(input_pat),
-        output: Box::new(build_path_ident_ty("Unit")),
-        functors: None,
-        body: Box::new(body),
-    };
-    let item = Item {
-        span: gate_span,
-        kind: Box::new(ast::ItemKind::Callable(Box::new(decl))),
-        ..Default::default()
-    };
-
-    Stmt {
-        kind: Box::new(StmtKind::Item(Box::new(item))),
-        span: gate_span,
-        ..Default::default()
-    }
-}
-
-#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
-pub(crate) fn build_lambda<S: AsRef<str>>(
-    name: S,
-    cargs: Vec<(String, Ty, Pat)>,
-    qargs: Vec<(String, Ty, Pat)>,
-    body: Option<Block>,
-    name_span: Span,
-    body_span: Span,
-    gate_span: Span,
-    return_type: Option<Ty>,
-    kind: CallableKind,
-) -> Stmt {
-    let args = cargs
-        .into_iter()
-        .chain(qargs)
-        .map(|(name, ty, pat)| (name, ty, pat.span))
-        .collect::<Vec<_>>();
-
-    let lo = args
-        .iter()
-        .min_by_key(|(_, _, span)| span.lo)
-        .map(|(_, _, span)| span.lo)
-        .unwrap_or_default();
-
-    let hi = args
-        .iter()
-        .max_by_key(|(_, _, span)| span.hi)
-        .map(|(_, _, span)| span.hi)
-        .unwrap_or_default();
-
-    let name_args = args
-        .iter()
-        .map(|(name, _, span)| Pat {
-            kind: Box::new(PatKind::Bind(
-                Box::new(Ident {
-                    span: *span,
-                    name: Rc::from(name.as_ref()),
-                    ..Default::default()
-                }),
-                None,
-            )),
-            ..Default::default()
-        })
-        .map(Box::new)
-        .collect::<Vec<_>>();
-    let input_pat = if args.len() == 1 {
-        ast::Pat {
-            kind: Box::new(ast::PatKind::Paren(name_args[0].clone())),
-            span: Span { lo, hi },
-            ..Default::default()
-        }
-    } else {
-        ast::Pat {
-            kind: Box::new(PatKind::Tuple(name_args.into_boxed_slice())),
-            span: Span { lo, hi },
-            ..Default::default()
-        }
-    };
-
-    let block_expr = build_wrapped_block_expr(body.map_or_else(
-        || Block {
-            id: NodeId::default(),
-            span: body_span,
-            stmts: Box::new([]),
-        },
-        |block| block,
-    ));
-    let lambda_expr = Expr {
-        id: NodeId::default(),
-        kind: Box::new(ExprKind::Lambda(
-            kind,
-            Box::new(input_pat),
-            Box::new(block_expr),
-        )),
-        span: gate_span,
-    };
-    let ty_args = args.iter().map(|(_, ty, _)| ty.clone()).collect::<Vec<_>>();
-    let input_ty = if args.len() == 1 {
-        ast::Ty {
-            kind: Box::new(ast::TyKind::Paren(Box::new(ty_args[0].clone()))),
-            ..Default::default()
-        }
-    } else {
-        ast::Ty {
-            kind: Box::new(ast::TyKind::Tuple(ty_args.into_boxed_slice())),
-            ..Default::default()
-        }
-    };
-    let return_type = if let Some(ty) = return_type {
-        ty
-    } else {
-        build_path_ident_ty("Unit")
-    };
-
-    let lambda_ty = ast::Ty {
-        kind: Box::new(ast::TyKind::Arrow(
-            kind,
-            Box::new(input_ty),
-            Box::new(return_type),
-            None,
-        )),
-        ..Default::default()
-    };
-    Stmt {
-        span: gate_span,
-        kind: Box::new(StmtKind::Local(
-            Mutability::Immutable,
-            Box::new(Pat {
-                kind: Box::new(PatKind::Bind(
-                    Box::new(Ident {
-                        span: name_span,
-                        name: Rc::from(name.as_ref()),
-                        ..Default::default()
-                    }),
-                    Some(Box::new(lambda_ty)),
-                )),
-                ..Default::default()
-            }),
-            Box::new(lambda_expr),
-        )),
-        ..Default::default()
-    }
-}
-
 #[allow(clippy::too_many_arguments, clippy::too_many_lines)]
 pub(crate) fn build_function_or_operation(
     name: String,

compiler/qsc_qasm3/src/compiler.rs

@@ -22,17 +22,18 @@ use crate::{
         build_gate_call_with_params_and_callee, build_global_call_with_two_params,
         build_if_expr_then_block, build_if_expr_then_block_else_block,
         build_if_expr_then_block_else_expr, build_if_expr_then_expr_else_expr,
-        build_implicit_return_stmt, build_indexed_assignment_statement, build_lit_angle_expr,
-        build_lit_bigint_expr, build_lit_bool_expr, build_lit_complex_expr, build_lit_double_expr,
-        build_lit_int_expr, build_lit_result_array_expr_from_bitstring, build_lit_result_expr,
-        build_managed_qubit_alloc, build_math_call_from_exprs, build_math_call_no_params,
-        build_measure_call, build_operation_with_stmts, build_path_ident_expr, build_path_ident_ty,
-        build_qasm_import_decl, build_qasm_import_items, build_range_expr, build_reset_call,
-        build_return_expr, build_return_unit, build_stmt_semi_from_expr,
-        build_stmt_semi_from_expr_with_span, build_top_level_ns_with_items, build_tuple_expr,
-        build_unary_op_expr, build_unmanaged_qubit_alloc, build_unmanaged_qubit_alloc_array,
-        build_while_stmt, build_wrapped_block_expr, managed_qubit_alloc_array,
-        map_qsharp_type_to_ast_ty, wrap_expr_in_parens,
+        build_implicit_return_stmt, build_index_expr, build_indexed_assignment_statement,
+        build_lit_angle_expr, build_lit_bigint_expr, build_lit_bool_expr, build_lit_complex_expr,
+        build_lit_double_expr, build_lit_int_expr, build_lit_result_array_expr_from_bitstring,
+        build_lit_result_expr, build_managed_qubit_alloc, build_math_call_from_exprs,
+        build_math_call_no_params, build_measure_call, build_operation_with_stmts,
+        build_path_ident_expr, build_path_ident_ty, build_qasm_import_decl,
+        build_qasm_import_items, build_range_expr, build_reset_call, build_return_expr,
+        build_return_unit, build_stmt_semi_from_expr, build_stmt_semi_from_expr_with_span,
+        build_top_level_ns_with_items, build_tuple_expr, build_unary_op_expr,
+        build_unmanaged_qubit_alloc, build_unmanaged_qubit_alloc_array, build_while_stmt,
+        build_wrapped_block_expr, managed_qubit_alloc_array, map_qsharp_type_to_ast_ty,
+        wrap_expr_in_parens,
     },
     io::SourceResolver,
     parser::ast::{list_from_iter, List},
@@ -1221,14 +1222,7 @@ impl QasmCompiler {
 
         let ident =
             build_path_ident_expr(&symbol.name, indexed_ident.name_span, indexed_ident.span);
-        qsast::Expr {
-            id: qsast::NodeId::default(),
-            span,
-            kind: Box::new(qsast::ExprKind::Index(
-                Box::new(ident),
-                Box::new(index[0].clone()),
-            )),
-        }
+        build_index_expr(ident, index[0].clone(), span)
     }
 
     fn compile_unary_op_expr(&mut self, unary: &UnaryOpExpr) -> qsast::Expr {