SimpleOps.h

Go to the documentation of this file.

#pragma once
 
#ifndef _SIMPLEOPS_H_
#define _SIMPLEOPS_H_
 
#include <cctype>
#include <limits>
#include <string_view>
 
#include "Expr.h"
 
namespace qasm
{
// something like this id[value] used for example by qreg and creg declarations
// also when a qubit or cbit is referenced
class IndexedId : public AbstractSyntaxTree
{
  public:
    IndexedId() : index(0)
    {
    }
 
    IndexedId(const std::string &id, int index) : id(id), index(index)
    {
    }
 
    ~IndexedId()
    {
    }
 
    double Eval() const
    {
        return index;
    }
 
    operator std::string() const
    {
        return declType + " " + id + "[" + std::to_string(index) + "]";
    }
 
    std::string id;
    int index;
    int base = 0;         // to be used when allocating the qubits/cbits in the circuit
    std::string declType; // "qreg" or "creg" or "id"
};
 
enum class DeclarationKind
{
    Qubit,
    Bit,
    Input,
    Gate,
    Opaque
};
 
using DeclarationRegistry = std::unordered_map<std::string, DeclarationKind>;
 
inline std::string_view DeclarationKindName(DeclarationKind kind)
{
    switch (kind)
    {
    case DeclarationKind::Qubit:
        return "quantum register";
    case DeclarationKind::Bit:
        return "classical register";
    case DeclarationKind::Input:
        return "input";
    case DeclarationKind::Gate:
        return "gate";
    case DeclarationKind::Opaque:
        return "opaque gate";
    }
 
    return "declaration";
}
 
inline void RegisterDeclaration(DeclarationRegistry &declarations, const std::string &name, DeclarationKind kind)
{
    const auto [it, inserted] = declarations.emplace(name, kind);
    if (inserted)
        return;
 
    if (it->second == kind)
        throw std::invalid_argument("Duplicate declaration of '" + name + "'.");
 
    throw std::invalid_argument("Declaration of '" + name + "' conflicts with an existing " + std::string(DeclarationKindName(it->second)) + ".");
}
 
inline int ValidateRegisterAllocation(const IndexedId &id, int currentSize, std::string_view kind)
{
    const int size = id.index;
    if (size <= 0)
        throw std::invalid_argument(std::string(kind) + " register '" + id.id + "' must have a positive size.");
 
    if (currentSize < 0 || currentSize > std::numeric_limits<int>::max() - size)
        throw std::overflow_error(std::string(kind) + " register allocation exceeds supported "
                                                      "maximum.");
 
    return size;
}
 
struct MakeIndexedIdExpression
{
    template <typename, typename> struct result
    {
        typedef IndexedId type;
    };
 
    template <typename ID, typename IND> IndexedId operator()(const ID &id, IND index) const
    {
        return IndexedId(id, index);
    }
};
 
inline phx::function<MakeIndexedIdExpression> MakeIndexedId;
 
using SimpleExpType = std::variant<double, int, std::string>;
 
using ArgumentType = std::variant<std::string, IndexedId>;
using RegisterMap = std::unordered_map<std::string, IndexedId>;
using MixedListType = std::vector<ArgumentType>;
using InputDeclType = boost::fusion::vector<std::string, boost::optional<int>, std::string>;
 
inline std::vector<int> ResolveRegisterOperand(const ArgumentType &argument, const RegisterMap &registers, std::string_view kind)
{
    const std::string &name = std::holds_alternative<IndexedId>(argument) ? std::get<IndexedId>(argument).id : std::get<std::string>(argument);
    const auto it = registers.find(name);
    if (it == registers.end())
        throw std::invalid_argument("Undeclared " + std::string(kind) + " register '" + name + "'.");
 
    const IndexedId &declaration = it->second;
    if (std::holds_alternative<IndexedId>(argument))
    {
        const int index = std::get<IndexedId>(argument).index;
        if (index < 0 || index >= declaration.index)
        {
            std::string titledKind(kind);
            titledKind[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(titledKind[0])));
            throw std::out_of_range(titledKind + " register '" + name + "' index " + std::to_string(index) + " is out of range [0, " +
                                    std::to_string(declaration.index) + ").");
        }
 
        return {declaration.base + index};
    }
 
