tree-gen classes can now dump to JSON

.github/workflows/test.yml

@@ -153,7 +153,7 @@ jobs:
           miniconda-version: "latest"
           show-channel-urls: true
       - name: Install conda dependencies
-        run: conda install conda-build conda-verify -y
+        run: conda install conda-build conda-verify numpy -y
       - name: Build & test
         run: conda build python/conda
       - name: Install

Dockerfile

@@ -8,8 +8,8 @@ RUN apt-get -qq update && \
 ADD . /libqasm
 
 WORKDIR /libqasm
-RUN conan profile detect
-RUN conan build . -s:h compiler.cppstd=20 -o libqasm/*:build_tests=True -o libqasm/*:compat=True -o libqasm/*:tree_gen_build_tests=True -o libqasm/*:asan_enabled=True -b missing
+RUN conan profile detect --force
+RUN conan build . -pr=./conan/profiles/tests-debug-compat -b missing
 
 WORKDIR /libqasm/build/Release
 RUN ctest -C Release --output-on-failure

include/cqasm-utils.hpp

@@ -4,14 +4,14 @@
 
 #pragma once
 
+#include <fmt/format.h>
+#include <sstream>  // ostringstream
 #include <string>
 
-namespace cqasm {
-
 /**
  * Namespace for various utility functions.
  */
-namespace utils {
+namespace cqasm::utils {
 
 /**
  * Makes a string lowercase.
@@ -23,5 +23,21 @@ std::string to_lowercase(const std::string &name);
  */
 bool equal_case_insensitive(const std::string &lhs, const std::string &rhs);
 
-} // namespace utils
-} // namespace cqasm
+/**
+ * Returns a string with a JSON representation of a ParseResult or an AnalysisResult.
+ */
+template <typename Result>
+std::string to_json(const Result &result) {
+    if (!result.errors.empty()) {
+        return fmt::format(R"({{"errors":["{}"]}})",  // first quote of first error message, and
+                                                      // last quote of last error message
+            fmt::join(result.errors, R"(",")"));  // last quote of any intermediate error message, and
+                                                  // first quote of the following
+    } else {
+        std::ostringstream oss{};
+        result.root->dump_json(oss);
+        return oss.str();
+    }
+}
+
+} // namespace cqasm::utils

include/v1x/cqasm-analysis-result.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "cqasm-ast.hpp"
+#include "cqasm-semantic.hpp"
+
+#include <stdexcept>  // runtime_error
+#include <iosfwd>  // ostream
+#include <string>
+#include <vector>
+
+
+/**
+ * Namespace for the \ref cqasm::analyzer::Analyzer "Analyzer" class and support classes.
+ */
+namespace cqasm::v1x::analyzer {
+
+
+/**
+ * Exception thrown by AnalysisResult::unwrap() when the cQASM file fails to
+ * parse.
+ */
+class AnalysisFailed: public std::runtime_error {
+public:
+    AnalysisFailed() : std::runtime_error("cQASM analysis failed") {};
+};
+
+
+/**
+ * Analysis result class.
+ *
+ * An object of this type is returned by the various `analyze*()` methods of the Analyzer class.
+ * There are three possibilities.
+ *
+ *  - Analysis was successful.
+ *    In this case, \ref errors is empty, and \ref root contains a valid \ref semantic::Program "Program" tree.
+ *  - Analysis failed.
+ *    In this case, there is at least one string in \ref errors.
+ *    \ref root may be an empty reference, a partial tree, or even a complete but somehow invalid tree.
+ *  - Analysis failed spectacularly with an internal error,
+ *    in which case an exception is thrown instead of this object being returned.
+ *
+ * If you don't want to manage printing error messages yourself and would like an exception upon failure in all cases,
+ * you can call unwrap() on the returned object.
+ */
+class AnalysisResult {
+public:
+    /**
+     * Root node of the semantic tree, if analysis was successful.
+     * The node may be empty or incomplete if errors is nonempty;
+     * use unwrap() to ensure it's complete if you just want to use it and
+     * don't care about things like pretty-printing error messages for your users
+     * in a different way than what unwrap() does for you.
+     */
+    ast::One<semantic::Program> root;
+
+    /**
+     * List of accumulated errors.
+     * Analysis was successful if and only if `errors.empty()`.
+     */
+    std::vector<std::string> errors;
+
+    /**
+     * "Unwraps" the result (as you would in Rust) to get the program node or an exception.
+     * The exception is always an AnalysisFailed, deriving from std::runtime_error.
+     * The actual error messages are in this case first written to the given output stream, defaulting to stderr.
+     */
+    ast::One<semantic::Program> unwrap(std::ostream &out = std::cerr) const;
+
+    /**
+     * Returns a string with a JSON representation of the AnalysisResult.
+     */
+    std::string to_json() const;
+};
+
+} // namespace cqasm::v1x::analyzer

