Perform Type-Checking on the AST

src/bind/binder.rs

@@ -109,14 +109,14 @@ impl Binder {
                 Rc::new(ParDec::new(String::from("phi"))),
                 Rc::new(ParDec::new(String::from("lambda"))),
             ],
-            vec![Rc::new(RegDec::new(String::from("qubit"), RegTy::QReg, 1))],
+            vec![Rc::new(RegDec::new_bit(String::from("qubit"), RegTy::QReg))],
         ));
         let cxgate = Rc::new(GateDec::new(
             String::from("CX"),
             vec![],
             vec![
-                Rc::new(RegDec::new(String::from("control"), RegTy::QReg, 1)),
-                Rc::new(RegDec::new(String::from("target"), RegTy::QReg, 1)),
+                Rc::new(RegDec::new_bit(String::from("control"), RegTy::QReg)),
+                Rc::new(RegDec::new_bit(String::from("target"), RegTy::QReg)),
             ],
         ));
 

src/bind/gate.rs

@@ -4,10 +4,13 @@ use std::vec::Vec;
 use crate::bind::par::ParDec;
 use crate::bind::reg::RegDec;
 
+use crate::typing::ty::Ty;
+
 pub struct GateDec {
     name: String,
     pars: Vec<Rc<ParDec>>,
     args: Vec<Rc<RegDec>>,
+    ty: Ty,
 }
 
 impl ToString for GateDec {
@@ -32,14 +35,20 @@ impl ToString for GateDec {
 
 impl GateDec {
     pub fn new(name: String, pars: Vec<Rc<ParDec>>, args: Vec<Rc<RegDec>>) -> GateDec {
+        let ty = Ty::GateTy(pars.len() as u32, args.len() as u32);
         GateDec {
             name: name,
             pars: pars,
             args: args,
+            ty: ty,
         }
     }
 
     pub fn get_name(&self) -> &String {
         &self.name
     }
+
+    pub fn get_ty(&self) -> &Ty {
+        &self.ty
+    }
 }

src/bind/reg.rs

@@ -1,33 +1,44 @@
 use crate::ast::node::RegTy;
 
+use crate::typing::ty::Ty;
+
 pub struct RegDec {
     name: String,
-    ty: RegTy,
-    size: u32,
+    ty: Ty,
 }
 
 impl ToString for RegDec {
     fn to_string(&self) -> String {
-        format!(
-            "{:p} ({},{},{})",
-            self,
-            self.ty.to_string(),
-            self.name,
-            self.size
-        )
+        format!("{:p} ({},{})", self, self.ty.to_string(), self.name)
     }
 }
 
 impl RegDec {
     pub fn new(name: String, ty: RegTy, size: u32) -> RegDec {
         RegDec {
             name: name,
-            ty: ty,
-            size: size,
+            ty: match ty {
+                RegTy::QReg => Ty::QRegTy(size),
+                RegTy::CReg => Ty::CRegTy(size),
+            },
+        }
+    }
+
+    pub fn new_bit(name: String, ty: RegTy) -> RegDec {
+        RegDec {
+            name: name,
+            ty: match ty {
+                RegTy::QReg => Ty::QubitTy,
+                RegTy::CReg => Ty::BitTy,
+            },
         }
     }
 
     pub fn get_name(&self) -> &String {
         &self.name
     }
+
+    pub fn get_ty(&self) -> &Ty {
+        &self.ty
+    }
 }

src/main.rs

@@ -1,6 +1,7 @@
 pub mod ast;
 pub mod bind;
 pub mod parse;
+pub mod typing;
 pub mod utils;
 
 use std::process;
@@ -12,22 +13,27 @@ use crate::bind::binder::Binder;
 use crate::parse::lexer::Lexer;
 use crate::parse::parser::Parser;
 
+use crate::typing::type_checker::TypeChecker;
+
 use crate::utils::error::{CompoundError, Error};
 
 fn main() {
     let lexer = Lexer::new(String::from("<stdin>"), std::io::stdin());
     let mut parser = Parser::new(lexer);
     let mut binder = Binder::new();
+    let mut type_checker = TypeChecker::new();
 
     if let Some(program) = &mut parser.parse_input() {
         binder.bind(program);
+        type_checker.check_types(program);
 
         PrettyPrinter.pretty_print(program);
     }
 
     let mut error = CompoundError::new();
     error.consume(parser.get_error_mut());
     error.consume(binder.get_error_mut());
+    error.consume(type_checker.get_error_mut());
 
     if !error.empty() {
         eprintln!("{}", error.get_desc());

src/typing/mod.rs

@@ -0,0 +1,2 @@
+pub mod ty;
+pub mod type_checker;

src/typing/ty.rs

@@ -0,0 +1,31 @@
+pub enum Ty {
+    QubitTy,
+    QRegTy(u32),
+    BitTy,
+    CRegTy(u32),
+    GateTy(u32, u32),
+}
+
+impl Clone for Ty {
+    fn clone(&self) -> Ty {
+        match self {
+            Ty::QubitTy => Ty::QubitTy,
+            Ty::QRegTy(size) => Ty::QRegTy(*size),
+            Ty::BitTy => Ty::BitTy,
+            Ty::CRegTy(size) => Ty::CRegTy(*size),
+            Ty::GateTy(pars, args) => Ty::GateTy(*pars, *args),
+        }
+    }
+}
+
+impl ToString for Ty {
+    fn to_string(&self) -> String {
+        match self {
+            Ty::QubitTy => String::from("qubit_ty"),
+            Ty::QRegTy(size) => format!("qreg_ty[{}]", size),
+            Ty::BitTy => String::from("bit_ty"),
+            Ty::CRegTy(size) => format!("creg_ty[{}]", size),
+            Ty::GateTy(pars, args) => format!("gate_ty[{},{}]", pars, args),
+        }
+    }
+}