    std::vector<int> resolved;
    resolved.reserve(static_cast<size_t>(declaration.index));
    for (int index = 0; index < declaration.index; ++index)
        resolved.push_back(declaration.base + index);
    return resolved;
}
 
inline void RequireMatchingRegisterWidths(const std::vector<int> &left, const std::vector<int> &right, std::string_view operation)
{
    if (left.size() != right.size())
        throw std::invalid_argument(std::string(operation) + " operands must have the same width.");
}
 
using SimpleGatecallType = boost::fusion::vector<std::string, MixedListType>;
using ExpGatecallType = boost::fusion::vector<std::string, std::vector<Expression>, MixedListType>;
using GatecallType = std::variant<SimpleGatecallType, ExpGatecallType>;
 
using UGateCallType = boost::fusion::vector<std::vector<Expression>, ArgumentType>;
using CXGateCallType = boost::fusion::vector<ArgumentType, ArgumentType>;
 
using UopType = std::variant<UGateCallType, CXGateCallType, GatecallType>;
 
// QASM3 call-site gate modifiers: `ctrl @`, `negctrl @`, `inv @` and
// `pow(k) @`.
enum class ModifierKind
{
    Ctrl,
    NegCtrl,
    Inv,
    Pow
};
 
struct ModifierType
{
    ModifierType() = default;
 
    ModifierType(ModifierKind kind, double exponent = 0., int count = 1) : kind(kind), exponent(exponent), count(count)
    {
    }
 
    ModifierKind kind = ModifierKind::Ctrl;
    double exponent = 0.; // only meaningful for ModifierKind::Pow
    // The optional control count of `ctrl(n) @` / `negctrl(n) @`; 1 for the
    // countless spelling and for every non-control modifier. Kept on the
    // modifier instead of expanded into n separate ModifierType entries so that
    // one parsed modifier remains one element of ModifierListType - the list's
    // source order is what tells AddModifiedGateExpr which qubit arguments a
    // control owns.
    int count = 1;
};
 
// Modifiers are kept in source order, i.e. outermost first: in
// `ctrl @ inv @ s q[0], q[1]` the control is applied last, to the inverted
// gate, and it consumes the first qubit argument.
using ModifierListType = std::vector<ModifierType>;
using ModifiedUopType = boost::fusion::vector<ModifierListType, UopType>;
 
struct MakePowModifierExpression
{
    template <typename, typename> struct result
    {
        typedef ModifierType type;
    };
 
    // `variables` carries the top-level `input` bindings (threaded from the
    // `powMod` rule via std::ref(inputValues), the same grammar member
    // AddModifiedGate's call site uses), so `pow(theta) @ x q[0];` resolves
    // theta the same way an ordinary gate parameter does. A modified call
    // cannot appear inside a gate declaration body, so no macro formal
    // parameter is ever in scope here - any identifier absent from `variables`
    // is still an error (Variable::Eval throws), not a silent zero.
    template <typename E, typename V> ModifierType operator()(const E &exponent, const V &variables) const
    {
        return ModifierType(ModifierKind::Pow, exponent.Eval(variables));
    }
};
 
inline phx::function<MakePowModifierExpression> MakePowModifier;
 
// Builds a `ctrl @` / `negctrl @` modifier, with the optional control count
// of `ctrl(n) @`. `count` is absent for the countless spelling, in which case
// it is 1 - so `ctrl(1) @ g` and `ctrl @ g` produce identical modifiers.
//
// `variables` is threaded exactly as MakePowModifierExpression's is, so
// `ctrl(n) @` may name a top-level `input`; an identifier absent from it is
// an error via Variable::Eval rather than a silent zero. A count that is not
// a positive whole number is rejected here, where the spelling is still
// known. How many controls the lowering can actually realise is not decided
// here - that stays in AddModifiedGateExpr, which already reports it.
struct MakeCtrlModifierExpression
{
    template <typename, typename, typename> struct result
    {
        typedef ModifierType type;
    };
 