include/v1x/cqasm-analyzer.hpp

@@ -9,75 +9,21 @@
 
 #pragma once
 
+#include "cqasm-analysis-result.hpp"
 #include "cqasm-ast.hpp"
 #include "cqasm-parse-helper.hpp"
 #include "cqasm-resolver.hpp"
 #include "cqasm-semantic.hpp"
 
-#include <cstdio>
 #include <functional>
+#include <string>
 
 /**
  * Namespace for the \ref cqasm::analyzer::Analyzer "Analyzer" class and
  * support classes.
  */
 namespace cqasm::v1x::analyzer {
 
-/**
- * Exception thrown by AnalysisResult::unwrap() when the cQASM file fails to
- * parse.
- */
-class AnalysisFailed: public std::runtime_error {
-public:
-    AnalysisFailed() : std::runtime_error("cQASM analysis failed") {};
-};
-
-/**
- * Analysis result class.
- *
- * An object of this type is returned by the various `analyze*()` methods of
- * the Analyzer class. There are three possibilities.
- *
- *  - Analysis was successful. In this case, \ref errors is empty, and
- *    \ref root contains a valid \ref semantic::Program "Program" tree.
- *  - Analysis failed. In this case, there is at least one string in
- *    \ref errors. \ref root may be an empty reference, a partial tree,
- *    or even a complete but somehow invalid tree.
- *  - Analysis failed spectacularly with an internal error, in which case an
- *    exception is thrown instead of this object being returned.
- *
- * If you don't want to manage printing error messages yourself and would like
- * an exception upon failure in all cases, you can call unwrap() on the
- * returned object.
- */
-class AnalysisResult {
-public:
-
-    /**
-     * Root node of the semantic tree, if analysis was successful. The node may
-     * be empty or incomplete if errors is nonempty; use unwrap() to ensure it's
-     * complete if you just want to use it and don't care about things like
-     * pretty-printing error messages for your users in a different way than
-     * what unwrap() does for you.
-     */
-    ast::One<semantic::Program> root;
-
-    /**
-     * List of accumulated errors. Analysis was successful if and only if
-     * `errors.empty()`.
-     */
-    std::vector<std::string> errors;
-
-    /**
-     * "Unwraps" the result (as you would in Rust) to get the program node or
-     * an exception. The exception is always an AnalysisFailed, deriving from
-     * std::runtime_error. The actual error messages are in this case first
-     * written to the given output stream, defaulting to stderr.
-     */
-    ast::One<semantic::Program> unwrap(std::ostream &out = std::cerr) const;
-
-};
-
 /**
  * Main class used for analyzing cQASM files.
  *

include/v1x/cqasm-parse-result.hpp

@@ -9,7 +9,8 @@
 #include "cqasm-annotations.hpp"
 #include "cqasm-ast.hpp"
 
-#include <cstdio>
+#include <string>
+#include <vector>
 
 
 /**
@@ -22,7 +23,6 @@ namespace cqasm::v1x::parser {
  */
 class ParseResult {
 public:
-
     /**
      * Root node of the AST, if analysis was sufficiently successful.
      * This may be set even if parsing was not ENTIRELY successful,
@@ -36,6 +36,10 @@ class ParseResult {
      */
     std::vector<std::string> errors;
 
+    /**
+     * Returns a string with a JSON representation of the ParseResult.
+     */
+    std::string to_json() const;
 };
 
 } // namespace cqasm::v1x::parser

