mqt-core 3.3.2__cp314-cp314t-macosx_11_0_x86_64.whl

mqt/core/include/mqt-core/qasm3/mqt_core_qasm_export.h

@@ -0,0 +1,43 @@
+
+#ifndef MQT_CORE_QASM_EXPORT_H
+#define MQT_CORE_QASM_EXPORT_H
+
+#ifdef MQT_CORE_QASM_STATIC_DEFINE
+#  define MQT_CORE_QASM_EXPORT
+#  define MQT_CORE_QASM_NO_EXPORT
+#else
+#  ifndef MQT_CORE_QASM_EXPORT
+#    ifdef mqt_core_qasm_EXPORTS
+        /* We are building this library */
+#      define MQT_CORE_QASM_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define MQT_CORE_QASM_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef MQT_CORE_QASM_NO_EXPORT
+#    define MQT_CORE_QASM_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef MQT_CORE_QASM_DEPRECATED
+#  define MQT_CORE_QASM_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef MQT_CORE_QASM_DEPRECATED_EXPORT
+#  define MQT_CORE_QASM_DEPRECATED_EXPORT MQT_CORE_QASM_EXPORT MQT_CORE_QASM_DEPRECATED
+#endif
+
+#ifndef MQT_CORE_QASM_DEPRECATED_NO_EXPORT
+#  define MQT_CORE_QASM_DEPRECATED_NO_EXPORT MQT_CORE_QASM_NO_EXPORT MQT_CORE_QASM_DEPRECATED
+#endif
+
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef MQT_CORE_QASM_NO_DEPRECATED
+#    define MQT_CORE_QASM_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* MQT_CORE_QASM_EXPORT_H */

mqt/core/include/mqt-core/qasm3/passes/CompilerPass.hpp

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+namespace qasm3 {
+class Statement;
+
+class CompilerPass {
+public:
+  virtual ~CompilerPass() = default;
+
+  virtual void processStatement(Statement& statement) = 0;
+};
+} // namespace qasm3

mqt/core/include/mqt-core/qasm3/passes/ConstEvalPass.hpp

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "qasm3/InstVisitor.hpp"
+#include "qasm3/NestedEnvironment.hpp"
+#include "qasm3/Statement_fwd.hpp"
+#include "qasm3/passes/CompilerPass.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace qasm3::const_eval {
+struct ConstEvalValue {
+  enum Type : uint8_t {
+    ConstInt,
+    ConstUint,
+    ConstFloat,
+    ConstBool,
+  } type;
+  std::variant<int64_t, double, bool> value;
+  size_t width;
+
+  explicit ConstEvalValue(double val, const size_t w = 64)
+      : type(ConstFloat), value(val), width(w) {}
+  explicit ConstEvalValue(int64_t val, const bool isSigned, const size_t w = 64)
+      : type(isSigned ? ConstInt : ConstUint), value(val), width(w) {}
+  explicit ConstEvalValue(bool val) : type(ConstBool), value(val), width(1) {}
+
+  [[nodiscard]] std::shared_ptr<Constant> toExpr() const;
+
+  bool operator==(const ConstEvalValue& rhs) const;
+
+  bool operator!=(const ConstEvalValue& rhs) const { return !(*this == rhs); }
+
+  [[nodiscard]] std::string toString() const;
+};
+
+class ConstEvalPass final
+    : public CompilerPass,
+      public DefaultInstVisitor,
+      public ExpressionVisitor<std::optional<ConstEvalValue>>,
+      public TypeVisitor<std::shared_ptr<Expression>> {
+  NestedEnvironment<ConstEvalValue> env;
+
+public:
+  ConstEvalPass() = default;
+  ~ConstEvalPass() override = default;
+
+  void addConst(const std::string& identifier, const ConstEvalValue& val) {
+    env.emplace(identifier, val);
+  }
+
+  void addConst(const std::string& identifier, const double val) {
+    env.emplace(identifier, ConstEvalValue(val));
+  }
+
+  void processStatement(Statement& statement) override;
+
+  void pushEnv() { env.push(); }
+  void popEnv() { env.pop(); }
+
+  void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> declarationStatement) override;
+  void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> gateCallStatement) override;
+
+  std::optional<ConstEvalValue> visitBinaryExpression(
+      std::shared_ptr<BinaryExpression> binaryExpression) override;
+  std::optional<ConstEvalValue> visitUnaryExpression(
+      std::shared_ptr<UnaryExpression> unaryExpression) override;
+  std::optional<ConstEvalValue>
+  visitConstantExpression(std::shared_ptr<Constant> constant) override;
+  std::optional<ConstEvalValue> visitIdentifierExpression(
+      std::shared_ptr<IdentifierExpression> identifierExpression) override;
+  std::optional<ConstEvalValue>
+  visitIdentifierList(std::shared_ptr<IdentifierList> identifierList) override;
+  std::optional<ConstEvalValue> visitIndexedIdentifier(
+      std::shared_ptr<IndexedIdentifier> indexedIdentifier) override;
+  std::optional<ConstEvalValue> visitMeasureExpression(
+      std::shared_ptr<MeasureExpression> measureExpression) override;
+
+  std::shared_ptr<ResolvedType> visitDesignatedType(
+      DesignatedType<std::shared_ptr<Expression>>* designatedType) override;
+  std::shared_ptr<ResolvedType> visitUnsizedType(
+      UnsizedType<std::shared_ptr<Expression>>* unsizedType) override;
+  std::shared_ptr<ResolvedType>
+  visitArrayType(ArrayType<std::shared_ptr<Expression>>* arrayType) override;
+};
+} // namespace qasm3::const_eval