    template <typename K, typename E, typename V> ModifierType operator()(K kind, const E &count, const V &variables) const
    {
        if (!count)
            return ModifierType(kind);
 
        const double value = count->Eval(variables);
        if (!std::isfinite(value))
            throw std::invalid_argument("The control count of ctrl(n) @ / negctrl(n) @ must be finite, "
                                        "got: " +
                                        std::to_string(value));
 
        const double rounded = std::round(value);
 
        if (std::abs(value - rounded) > 1e-9 || rounded < 1. || rounded > 64.)
            throw std::invalid_argument("The control count of ctrl(n) @ / negctrl(n) @ must be a positive "
                                        "whole number, got: " +
                                        std::to_string(value));
 
        return ModifierType(kind, 0., static_cast<int>(rounded));
    }
};
 
inline phx::function<MakeCtrlModifierExpression> MakeCtrlModifier;
 
struct QoperationStatement : public AbstractSyntaxTree
{
    enum class OperationType
    {
        Comment,
        Declaration, // creg, qreg
        Barrier,
        Measurement,
        Reset,
        OpaqueDecl,
        GateDecl,
        Uop,
        CondUop,
        Delay,
    };
 
    OperationType opType = OperationType::Comment;
    Circuits::QuantumGateType gateType = Circuits::QuantumGateType::kNone;
 
    std::string comment;
 
    IndexedId declaration;
 
    std::vector<int> qubits;
    std::vector<int> cbits;
 
    std::vector<double> parameters;
 
    std::vector<std::string> paramsDecl;
    std::vector<std::string> qubitsDecl;
 
    // Expected values are stored explicitly instead of packed into an integer,
    // so QASM3 conjunctions are not limited by the host integer width.
    std::vector<bool> condExpected;
    // Condition bits for a conditional Measurement/Reset; CondUop uses cbits.
    std::vector<int> condBits;
    std::vector<UopType> declOps;
};
 
using StatementType = QoperationStatement;
 
using ProgramType = boost::fusion::vector<std::vector<std::string>, double, std::vector<std::string>, std::vector<StatementType>>;
 
using ResetType = ArgumentType;
using MeasureType = boost::fusion::vector<ArgumentType, ArgumentType>;
using BarrierType = MixedListType;
 
struct DelayType
{
    double duration = 0.0;
    MixedListType operands;
};
 
// using QopType = std::variant<UopType, ResetType, MeasureType, BarrierType>;
using QopType = StatementType;
using CondOpType = boost::fusion::vector<std::string, int, QopType>;
 
// The parsed condition head of a QASM3 braced conditional, i.e. everything
// inside `if ( ... )`. Two shapes are folded into one type rather than a
// std::variant, matching the style of ModifierType above: each alternative
// of the `condHead` rule (register-comparison, bare bit, negated bit) has
// its own semantic action constructing one of these, so no
// BOOST_FUSION_ADAPT_STRUCT/attribute propagation is needed - only direct
// construction via qi::_val = Make...CondHead(...).
//
// Register form (`c == 2`): isBitForm is false, regId/regValue hold the
// register name and comparison value - the same information CondOpType
// carried before this type existed.
//
// Bit form (`c[0]`, `!c[0]`, or a `&&`-joined chain of either): isBitForm is
// true and bits holds one entry per tested bit, each pairing the indexed
// classical bit with the value it must equal for the condition to be true
// (true for the bare form, false for the negated form). This is deliberately
// expressed as bits + expected values, not a register + mask, since
// CreateEqualCondition already takes bit indices and expected booleans
// directly (see AddCondQopBracedExpr).
struct CondBitTest
{
    IndexedId bit;
    bool expected = true;
};
 
