Handle comments and bind registers and gates

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "openqasm-parser"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]

default.nix

@@ -0,0 +1,36 @@
+{ pkgs, localLib }:
+let
+  openqasm-parser = pkgs.rustPlatform.buildRustPackage {
+    pname = "openqasm-parser";
+    version = "0.2.0";
+    src = localLib.filters.cleanSourceWithFiles {
+      src = ./.;
+      files = [
+        "Cargo.toml"
+        "Cargo.lock"
+        "src/"
+      ];
+    };
+
+    cargoLock.lockFile = ./Cargo.lock;
+  };
+in
+{
+  packages = {
+    inherit openqasm-parser;
+  };
+
+  devShells = {
+    openqasm-parser = pkgs.mkShell {
+      inputsFrom = [
+        openqasm-parser
+      ];
+
+      buildInputs = with pkgs; [
+        rust-analyzer
+        rustfmt
+        clippy
+      ];
+    };
+  };
+}

flake.nix

@@ -14,36 +14,22 @@
     flake-utils.lib.eachDefaultSystem (system:
       let
         pkgs = nixpkgs.legacyPackages.${system};
+        localLib = import ./localLib { inherit pkgs; };
+        project = import ./. { inherit pkgs localLib; };
       in
       {
-        packages = {
-          openqasm-parser = pkgs.rustPlatform.buildRustPackage {
-            pname = "openqasm-parser";
-            version = "0.1.0";
-            src = self;
-
-            cargoLock.lockFile = ./Cargo.lock;
+        packages =
+          project.packages //
+          {
+            default = project.packages.openqasm-parser;
           };
 
-          default = self.packages.${system}.openqasm-parser;
-        };
-
-        devShells = {
-          openqasm-parser = pkgs.mkShell {
-            inputsFrom = [
-              self.packages.${system}.openqasm-parser
-            ];
-
-            buildInputs = with pkgs; [
-              rust-analyzer
-              rustfmt
-              clippy
-            ];
+        devShells =
+          project.devShells //
+          {
+            default = project.devShells.openqasm-parser;
           };
 
-          default = self.devShells.${system}.openqasm-parser;
-        };
-
         formatter = pkgs.nixpkgs-fmt;
       }
     );

localLib/default.nix

@@ -0,0 +1,4 @@
+{ pkgs }:
+{
+  filters = import ./filters.nix { inherit pkgs; };
+}

localLib/filters.nix

@@ -0,0 +1,28 @@
+{ pkgs }:
+let
+  testFiles = files: relPath:
+    let
+      filesHead = builtins.head files;
+      isDirectory = (builtins.substring ((builtins.stringLength filesHead) - 1) 1 filesHead) == "/";
+      current =
+        if isDirectory
+        then builtins.substring 0 ((builtins.stringLength filesHead) - 1) filesHead
+        else filesHead;
+    in
+    files != [ ] && (
+      relPath == current ||
+      (isDirectory && builtins.match "${current}/.*" relPath != null) ||
+      testFiles (builtins.tail files) relPath
+    );
+in
+{
+  cleanSourceWithFiles = { src, files }:
+    pkgs.lib.cleanSourceWith {
+      inherit src;
+      filter = path: type:
+        let
+          relPath = builtins.replaceStrings [ (toString src + "/") ] [ "" ] (toString path);
+        in
+        testFiles files relPath;
+    };
+}

src/ast/factory.rs

@@ -8,13 +8,15 @@ pub fn make_reg_dec(loc: Location, name: String, ty: node::RegTy, size: u32) ->
         name: name,
         ty: ty,
         size: size,
+        dec: None,
     })
 }
 
 pub fn make_simple_reg(loc: Location, name: String) -> node::Reg {
     node::Reg::SimpleReg {
         loc: loc,
         name: name,
+        dec: None,
     }
 }
 
@@ -23,6 +25,7 @@ pub fn make_subscript_reg(loc: Location, name: String, index: u32) -> node::Reg
         loc: loc,
         name: name,
         index: index,
+        dec: None,
     }
 }
 
