v3 MVP

.github/workflows/test.yml

@@ -90,6 +90,7 @@ jobs:
           python3 -m venv venv
           source venv/bin/activate
           python3 -m pip install --upgrade pip conan
+          conan profile detect --force
           conan build . -pr=conan/profiles/tests-release-compat -b missing
       - name: Test
         working-directory: build/Release

CMakeLists.txt

@@ -35,17 +35,16 @@ option(LIBQASM_BUILD_TESTS
     OFF
 )
 
-# Compatibility mode. When enabled, the legacy API headers in src/library are
-# added to the public headers of the cqasm target. To enable this in your CMake
-# project, add `option(LIBQASM_COMPAT "" ON)` before the `add_subdirectory`
-# command.
+# Compatibility mode.
+# When enabled, the legacy API headers in src/library are added to the public headers of the cqasm target.
+# To enable this in your CMake project, add `option(LIBQASM_COMPAT "" ON)` before the `add_subdirectory` command.
 option(LIBQASM_COMPAT
     "whether the legacy API headers should be added to the cqasm library"
     OFF
 )
 
-# Whether the Python module should be built. This should only be enabled for
-# setup.py's builds.
+# Whether the Python module should be built.
+# This should only be enabled for setup.py's builds.
 option(LIBQASM_BUILD_PYTHON
     "Whether the Python module should be built"
     OFF
@@ -70,8 +69,7 @@ set(LIBQASM_PYTHON_EXT ""
 )
 mark_as_advanced(LIBQASM_PYTHON_EXT)
 
-# The Python library requires the compatibility headers, so make sure those are
-# enabled.
+# The Python library requires the compatibility headers, so make sure those are enabled.
 if(LIBQASM_BUILD_PYTHON AND NOT LIBQASM_COMPAT)
     message(SEND_ERROR "The Python library requires the compatibility headers! Please add -DLIBQASM_COMPAT=ON")
 endif()
@@ -126,4 +124,4 @@ if(LIBQASM_BUILD_PYTHON)
     add_subdirectory(python)
 endif()
 
-endif()  # NOT TARGET cqasm
+endif()  # NOT TARGET cqasm

conanfile.py

@@ -6,7 +6,7 @@
 from conan.errors import ConanInvalidConfiguration
 from conan.tools.build import check_min_cppstd
 from conan.tools.cmake import CMakeToolchain, CMakeDeps, CMake
-from conan.tools.files import copy, get
+from conan.tools.files import copy
 from conan.tools.scm import Version
 
 
@@ -58,6 +58,7 @@ def build_requirements(self):
             if self.settings.arch != "armv8":
                 self.tool_requires("flex/2.6.4")
                 self.tool_requires("bison/3.8.2")
+        self.requires("range-v3/0.12.0")
         if self.settings.arch != "armv8":
             self.tool_requires("zulu-openjdk/11.0.19")
         if self.options.build_tests:

include/cqasm-annotations.hpp

@@ -6,12 +6,8 @@
 
 #include <string>
 
-namespace cqasm {
 
-/**
- * Namespace for tree annotation objects used by libqasm.
- */
-namespace annotations {
+namespace cqasm::annotations {
 
 /**
  * Source location annotation object, containing source file line numbers etc.
@@ -68,5 +64,4 @@ class SourceLocation {
  */
 std::ostream &operator<<(std::ostream &os, const SourceLocation &object);
 
-} // namespace annotations
-} // namespace cqasm
+} // namespace cqasm::annotations

include/cqasm-overload.hpp

@@ -0,0 +1,171 @@
+#pragma once
+
+#include "cqasm-overload.hpp"
+#include "cqasm-tree.hpp"
+
+#include <exception>
+#include <string>
+#include <unordered_map>
+#include <utility>  // pair
+#include <vector>
+
+
+/**
+ * Overload templates are case-sensitive.
+ * The code using them can be case-insensitive by converting to lowercase before adding and resolving an overload.
+ */
+namespace cqasm::overload {
+
+struct NameResolutionFailure : public std::exception {};
+struct OverloadResolutionFailure : public std::exception {};
+
+/**
+ * Represents a possible overload for the parameter types of a function, gate, or error model.
+ * T is some tag type identifying the overload.
+ */
+template <class T, class TypeBase>
+class Overload {
+    using Type = tree::One<TypeBase>;
+    using Types = tree::Any<TypeBase>;
+
+    T tag;
+    Types param_types;
+
+public:
+    Overload(const T &tag, const Types &param_types) : tag{ tag }, param_types{ param_types} {}
+    Overload(const Overload &other) : tag{ other.tag }, param_types{ other.param_types } {}
+    Overload(Overload &&other) noexcept : tag{ std::move(other.tag) }, param_types{ other.param_types } {}
+    Overload& operator=(const Overload &other) { tag = other.tag; param_types = other.param_types; return *this; }
+    Overload& operator=(Overload &&other) noexcept { tag = std::move(other.tag); param_types = other.param_types; return *this; }
+
+    /**
+     * Returns the tag for this overload.
+     */
+    [[nodiscard]] const T &get_tag() const {
+        return tag;
+    }
+
+    /**
+     * Returns the number of parameters for this overload.
+     */
+    [[nodiscard]] std::size_t num_params() const {
+        return param_types.size();
+    }
+
+    /**
+     * Returns the parameter type object for the parameter at the specified index.
+     */
+    [[nodiscard]] const Type &param_type_at(std::size_t index) const {
+        return param_types.at(index);
+    }
+};
+
+/**
+ * Represents a set of possible overloads for the parameter types of a
+ * function, gate, or error model. T is some tag type identifying the overload.
+ * In case of a function, T would contain at least the return type, but maybe
+ * also a lambda to represent the actual function. Note that ambiguous
+ * overloads are silently resolved by using the last applicable overload, so
+ * more specific overloads should always be added last.
+ */
+template <class T, class TypeBase, class Node>
+class OverloadResolver {
+    using Type = tree::One<TypeBase>;
+    using Types = tree::Any<TypeBase>;
+    using Value = tree::One<Node>;
+    using Values = tree::Any<Node>;
+
+    std::vector<Overload<T, TypeBase>> overloads;
+
+public:
+    /**
+     * Adds a possible overload to the resolver. Note that ambiguous
+     * overloads are silently resolved by using the last applicable overload,
+     * so more specific overloads should always be added last.
+     */
+    void add_overload(const T &tag, const Types &param_types) {
+        overloads.emplace_back(tag, param_types);
+    }
+
+    /**
+     * Tries to resolve which overload belongs to the given argument list, if
+     * any. Raises an OverloadResolutionFailure if no applicable overload
+     * exists, otherwise the tag corresponding to the first proper overload and
+     * the appropriately promoted vector of value pointers are returned.
+     */
+    [[nodiscard]] std::pair<T, Values> resolve(const Values &args) {
+        for (auto overload = overloads.rbegin(); overload != overloads.rend(); ++overload) {
+            if (overload->num_params() != args.size()) {
+                continue;
+            }
+            Values promoted_args;
+            bool ok = true;
+            for (size_t i = 0; i < args.size(); i++) {
+                auto promoted_arg = promote(args.at(i), overload->param_type_at(i));
+                if (promoted_arg.empty()) {
+                    ok = false;
+                    break;
+                }
+                promoted_args.add(promoted_arg);
+            }
+            if (ok) {
+                return std::pair<T, Values>(overload->get_tag(), promoted_args);
+            }
+        }
+        throw OverloadResolutionFailure{};
+    }
+};
+
+/**
+ * Table of overloaded callables with case-sensitive identifier matching.
+ * T is the tag type of the callable/overload pair.
+ */
+template <class T, class TypeBase, class Node>
+class OverloadedNameResolver {
+    using Type = tree::One<TypeBase>;
+    using Types = tree::Any<TypeBase>;
+    using Value = tree::One<Node>;
+    using Values = tree::Any<Node>;
+
+    std::unordered_map<std::string, OverloadResolver<T, TypeBase, Node>> table;
+
+public:
+    /**
+     * Registers a callable.
+     * Matching will be done case-sensitively.
+     * The param_types variadic specifies the amount and types of the parameters that
+     * (this particular overload of) the function expects.
+     * The C++ implementation of the function can assume that
+     * the value list it gets is of the right size and the values are of the right types.
+     * Note that ambiguous overloads are silently resolved by using the last applicable overload,
+     * so more specific overloads should always be added last.
+     */
+    virtual void add_overload(const std::string &name, const T &tag, const Types &param_types) {
+        auto entry = table.find(name);
+        if (entry == table.end()) {
+            auto resolver = OverloadResolver<T, TypeBase, Node>();
+            resolver.add_overload(tag, param_types);
+            table.insert(std::pair<std::string, OverloadResolver<T, TypeBase, Node>>(name, std::move(resolver)));
+        } else {
+            entry->second.add_overload(tag, param_types);
+        }
+    }
+
+    /**
+     * Resolves the particular overload for the callable with the given case-sensitively matched name.
+     * Raises NameResolutionFailure if no callable with the requested name is found,
+     * raises an OverloadResolutionFailure if overload resolution fails, or otherwise
+     * returns the tag of the first applicable callable/overload pair and
+     * the appropriately promoted vector of value pointers.
+     */
+    [[nodiscard]] virtual std::pair<T, Values> resolve(const std::string &name, const Values &args) {
+        auto entry = table.find(name);
+        if (entry == table.end()) {
+            throw NameResolutionFailure{};
+        } else {
+            return entry->second.resolve(args);
+        }
+    }
+};
+
+}  // cqasm::overload

include/cqasm-utils.hpp

@@ -16,12 +16,12 @@ namespace utils {
 /**
  * Makes a string lowercase.
  */
-std::string lowercase(const std::string &name);
+std::string to_lowercase(const std::string &name);
 
 /**
  * Case-insensitive string compare.
  */
-bool case_insensitive_equals(const std::string &lhs, const std::string &rhs);
+bool equal_case_insensitive(const std::string &lhs, const std::string &rhs);
 
 } // namespace utils
 } // namespace cqasm