struct CondHeadType
{
    bool isBitForm = false;
 
    std::string regId;
    int regValue = 0;
 
    std::vector<CondBitTest> bits;
};
 
struct MakeRegCondHeadExpression
{
    struct result
    {
        typedef CondHeadType type;
    };
 
    CondHeadType operator()(const std::string &regId, int regValue) const
    {
        CondHeadType head;
        head.isBitForm = false;
        head.regId = regId;
        head.regValue = regValue;
        return head;
    }
};
 
inline phx::function<MakeRegCondHeadExpression> MakeRegCondHead;
 
struct MakeCondBitTestExpression
{
    struct result
    {
        typedef CondBitTest type;
    };
 
    CondBitTest operator()(const IndexedId &bit, bool expected) const
    {
        CondBitTest test;
        test.bit = bit;
        test.expected = expected;
        return test;
    }
};
 
inline phx::function<MakeCondBitTestExpression> MakeCondBitTest;
 
struct MakeBitCondHeadExpression
{
    struct result
    {
        typedef CondHeadType type;
    };
 
    CondHeadType operator()(const std::vector<CondBitTest> &bits) const
    {
        CondHeadType head;
        head.isBitForm = true;
        head.bits = bits;
        return head;
    }
};
 
inline phx::function<MakeBitCondHeadExpression> MakeBitCondHead;
 
using GateDeclType = boost::fusion::vector<std::string, std::vector<std::string>, std::vector<std::string>>;
using SimpleBarrierType = std::vector<std::string>;
using GateDeclOpType = std::variant<UopType, SimpleBarrierType>;
using OpaqueDeclType = boost::fusion::vector<std::string, std::vector<std::string>, std::vector<std::string>>;
 
struct AddCregExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef IndexedId type;
    };
 
    IndexedId operator()(int &counter, std::unordered_map<std::string, IndexedId> &creg_map, DeclarationRegistry &declarations, const IndexedId &id) const
    {
        IndexedId id_copy = id;
        const int size = ValidateRegisterAllocation(id_copy, counter, "Classical");
        RegisterDeclaration(declarations, id_copy.id, DeclarationKind::Bit);
 
        id_copy.base = counter;
        id_copy.declType = "creg";
 
        counter += size;
        creg_map[id_copy.id] = id_copy;
 
        return id_copy;
    }
};
 
inline phx::function<AddCregExpr> AddCreg;
 
struct AddQregExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef IndexedId type;
    };
 
    IndexedId operator()(int &counter, std::unordered_map<std::string, IndexedId> &qreg_map, DeclarationRegistry &declarations, const IndexedId &id) const
    {
        IndexedId id_copy = id;
        const int size = ValidateRegisterAllocation(id_copy, counter, "Quantum");
        RegisterDeclaration(declarations, id_copy.id, DeclarationKind::Qubit);
 
        id_copy.base = counter;
        id_copy.declType = "qreg";
 
        counter += size;
        qreg_map[id_copy.id] = id_copy;
 
        return id_copy;
    }
};
 
inline phx::function<AddQregExpr> AddQreg;
 
struct AddCommentExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const std::string &comment) const
    {
        QoperationStatement stmt;
 
        stmt.opType = QoperationStatement::OperationType::Comment;
        stmt.comment = comment;
 
        return stmt;
    }
};
 
inline phx::function<AddCommentExpr> AddComment;
 
struct AddDeclarationExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const IndexedId &id) const
    {
        QoperationStatement stmt;
        stmt.opType = QoperationStatement::OperationType::Declaration;
        stmt.declaration = id;
 
        return stmt;
    }
};
 
inline phx::function<AddDeclarationExpr> AddDeclaration;
 