@@ -37,6 +40,7 @@ pub fn make_gate_stmt(
         gate: gate,
         pars: pars,
         args: args,
+        dec: None,
     }
 }
 

src/ast/node.rs

@@ -1,3 +1,8 @@
+use std::rc::Rc;
+
+use crate::bind::gate;
+use crate::bind::reg;
+
 use crate::utils::location::Location;
 
 pub enum RegTy {
@@ -14,12 +19,22 @@ impl ToString for RegTy {
     }
 }
 
+impl Clone for RegTy {
+    fn clone(&self) -> Self {
+        match self {
+            Self::QReg => Self::QReg,
+            Self::CReg => Self::CReg,
+        }
+    }
+}
+
 pub enum Dec {
     RegDec {
         loc: Location,
         name: String,
         ty: RegTy,
         size: u32,
+        dec: Option<Rc<reg::RegDec>>,
     },
 }
 
@@ -31,6 +46,7 @@ impl Dec {
                 name: _,
                 ty: _,
                 size: _,
+                dec: _,
             } => &loc,
         }
     }
@@ -40,22 +56,29 @@ pub enum Reg {
     SimpleReg {
         loc: Location,
         name: String,
+        dec: Option<Rc<reg::RegDec>>,
     },
     SubscriptReg {
         loc: Location,
         name: String,
         index: u32,
+        dec: Option<Rc<reg::RegDec>>,
     },
 }
 
 impl Reg {
     pub fn get_loc(&self) -> &Location {
         match self {
-            Reg::SimpleReg { loc, name: _ } => &loc,
+            Reg::SimpleReg {
+                loc,
+                name: _,
+                dec: _,
+            } => &loc,
             Reg::SubscriptReg {
                 loc,
                 name: _,
                 index: _,
+                dec: _,
             } => &loc,
         }
     }
@@ -68,6 +91,7 @@ pub enum Stmt {
         gate: String,
         pars: Vec<Exp>,
         args: Vec<Reg>,
+        dec: Option<Rc<gate::GateDec>>,
     },
     MeasureStmt {
         loc: Location,
@@ -89,6 +113,7 @@ impl Stmt {
                 gate: _,
                 pars: _,
                 args: _,
+                dec: _,
             } => &loc,
             Stmt::MeasureStmt {
                 loc,

src/ast/pretty_printer.rs

@@ -13,18 +13,48 @@ impl Visitor for PrettyPrinter {
                 ref name,
                 ref ty,
                 size,
-            } => println!("{} {}[{}];", ty.to_string(), name, size),
+                ref dec,
+            } => {
+                if let Some(dec) = dec {
+                    println!(
+                        "{} {} /* {} */ [{}];",
+                        ty.to_string(),
+                        name,
+                        dec.to_string(),
+                        size
+                    )
+                } else {
+                    println!("{} {}[{}];", ty.to_string(), name, size)
+                }
+            }
         }
     }
 
     fn visit_reg(&mut self, e: &node::Reg) {
         match e {
-            &node::Reg::SimpleReg { loc: _, ref name } => print!("{}", name),
+            &node::Reg::SimpleReg {
+                loc: _,
+                ref name,
+                ref dec,
+            } => {
+                if let Some(dec) = dec {
+                    print!("{} /* {} */", name, dec.to_string())
+                } else {
+                    print!("{}", name)
+                }
+            }
             &node::Reg::SubscriptReg {
                 loc: _,
                 ref name,
                 index,
-            } => print!("{}[{}]", name, index),
+                ref dec,
+            } => {
+                if let Some(dec) = dec {
+                    print!("{} /* {} */ [{}]", name, dec.to_string(), index)
+                } else {
+                    print!("{}[{}]", name, index)
+                }
+            }
         }
     }
 
@@ -36,8 +66,12 @@ impl Visitor for PrettyPrinter {
                 ref gate,
                 ref pars,
                 ref args,
+                ref dec,
             } => {
                 print!("{} ", gate);
+                if let Some(dec) = dec {
+                    print!("/* {} */ ", dec.to_string());
+                }
                 if !pars.is_empty() {
                     print!("(");
                     self.visit_exp(&pars[0]);