include/cqasm-version.hpp

@@ -23,17 +23,7 @@ namespace cqasm::version {
  * Version number primitive used within the AST and semantic trees.
  */
 class Version : public std::vector<std::int64_t> {
-public:
-    /**
-     * Default constructor.
-     */
-    Version() = default;
-
-    /**
-     * Constructs a version object from a string.
-     */
-    explicit Version(const std::string &version);
-
+private:
     /**
      * Compares this version against the other version.
      * Returns:
@@ -44,15 +34,28 @@ class Version : public std::vector<std::int64_t> {
      */
     [[nodiscard]] int compare(const Version &other) const;
 
+public:
     /**
-     * Compares this version against the other version.
-     * Returns:
-     *   1 if this version is newer than the other,
-     *   -1 if this version is older than the other, or
-     *   0 if both versions are the same.
-     * When there is a mismatch in the number of components between the versions, missing components are interpreted as 0.
+     * Default constructor.
+     */
+    Version() = default;
+
+    /**
+     * Constructs a version object from a string.
+     */
+    Version(const std::string &version);
+
+    /**
+     * Constructs a version object from an array of chars.
      */
-    [[nodiscard]] int compare(const std::string &other) const;
+    Version(const char *version);
+
+    [[nodiscard]] auto operator==(const Version &rhs) const {
+        return compare(rhs) == 0;
+    }
+    [[nodiscard]] auto operator<=>(const Version &rhs) const {
+        return compare(rhs) <=> 0;
+    }
 };
 
 /**

include/v10/qasm_new_to_old.hpp

@@ -7,7 +7,7 @@
 #pragma once
 #ifndef QASM_NEW_TO_OLD_HPP
 
-#include "cqasm.hpp"
+#include "v1x/cqasm.hpp"
 #include "qasm_ast.hpp"
 
 namespace compiler {