feat: parse and display Gate directly

Author: kalzoo

src/instruction.rs

@@ -20,6 +20,7 @@ use std::str::FromStr;
 use std::{collections::HashMap, fmt};
 
 use crate::expression::Expression;
+use crate::parser::gate::parse_gate;
 use crate::parser::{common::parse_memory_reference, lex, ParseError};
 use crate::program::{disallow_leftover, frame::FrameMatchCondition, SyntaxError};
 
@@ -361,6 +362,35 @@ pub struct Gate {
     pub modifiers: Vec<GateModifier>,
 }
 
+impl std::fmt::Display for Gate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let parameter_str = get_expression_parameter_string(&self.parameters);
+
+        let qubit_str = format_qubits(&self.qubits);
+        let modifier_str = self
+            .modifiers
+            .iter()
+            .map(|m| format!("{} ", m))
+            .collect::<Vec<String>>()
+            .join("");
+        write!(
+            f,
+            "{}{}{} {}",
+            modifier_str, self.name, parameter_str, qubit_str
+        )
+    }
+}
+
+impl FromStr for Gate {
+    type Err = SyntaxError<Self>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let input = LocatedSpan::new(s);
+        let tokens = lex(input)?;
+        disallow_leftover(parse_gate(&tokens).map_err(ParseError::from_nom_internal_err))
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct CircuitDefinition {
     pub name: String,
@@ -837,21 +867,8 @@ impl fmt::Display for Instruction {
                     .map(|(k, v)| format!("\n\t{}: {}", k, v))
                     .collect::<String>()
             ),
-            Instruction::Gate(Gate {
-                name,
-                parameters,
-                qubits,
-                modifiers,
-            }) => {
-                let parameter_str = get_expression_parameter_string(parameters);
-
-                let qubit_str = format_qubits(qubits);
-                let modifier_str = modifiers
-                    .iter()
-                    .map(|m| format!("{} ", m))
-                    .collect::<Vec<String>>()
-                    .join("");
-                write!(f, "{}{}{} {}", modifier_str, name, parameter_str, qubit_str)
+            Instruction::Gate(gate) => {
+                write!(f, "{gate}")
             }
             Instruction::GateDefinition(GateDefinition {
                 name,

src/parser/gate.rs

@@ -14,7 +14,7 @@
 
 use nom::{combinator::opt, multi::many0, multi::separated_list0, sequence::delimited};
 
-use crate::{instruction::Instruction, token};
+use crate::token;
 
 use super::{
     common::{self, parse_gate_modifier},
@@ -25,7 +25,7 @@ use crate::instruction::Gate;
 use crate::parser::InternalParserResult;
 
 /// Parse a gate instruction.
-pub(crate) fn parse_gate<'a>(input: ParserInput<'a>) -> InternalParserResult<'a, Instruction> {
+pub(crate) fn parse_gate<'a>(input: ParserInput<'a>) -> InternalParserResult<'a, Gate> {
     let (input, modifiers) = many0(parse_gate_modifier)(input)?;
     let (input, name) = token!(Identifier(v))(input)?;
     let (input, parameters) = opt(delimited(
@@ -37,12 +37,12 @@ pub(crate) fn parse_gate<'a>(input: ParserInput<'a>) -> InternalParserResult<'a,
     let (input, qubits) = many0(common::parse_qubit)(input)?;
     Ok((
         input,
-        Instruction::Gate(Gate {
+        Gate {
             name,
             parameters,
             qubits,
             modifiers,
-        }),
+        },
     ))
 }
 
@@ -58,11 +58,11 @@ mod test {
         test_modifiers,
         parse_gate,
         "DAGGER CONTROLLED RX(pi) 0 1",
-        Instruction::Gate(Gate {
+        Gate {
             name: "RX".to_string(),
             parameters: vec![Expression::PiConstant],
             qubits: vec![Qubit::Fixed(0), Qubit::Fixed(1)],
             modifiers: vec![GateModifier::Dagger, GateModifier::Controlled],
-        })
+        }
     );
 }

src/parser/instruction.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use nom::{
-    combinator::all_consuming,
+    combinator::{all_consuming, map},
     multi::{many0, many1},
     sequence::{delimited, preceded},
 };
@@ -111,7 +111,7 @@ pub(crate) fn parse_instruction(input: ParserInput) -> InternalParserResult<Inst
             },
             _ => todo!(),
         },
-        Some((Token::Identifier(_), _)) | Some((Token::Modifier(_), _)) => gate::parse_gate(input),
+        Some((Token::Identifier(_), _)) | Some((Token::Modifier(_), _)) => map(gate::parse_gate, Instruction::Gate)(input),
         Some((_, _)) => Err(nom::Err::Failure(InternalParseError::from_kind(
             &input[..1],
             ParserErrorKind::NotACommandOrGate,

src/parser/mod.rs

@@ -19,7 +19,7 @@ pub(crate) use instruction::parse_instructions;
 pub(crate) use lexer::lex;
 
 mod command;
-mod gate;
+pub(crate) mod gate;
 mod macros;
 
 pub(crate) mod common;