mqt/core/include/mqt-core/qasm3/passes/TypeCheckPass.hpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "qasm3/InstVisitor.hpp"
+#include "qasm3/Statement_fwd.hpp"
+#include "qasm3/Types.hpp"
+#include "qasm3/passes/CompilerPass.hpp"
+#include "qasm3/passes/ConstEvalPass.hpp"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace qasm3 {
+class GateOperand;
+struct DebugInfo;
+} // namespace qasm3
+
+namespace qasm3::type_checking {
+struct InferredType {
+  bool isError;
+  std::shared_ptr<ResolvedType> type;
+
+  InferredType(const bool isErr, std::shared_ptr<ResolvedType> ty)
+      : isError(isErr), type(std::move(ty)) {}
+
+  explicit InferredType(std::shared_ptr<ResolvedType> ty)
+      : isError(false), type(std::move(ty)) {}
+
+  static InferredType error() { return InferredType{true, nullptr}; }
+
+  [[nodiscard]] bool matches(const InferredType& other) const {
+    if (isError || other.isError) {
+      return true;
+    }
+
+    return *type == *other.type;
+  }
+
+  [[nodiscard]] std::string toString() const {
+    if (isError) {
+      return "error";
+    }
+    return type->toString();
+  }
+};
+
+class TypeCheckPass final : public CompilerPass,
+                            public InstVisitor,
+                            public ExpressionVisitor<InferredType> {
+  bool hasError = false;
+  std::string errMessage;
+  std::map<std::string, InferredType> env;
+  // We need a reference to a const eval pass to evaluate types before type
+  // checking.
+  const_eval::ConstEvalPass* constEvalPass;
+
+  InferredType error(const std::string& msg,
+                     const std::shared_ptr<DebugInfo>& debugInfo = nullptr);
+
+public:
+  explicit TypeCheckPass(const_eval::ConstEvalPass& pass)
+      : constEvalPass(&pass) {}
+
+  ~TypeCheckPass() override = default;
+
+  void addBuiltin(const std::string& identifier, const InferredType& ty) {
+    env.emplace(identifier, ty);
+  }
+
+  void processStatement(Statement& statement) override;
+
+  void checkIndexOperator(const IndexOperator& indexOperator);
+  void checkIndexedIdentifier(const IndexedIdentifier& id);
+  void checkGateOperand(const GateOperand& operand);
+
+  // Types
+  void
+  visitGateStatement(std::shared_ptr<GateDeclaration> gateStatement) override;
+  void visitVersionDeclaration(
+      std::shared_ptr<VersionDeclaration> versionDeclaration) override;
+  void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> declarationStatement) override;
+  void
+  visitInitialLayout(std::shared_ptr<InitialLayout> initialLayout) override;
+  void visitOutputPermutation(
+      std::shared_ptr<OutputPermutation> outputPermutation) override;
+  void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> gateCallStatement) override;
+  void visitAssignmentStatement(
+      std::shared_ptr<AssignmentStatement> assignmentStatement) override;
+  void visitBarrierStatement(
+      std::shared_ptr<BarrierStatement> barrierStatement) override;
+  void
+  visitResetStatement(std::shared_ptr<ResetStatement> resetStatement) override;
+  void visitIfStatement(std::shared_ptr<IfStatement> ifStatement) override;
+
+  // Expressions
+  InferredType visitBinaryExpression(
+      std::shared_ptr<BinaryExpression> binaryExpression) override;
+  InferredType visitUnaryExpression(
+      std::shared_ptr<UnaryExpression> unaryExpression) override;
+  InferredType
+  visitConstantExpression(std::shared_ptr<Constant> constantInt) override;
+  InferredType visitIdentifierExpression(
+      std::shared_ptr<IdentifierExpression> identifierExpression) override;
+  InferredType
+  visitIdentifierList(std::shared_ptr<IdentifierList> identifierList) override;
+  InferredType visitIndexedIdentifier(
+      std::shared_ptr<IndexedIdentifier> indexedIdentifier) override;
+  InferredType visitMeasureExpression(
+      std::shared_ptr<MeasureExpression> measureExpression) override;
+};
+} // namespace qasm3::type_checking