inline void ValidateInputDeclaration(const std::string &name, const std::string &type, const boost::optional<int> &width)
{
    if (width && *width <= 0)
        throw std::invalid_argument("Input '" + name + "' must have a positive type width.");
 
    if (type == "bool")
    {
        if (width)
            throw std::invalid_argument("Boolean input '" + name + "' cannot have a width designator.");
        return;
    }
 
    if (type == "float")
    {
        if (width && *width != 32 && *width != 64)
            throw std::invalid_argument("Input '" + name +
                                        "' uses an unsupported float width; only float, float[32], and "
                                        "float[64] are supported.");
        return;
    }
 
    if (type == "angle")
    {
        if (width)
            throw std::invalid_argument("Precisely quantized sized angle inputs are not supported.");
        return;
    }
 
    if (width && *width > 64)
        throw std::invalid_argument("Input '" + name +
                                    "' uses an integer width above 64, which "
                                    "the numeric binding API cannot represent.");
}
 
inline double ValidateInputBinding(const std::string &name, const std::string &type, const boost::optional<int> &width, double value)
{
    ValidateInputDeclaration(name, type, width);
 
    if (!std::isfinite(value))
        throw std::invalid_argument("Input binding '" + name + "' must be finite.");
 
    if (type == "bool")
    {
        if (value != 0. && value != 1.)
            throw std::invalid_argument("Input binding '" + name + "' must be a boolean value (0 or 1).");
        return value;
    }
 
    if (type == "float")
    {
        if (!width || *width == 64)
            return value;
        const float narrowed = static_cast<float>(value);
        if (!std::isfinite(narrowed))
            throw std::invalid_argument("Input binding '" + name + "' does not fit float[32].");
        return static_cast<double>(narrowed);
    }
 
    if (type == "angle")
    {
        double normalized = std::fmod(value, 2. * M_PI);
        if (normalized < 0.)
            normalized += 2. * M_PI;
        return normalized;
    }
 
    const bool isUnsigned = type == "uint";
    if (std::trunc(value) != value)
        throw std::invalid_argument("Input binding '" + name + "' must be an integer value.");
    if (isUnsigned && value < 0.)
        throw std::invalid_argument("Unsigned input binding '" + name + "' must be non-negative.");
 
    if (width)
    {
        const double upper = std::ldexp(1., isUnsigned ? *width : *width - 1);
        const double lower = isUnsigned ? 0. : -upper;
        if (value < lower || value >= upper)
            throw std::invalid_argument("Input binding '" + name + "' does not fit its declared " + type + "[" + std::to_string(*width) + "] type.");
    }
 
    return value;
}
 
// Records a QASM3 input declaration and publishes a validated caller binding
// to the expression environment only when that declaration is reached.
struct AddInputDeclExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const InputDeclType &inputDecl, std::vector<std::string> &inputNames, DeclarationRegistry &declarations,
                                   const std::unordered_map<std::string, double> &inputBindings,
                                   std::unordered_map<std::string, double> &visibleInputValues) const
    {
        const std::string &type = boost::fusion::at_c<0>(inputDecl);
        const boost::optional<int> &width = boost::fusion::at_c<1>(inputDecl);
        const std::string &name = boost::fusion::at_c<2>(inputDecl);
        ValidateInputDeclaration(name, type, width);
        RegisterDeclaration(declarations, name, DeclarationKind::Input);
        inputNames.push_back(name);
 
        const auto binding = inputBindings.find(name);
        if (binding != inputBindings.end())
            visibleInputValues[name] = ValidateInputBinding(name, type, width, binding->second);
 
        QoperationStatement stmt;
        stmt.opType = QoperationStatement::OperationType::Declaration;
        // Recorded in `declaration`, the same IndexedId field AddDeclarationExpr
        // (the qreg/creg/qubit/bit declaration functor) populates, so a
        // Declaration-typed statement always carries its declared name in one
        // place regardless of which kind of declaration produced it. `index` is
        // left at its default 0: an `input` has no size to record.
        stmt.declaration = IndexedId(name, 0);
        stmt.declaration.declType = "input";
 
        return stmt;
    }
};
 
inline phx::function<AddInputDeclExpr> AddInputDecl;
 