include/v1x/cqasm-py.hpp

@@ -14,7 +14,10 @@
 #include <vector>
 
 // Forward declarations for internal types.
-namespace cqasm::v1x::analyzer { class Analyzer; }
+namespace cqasm::v1x::analyzer {
+    class Analyzer;
+}
+
 
 /**
  * Main class for parsing and analyzing cQASM files with the v1.x API.
@@ -23,7 +26,7 @@ class V1xAnalyzer {
     /**
      * Reference to the actual C++ analyzer that this wraps.
      */
-    std::unique_ptr<cqasm::v1x::analyzer::Analyzer> a;
+    std::unique_ptr<cqasm::v1x::analyzer::Analyzer> analyzer;
 
 public:
     /**
@@ -36,10 +39,9 @@ class V1xAnalyzer {
      * the initial mappings and functions are not configurable at all.
      * The defaults for these are always used.
      */
-    explicit V1xAnalyzer(
-        const std::string &max_version = "1.0",
-        bool without_defaults = false
-    );
+    explicit V1xAnalyzer(const std::string &max_version = "1.0", bool without_defaults = false);
+
+    ~V1xAnalyzer();
 
     /**
      * Registers an instruction type.
@@ -58,10 +60,7 @@ class V1xAnalyzer {
      * Registers an error model.
      * The arguments are passed straight to error_model::ErrorModel's constructor.
      */
-    void register_error_model(
-        const std::string &name,
-        const std::string &param_types = ""
-    );
+    void register_error_model(const std::string &name, const std::string &param_types = "");
 
     /**
      * Only parses the given file.
@@ -71,18 +70,23 @@ class V1xAnalyzer {
      * of which the first is always present and is the CBOR serialization of the v1.x AST.
      * Any additional strings represent error messages.
      */
-    static std::vector<std::string> parse_file(
-        const std::string &filename
-    );
+    static std::vector<std::string> parse_file(const std::string &filename);
+
+    /**
+     * Counterpart of parse_file that returns a string with a JSON representation of the ParseResult.
+     */
+    static std::string parse_file_to_json(const std::string &filename);
 
     /**
      * Same as parse_file(), but instead receives the file contents directly.
      * The filename, if specified, is only used when reporting errors.
      */
-    static std::vector<std::string> parse_string(
-        const std::string &data,
-        const std::string &filename = "<unknown>"
-    );
+    static std::vector<std::string> parse_string(const std::string &data, const std::string &filename = "<unknown>");
+
+    /**
+     * Counterpart of parse_string that returns a string with a JSON representation of the ParseResult.
+     */
+    static std::string parse_string_to_json(const std::string &data, const std::string &filename = "<unknown>");
 
     /**
      * Parses and analyzes the given file.
@@ -93,16 +97,21 @@ class V1xAnalyzer {
      * of which the first is always present and is the CBOR serialization of the v1.x semantic tree.
      * Any additional strings represent error messages.
      */
-    std::vector<std::string> analyze_file(
-        const std::string &filename
-    ) const;
+    std::vector<std::string> analyze_file(const std::string &filename) const;
+
+    /**
+     * Counterpart of analyze_file that returns a string with a JSON representation of the AnalysisResult.
+     */
+    std::string analyze_file_to_json(const std::string &filename) const;
 
     /**
      * Same as analyze_file(), but instead receives the file contents directly.
      * The filename, if specified, is only used when reporting errors.
      */
-    std::vector<std::string> analyze_string(
-        const std::string &data,
-        const std::string &filename = "<unknown>"
-    ) const;
+    std::vector<std::string> analyze_string(const std::string &data, const std::string &filename = "<unknown>") const;
+
+    /**
+     * Counterpart of analyze_string that returns a string with a JSON representation of the AnalysisResult.
+     */
+    std::string analyze_string_to_json(const std::string &data, const std::string &filename = "<unknown>") const;
 };