lique_core 0.1.0

Core library for Lique
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use oq3_syntax::ast::{AstChildren, Stmt};

use crate::{lints, Diagnostic};

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Rule {
    ConditionalWithoutMeasurement,
    DoubleMeasurement,
    OpAfterMeasurement,
    OversizedCircuit,
    UnmanipulatedQubit,
    UnmeasurableQubits,
}

impl From<&str> for Rule {
    fn from(s: &str) -> Self {
        match s {
            "conditional-without-measurement" => Rule::ConditionalWithoutMeasurement,
            "double-measurement" => Rule::DoubleMeasurement,
            "operation-after-measurement" => Rule::OpAfterMeasurement,
            "oversized-circuit" => Rule::OversizedCircuit,
            "unmanipulated-qubits" => Rule::UnmanipulatedQubit,
            "unmeasurable-qubits" => Rule::UnmeasurableQubits,
            _ => panic!("Unknown rule: {}", s),
        }
    }
}

impl From<Rule> for String {
    fn from(rule: Rule) -> String {
        match rule {
            Rule::ConditionalWithoutMeasurement => "ql-conditional-without-measurement".to_string(),
            Rule::DoubleMeasurement => "ql-double-measurement".to_string(),
            Rule::OpAfterMeasurement => "ql-operation-after-measurement".to_string(),
            Rule::OversizedCircuit => "ql-oversized-circuit".to_string(),
            Rule::UnmanipulatedQubit => "ql-constant-classic-bit".to_string(),
            Rule::UnmeasurableQubits => "ql-unmeasurable-qubits".to_string(),
        }
    }
}

impl Rule {
    pub fn all() -> Vec<Self> {
        vec![
            Rule::ConditionalWithoutMeasurement,
            Rule::DoubleMeasurement,
            Rule::OpAfterMeasurement,
            Rule::OversizedCircuit,
            Rule::UnmanipulatedQubit,
            Rule::UnmeasurableQubits,
        ]
    }

    pub fn lint(&self, stmts: AstChildren<Stmt>) -> Vec<Diagnostic> {
        match self {
            Rule::ConditionalWithoutMeasurement => {
                lints::conditional_without_measurement::lint_conditional_without_measurement(stmts)
            }
            Rule::DoubleMeasurement => lints::double_measurement::lint_double_measurement(stmts),
            Rule::OpAfterMeasurement => {
                lints::op_after_measurement::lint_op_after_measurement(stmts)
            }
            Rule::OversizedCircuit => lints::oversized_circuit::lint_oversized_circuit(stmts),
            Rule::UnmanipulatedQubit => {
                lints::unmanipulated_qubits::lint_unmanipulated_qubits(stmts)
            }
            Rule::UnmeasurableQubits => lints::unmeasurable_qubits::lint_unmeasurable_qubits(stmts),
        }
    }
}