struct AddMeasureExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const MeasureType &measure, const RegisterMap &creg_map, const RegisterMap &qreg_map) const
    {
        QoperationStatement stmt;
        stmt.opType = QoperationStatement::OperationType::Measurement;
 
        stmt.qubits = ResolveRegisterOperand(boost::fusion::at_c<0>(measure), qreg_map, "quantum");
        stmt.cbits = ResolveRegisterOperand(boost::fusion::at_c<1>(measure), creg_map, "classical");
        RequireMatchingRegisterWidths(stmt.qubits, stmt.cbits, "Measurement");
 
        return stmt;
    }
};
 
inline phx::function<AddMeasureExpr> AddMeasure;
 
// The OpenQASM 3 grammar makes a measurement's `-> c` target optional, so
// `measure q;` ("measure and throw the result away") is spec-legal. It is not
// representable here: Circuits::CircuitFactory::CreateMeasurement takes
// (qubit, classical bit) pairs and MeasurementOperation always writes a bit,
// so there is no discard form to lower onto - and fabricating a classical bit
// to absorb the result would silently grow the program's classical register
// and change what a subsequent `if (c == ...)` sees. So the construct is
// recognised (see `measureNoTarget` in Qasm.h) and rejected by name. Before
// this rule existed it fell through to the gate-call path and was reported as
// "Unsupported gate without parameters: measure", which named the wrong
// thing entirely.
struct RejectMeasureWithoutTargetExpr : public AbstractSyntaxTree
{
    template <typename> struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const ArgumentType & /*qubits*/) const
    {
        throw std::invalid_argument("A measurement without a classical target ('measure q;') is not "
                                    "supported: every measurement must name the classical bit that "
                                    "receives its result, as in 'measure q -> c;' or 'c = measure q;'");
    }
};
 
inline phx::function<RejectMeasureWithoutTargetExpr> RejectMeasureWithoutTarget;
 
struct AddResetExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const ResetType &reset, const RegisterMap &qreg_map) const
    {
        QoperationStatement stmt;
        stmt.opType = QoperationStatement::OperationType::Reset;
        stmt.qubits = ResolveRegisterOperand(reset, qreg_map, "quantum");
        return stmt;
    }
};
 
inline phx::function<AddResetExpr> AddReset;
 
struct AddBarrierExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const BarrierType &barrier, const RegisterMap &qreg_map) const
    {
        StatementType stmt;
        stmt.opType = QoperationStatement::OperationType::Barrier;
        std::set<int> qubit_set;
 
        // A bare QASM3 barrier applies to every declared qubit. The Circuit IR
        // has no barrier operation, so Program intentionally erases this statement.
        if (barrier.empty())
        {
            for (const auto &[name, reg] : qreg_map)
                for (int index = 0; index < reg.index; ++index)
                    qubit_set.insert(reg.base + index);
        }
        else
        {
            for (const auto &operand : barrier)
            {
                const std::vector<int> resolved = ResolveRegisterOperand(operand, qreg_map, "quantum");
                qubit_set.insert(resolved.begin(), resolved.end());
            }
        }
 
        stmt.qubits.assign(qubit_set.begin(), qubit_set.end());
        return stmt;
    }
};
 
inline phx::function<AddBarrierExpr> AddBarrier;
 
struct MakeDelayExpr
{
    template <typename, typename, typename> struct result
    {
        typedef DelayType type;
    };
 
    template <typename D, typename M, typename V> DelayType operator()(const D &dur, const M &operands, const V &variables) const
    {
        const auto &expr = boost::fusion::at_c<0>(dur);
        const auto &unitOpt = boost::fusion::at_c<1>(dur);
        double val = expr.Eval(variables);
        double scale = unitOpt ? *unitOpt : 1.0;
        if (scale < 0.0)
        {
            throw std::invalid_argument("OpenQASM 'dt' unit delays require hardware timing context and are not "
                                        "supported without a target waveform configuration.");
        }
        return DelayType{val * scale, operands};
    }
};
 
