renaming, refactor QasmListener.measure

Author: Guen Prawiroatmodjo

src/main.rs

@@ -8,8 +8,10 @@ use std::fs::File;
 use std::io::prelude::*;
 use qasm::{process, lex, parse};
 use qir_translator::qasm2qir::listener::QasmListener;
+use log;
 
 fn main() {
+    log::info!("Test");
     let cwd = env::current_dir().unwrap();
     let mut source = String::new();
 
@@ -40,6 +42,9 @@ fn main() {
         }
     }
 
-    println!("Emitted QIR:");
-    println!("{:?}", listener.get_ir_string());
+    // println!("Emitted QIR:");
+    // println!("{:?}", listener.get_ir_string());
+    let file_name = "test.ll";
+    let result = listener.write_model_to_file(file_name.to_string());
+    println!("{:?}", result);
 }

src/qasm2qir/arguments.rs

@@ -1,28 +1,28 @@
 use qasm::Argument;
 
-pub struct QubitRef(pub String, pub i32);
-impl QubitRef {
+pub struct Register(pub String, pub i32);
+impl Register {
     pub fn as_qir_name(&self) -> String {
         format!("{}{}", self.0, self.1)
     }
 }
 
 // Needed so that we have a local type to avoid the orphan rule for
 // trait coherence.
-pub struct Pair<T, U>(pub T, pub U);
+pub struct Pair<Register1, Register2>(pub Register1, pub Register2);
 
-impl TryFrom<&Argument> for QubitRef {
+impl TryFrom<&Argument> for Register {
     type Error = String;
 
     fn try_from(value: &Argument) -> Result<Self, Self::Error> {
         match value {
-            Argument::Qubit(name, idx) => Ok(QubitRef(name.to_owned(), *idx)),
+            Argument::Qubit(name, idx) => Ok(Register(name.to_owned(), *idx)),
             _ => Err(format!("Expected qubit argument, got {:?}.", value))
         }
     }
 }
 
-impl TryFrom<&Vec<Argument>> for QubitRef {
+impl TryFrom<&Vec<Argument>> for Register {
     type Error = String;
 
     fn try_from(value: &Vec<Argument>) -> Result<Self, Self::Error> {
@@ -33,7 +33,7 @@ impl TryFrom<&Vec<Argument>> for QubitRef {
     }
 }
 
-impl TryFrom<&Vec<Argument>> for Pair<QubitRef, QubitRef> {
+impl TryFrom<&Vec<Argument>> for Pair<Register, Register> {
     type Error = String;
 
     fn try_from(value: &Vec<Argument>) -> Result<Self, Self::Error> {

src/qasm2qir/listener.rs

@@ -1,15 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 // This code was based on pyqir_generator::python::PyQIR
-use pyqir_generator::emit::get_ir_string;
+use pyqir_generator::emit::{get_ir_string, write_model_to_file};
 use pyqir_generator::interop::{
     ClassicalRegister, Controlled, Instruction, Measured, QuantumRegister, Rotated, SemanticModel,
     Single,
 };
 use qasm::{Argument, AstNode};
 use log;
 
-use crate::qasm2qir::arguments::{QubitRef, Pair};
+use crate::qasm2qir::arguments::{Register, Pair};
 
 pub struct QasmListener {
     pub(super) model: SemanticModel,
@@ -26,6 +26,10 @@ impl QasmListener {
         return get_ir_string(&self.model);
     }
 
+    pub fn write_model_to_file(&mut self, file_name: String ) -> Result<(), String> {
+        return write_model_to_file(&self.model, &file_name)
+    }
+
     pub fn cx(&mut self, control: String, target: String) {
         log::info!("cx {} => {}", control, target);
         let controlled = Controlled::new(control, target);
@@ -159,18 +163,19 @@ impl QasmListener {
     }
 
     pub fn measure(&mut self, qubit: Argument, register: Argument) {
-        if let Argument::Qubit(_name, _idx) = qubit {
-            if let Argument::Register(_reg_name) = register {
-                self.m(format!("{}{}", _name, _idx), format!("{}0", _reg_name));
-            }
-        }
+        let qubit: Register = (&qubit).try_into().unwrap();
+        let register: Register = (&register).try_into().unwrap();
+        self.m(
+            qubit.as_qir_name(),
+            register.as_qir_name()
+        );
     }
-    
+
     pub fn apply_gate(&mut self, name: String, qubits: Vec<Argument>) {
         println!("{:?}", name);
 
         if name == "h" {
-            let qubit: QubitRef = (&qubits).try_into().unwrap();
+            let qubit: Register = (&qubits).try_into().unwrap();
             self.h(qubit.as_qir_name());
         } else if name == "CX" {
             let Pair(control, target) =