inline phx::function<MakeDelayExpr> MakeDelay;
 
struct AddDelayExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const DelayType &delay, const RegisterMap &qreg_map) const
    {
        QoperationStatement stmt;
        stmt.opType = QoperationStatement::OperationType::Delay;
        stmt.parameters = {delay.duration};
        for (const auto &operand : delay.operands)
        {
            const std::vector<int> resolved = ResolveRegisterOperand(operand, qreg_map, "quantum");
            stmt.qubits.insert(stmt.qubits.end(), resolved.begin(), resolved.end());
        }
        return stmt;
    }
};
 
inline phx::function<AddDelayExpr> AddDelay;
 
struct AddOpaqueDeclExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const OpaqueDeclType &opaqueDecl, std::unordered_map<std::string, StatementType> &opaqueGates,
                                   const std::unordered_map<std::string, IndexedId> &qreg_map, DeclarationRegistry &declarations) const
    {
        StatementType stmt;
        stmt.opType = QoperationStatement::OperationType::OpaqueDecl;
 
        std::string gateName = boost::fusion::at_c<0>(opaqueDecl);
        RegisterDeclaration(declarations, gateName, DeclarationKind::Opaque);
 
        stmt.comment = gateName;
 
        // maybe take some other infor from opaqueDecl if needed
        const std::vector<std::string> &params = boost::fusion::at_c<1>(opaqueDecl);
        const std::vector<std::string> &args = boost::fusion::at_c<2>(opaqueDecl);
 
        stmt.paramsDecl = params;
        stmt.qubitsDecl = args;
 
        // save into the map as well
        opaqueGates[gateName] = stmt;
 
        return stmt;
    }
};
 
inline phx::function<AddOpaqueDeclExpr> AddOpaqueDecl;
 
struct AddGateDeclExpr : public AbstractSyntaxTree
{
    struct result
    {
        typedef QoperationStatement type;
    };
 
    QoperationStatement operator()(const boost::fusion::vector<GateDeclType, std::vector<GateDeclOpType>> &gateDecl,
                                   std::unordered_map<std::string, StatementType> &definedGates, DeclarationRegistry &declarations) const
    {
        StatementType stmt;
        stmt.opType = QoperationStatement::OperationType::GateDecl;
 
        const GateDeclType &declInfo = boost::fusion::at_c<0>(gateDecl);
 
        const std::string &gateName = boost::fusion::at_c<0>(declInfo);
        const std::vector<std::string> &params = boost::fusion::at_c<1>(declInfo);
        const std::vector<std::string> &args = boost::fusion::at_c<2>(declInfo);
 
        RegisterDeclaration(declarations, gateName, DeclarationKind::Gate);
 
        if (args.empty())
            throw std::invalid_argument("Gate declaration must have at least one qubit argument: " + gateName);
        else if (definedGates.find(gateName) != definedGates.end()) // for now do not allow redefinition, the
                                                                    // biggest problem is that defined gates can be
                                                                    // used inside other defined gates, otherwise
                                                                    // redefinition would be simple to handle
            throw std::invalid_argument("Gate already defined: " + gateName);
 
        stmt.comment = gateName;
        stmt.paramsDecl = params;
        stmt.qubitsDecl = args;
 
        const std::vector<GateDeclOpType> &declOps = boost::fusion::at_c<1>(gateDecl);
 
        for (const auto &op : declOps)
        {
            if (std::holds_alternative<UopType>(op))
            {
                const UopType &uop = std::get<UopType>(op);
 
                stmt.declOps.push_back(uop);
            }
            // ignore barriers
            // else if (std::holds_alternative<SimpleBarrierType>(op))
            //{
            //}
        }
 
        definedGates[gateName] = stmt;
 
        return stmt;
    }
};
 
inline phx::function<AddGateDeclExpr> AddGateDecl;
} // namespace qasm
 
#endif