✨ Enable QIR support #335

ystade · 2024-01-18T21:11:07Z

Description

⚠️ This is work in progress! 🚧

QIR is an LLVM IR dialect. This work aims to provide DDsim as a QIR backend. It packs DDsim into a shared library that can be linked with any .ll-file following the QIR specification resulting in an executable.

Checklist:

The pull request only contains commits that are related to it.
I have added appropriate tests and documentation.
I have made sure that all CI jobs on GitHub pass.
The pull request introduces no new warnings and follows the project's style guidelines.

codecov · 2024-01-18T21:16:42Z

Codecov Report

All modified and coverable lines are covered by tests ✅

Additional details and impacted files

@@          Coverage Diff          @@
##            main    #335   +/-   ##
=====================================
  Coverage   92.7%   92.8%           
=====================================
  Files         35      35           
  Lines       2704    2703    -1     
  Branches     349     348    -1     
=====================================
  Hits        2509    2509           
+ Misses       195     194    -1

Flag	Coverage Δ
cpp	`94.6% <ø> (+<0.1%)`	⬆️
python	`87.9% <ø> (ø)`

see 2 files with indirect coverage changes

github-actions · 2024-05-23T07:18:15Z

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy reports: 623 concern(s)

include/qir/DDsimQir.h:6:10: warning: [modernize-deprecated-headers]

including 'stdbool.h' has no effect in C++; consider removing it
```
#include <stdbool.h>
~~~~~~~~~^~~~~~~~~~~
```

include/qir/DDsimQir.h:21:1: warning: [modernize-use-using]

typedef signed long long int Int;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Int = long long

include/qir/DDsimQir.h:21:9: warning: [google-runtime-int]

consider replacing 'long long' with 'int64'
```
typedef signed long long int Int;
        ^
```

include/qir/DDsimQir.h:22:1: warning: [modernize-use-using]

typedef double               Double;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Double = double

include/qir/DDsimQir.h:23:1: warning: [modernize-use-using]

typedef bool                 Bool;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Bool = bool

include/qir/DDsimQir.h:24:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef enum {
^~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:25:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_I'
```
    PauliId_I = 0,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:26:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_X'
```
    PauliId_X = 1,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:27:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Z'
```
    PauliId_Z = 2,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:28:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Y'
```
    PauliId_Y = 3,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:30:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef struct {
^~~~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:37:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void BigInt;
^~~~~~~~~~~~~~~~~~~
using BigInt = void
```
include/qir/DDsimQir.h:42:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Result;
^~~~~~~~~~~~~~~~~~~
using Result = void
```
include/qir/DDsimQir.h:45:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_zero', which is a reserved identifier
```
Result* __quantum__rt__result_get_zero();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:45:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_zero'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_one', which is a reserved identifier
```
Result* __quantum__rt__result_get_one();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_one'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_equal', which is a reserved identifier
```
Bool __quantum__rt__result_equal(Result*, Result*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_update_reference_count', which is a reserved identifier
```
void __quantum__rt__result_update_reference_count(Result*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:55:60: warning: [google-runtime-int]

void __quantum__rt__result_update_reference_count(Result*, long int);
                                                           ^

include/qir/DDsimQir.h:59:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Qubit;
^~~~~~~~~~~~~~~~~~
using Qubit = void
```
include/qir/DDsimQir.h:64:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef char String;
^~~~~~~~~~~~~~~~~~~
using String = char
```
include/qir/DDsimQir.h:67:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_create', which is a reserved identifier
```
String* __quantum__rt__string_create(const char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:67:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_data', which is a reserved identifier
```
const char* __quantum__rt__string_get_data(String*);
            ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__string_get_length(String*);
^
```
include/qir/DDsimQir.h:73:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_length', which is a reserved identifier
```
long int __quantum__rt__string_get_length(String*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_update_reference_count', which is a reserved identifier
```
void __quantum__rt__string_update_reference_count(String*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:77:60: warning: [google-runtime-int]

void __quantum__rt__string_update_reference_count(String*, long int);
                                                           ^

include/qir/DDsimQir.h:80:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_concatenate', which is a reserved identifier
```
String* __quantum__rt__string_concatenate(String*, String*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:80:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_equal', which is a reserved identifier
```
Bool __quantum__rt__string_equal(String*, String*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__int_to_string', which is a reserved identifier
```
String* __quantum__rt__int_to_string(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__int_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__double_to_string', which is a reserved identifier
```
String* __quantum__rt__double_to_string(Double);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__double_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bool_to_string', which is a reserved identifier
```
String* __quantum__rt__bool_to_string(Bool);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bool_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_to_string', which is a reserved identifier
```
String* __quantum__rt__result_to_string(Result*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__pauli_to_string', which is a reserved identifier
```
String* __quantum__rt__pauli_to_string(Pauli);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__pauli_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_to_string', which is a reserved identifier
```
String* __quantum__rt__qubit_to_string(Qubit*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__range_to_string', which is a reserved identifier
```
String* __quantum__rt__range_to_string(Range);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__range_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_to_string', which is a reserved identifier
```
String* __quantum__rt__bigint_to_string(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_i64', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_i64(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_i64'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_array', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_array(long int, char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_array'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:117:44: warning: [google-runtime-int]

BigInt* __quantum__rt__bigint_create_array(long int, char*);
                                           ^

include/qir/DDsimQir.h:120:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_data', which is a reserved identifier
```
char* __quantum__rt__bigint_get_data(BigInt*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:120:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__bigint_get_length(BigInt*);
^
```
include/qir/DDsimQir.h:123:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_length', which is a reserved identifier
```
long int __quantum__rt__bigint_get_length(BigInt*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_update_reference_count', which is a reserved identifier
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:127:60: warning: [google-runtime-int]

void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
                                                           ^

include/qir/DDsimQir.h:130:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_negate', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_negate(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:130:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_negate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_add', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_add(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_add'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_subtract', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_subtract(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_subtract'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_multiply', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_multiply(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_multiply'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_divide', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_divide(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_divide'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_modulus', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_modulus(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_modulus'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_power', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_power(BigInt*, long int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_power'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:148:46: warning: [google-runtime-int]

BigInt* __quantum__rt__bigint_power(BigInt*, long int);
                                             ^

include/qir/DDsimQir.h:151:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitand', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitand(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:151:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitand'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitxor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitxor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitxor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitnot', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitnot(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitnot'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftleft', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftleft(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftleft'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftright', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftright(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftright'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_equal', which is a reserved identifier
```
Bool __quantum__rt__bigint_equal(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater_eq', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater_eq(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater_eq'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:180:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Tuple;
^~~~~~~~~~~~~~~~~~
using Tuple = void
```
include/qir/DDsimQir.h:183:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_create', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_create(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:183:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_copy', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_copy(Tuple*, Bool force);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_reference_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:190:58: warning: [google-runtime-int]

void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
                                                         ^

include/qir/DDsimQir.h:193:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_alias_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:193:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:193:54: warning: [google-runtime-int]

void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
                                                     ^

include/qir/DDsimQir.h:198:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Array;
^~~~~~~~~~~~~~~~~~
using Array = void
```
include/qir/DDsimQir.h:202:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create_1d', which is a reserved identifier
```
Array* __quantum__rt__array_create_1d(long int, Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:39: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_create_1d(long int, Int);
                                      ^
```
include/qir/DDsimQir.h:205:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_copy', which is a reserved identifier
```
Array* __quantum__rt__array_copy(Array*, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:205:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_concatenate', which is a reserved identifier
```
Array* __quantum__rt__array_concatenate(Array*, Array*);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice_1d', which is a reserved identifier
```
Array* __quantum__rt__array_slice_1d(Array*, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size_1d', which is a reserved identifier
```
Int __quantum__rt__array_get_size_1d(Array*);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr_1d', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr_1d(Array*, Int);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_reference_count', which is a reserved identifier
```
void __quantum__rt__array_update_reference_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:224:58: warning: [google-runtime-int]

void __quantum__rt__array_update_reference_count(Array*, long int);
                                                         ^

include/qir/DDsimQir.h:227:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_alias_count', which is a reserved identifier
```
void __quantum__rt__array_update_alias_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:227:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:227:54: warning: [google-runtime-int]

void __quantum__rt__array_update_alias_count(Array*, long int);
                                                     ^

include/qir/DDsimQir.h:233:8: warning: [bugprone-reserved-identifier]

Array* __quantum__rt__array_create(long int, long int, Int*);
       ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:233:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:233:36: warning: [google-runtime-int]

Array* __quantum__rt__array_create(long int, long int, Int*);
                                   ^

include/qir/DDsimQir.h:233:46: warning: [google-runtime-int]

Array* __quantum__rt__array_create(long int, long int, Int*);
                                             ^

include/qir/DDsimQir.h:236:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__array_get_dim(Array*);
^
```
include/qir/DDsimQir.h:236:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_dim', which is a reserved identifier
```
long int __quantum__rt__array_get_dim(Array*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:236:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_dim'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size', which is a reserved identifier
```
Int __quantum__rt__array_get_size(Array*, long int);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:240:43: warning: [google-runtime-int]

Int __quantum__rt__array_get_size(Array*, long int);
                                          ^

include/qir/DDsimQir.h:244:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr(Array*, Int*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:244:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:251:8: warning: [bugprone-reserved-identifier]

Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:251:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:251:43: warning: [google-runtime-int]

Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
                                          ^

include/qir/DDsimQir.h:258:8: warning: [bugprone-reserved-identifier]

Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:258:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_project'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:258:45: warning: [google-runtime-int]

Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
                                            ^

include/qir/DDsimQir.h:263:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Callable;
^~~~~~~~~~~~~~~~~~~~~
using Callable = void
```

include/qir/DDsimQir.h:267:11: warning: [bugprone-reserved-identifier]

Callable* __quantum__rt__callable_create(void (*f[4])(Tuple*, Tuple*, Tuple*), void (*m[2])(Tuple*, Tuple*, Tuple*), Tuple*);
          ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:267:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_copy', which is a reserved identifier
```
Callable* __quantum__rt__callable_copy(Callable*, Bool);
          ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_invoke', which is a reserved identifier
```
void __quantum__rt__callable_invoke(Callable*, Tuple*, Tuple*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_invoke'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_adjoint', which is a reserved identifier
```
void __quantum__rt__callable_make_adjoint(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_adjoint'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_controlled', which is a reserved identifier
```
void __quantum__rt__callable_make_controlled(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_controlled'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_reference_count', which is a reserved identifier
```
void __quantum__rt__callable_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:284:64: warning: [google-runtime-int]

void __quantum__rt__callable_update_reference_count(Callable*, long int);
                                                               ^

include/qir/DDsimQir.h:287:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_alias_count', which is a reserved identifier
```
void __quantum__rt__callable_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:287:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:287:60: warning: [google-runtime-int]

void __quantum__rt__callable_update_alias_count(Callable*, long int);
                                                           ^

include/qir/DDsimQir.h:291:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_reference_count', which is a reserved identifier
```
void __quantum__rt__capture_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:291:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:291:63: warning: [google-runtime-int]

void __quantum__rt__capture_update_reference_count(Callable*, long int);
                                                              ^

include/qir/DDsimQir.h:295:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_alias_count', which is a reserved identifier
```
void __quantum__rt__capture_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:295:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:295:59: warning: [google-runtime-int]

void __quantum__rt__capture_update_alias_count(Callable*, long int);
                                                          ^

include/qir/DDsimQir.h:301:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__message', which is a reserved identifier
```
void __quantum__rt__message(String* msg);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:301:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__message'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:304:16: warning: [bugprone-reserved-identifier]

_Noreturn void __quantum__rt__fail(String* msg);
               ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:304:16: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__fail'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate', which is a reserved identifier
```
Qubit* __quantum__rt__qubit_allocate();
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate_array', which is a reserved identifier
```
Array* __quantum__rt__qubit_allocate_array(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate_array'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_release', which is a reserved identifier
```
void __quantum__rt__qubit_release(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_release'
```
note: this fix will not be applied because it overlaps with another fix
```

Have any feedback or feature suggestions? Share it here.

update readme to describe how to generate a working example

uncomment unsued library to make example work

ystade and others added 2 commits January 18, 2024 21:37

✨ Start a QIR interafce

f4a8983

🎨 pre-commit fixes

9ad91fa

ystade self-assigned this Jan 18, 2024

ystade marked this pull request as draft January 18, 2024 21:12

ystade added the feature New feature or request label Jan 18, 2024

ystade and others added 5 commits May 23, 2024 09:12

🎨 Cleanup src and cmake file

d5d9206

🧪 Add failing test for QIR

f0c5223

🐛 Fix malloc

7365801

🔥 Comment out non working code

b7011f5

🎨 pre-commit fixes

336d7af

Erik Weilandt added 3 commits May 23, 2024 09:35

update QIR Readme

f7aaaae

update readme to describe how to generate a working example

fix final issue for working example

b7e6eaa

uncomment unsued library to make example work

Update MQT core

073036f

ErikLahm self-assigned this May 23, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

✨ Enable QIR support #335

✨ Enable QIR support #335

ystade commented Jan 18, 2024 •

edited

codecov bot commented Jan 18, 2024 •

edited

github-actions bot commented May 23, 2024

✨ Enable QIR support #335

Are you sure you want to change the base?

✨ Enable QIR support #335

Conversation

ystade commented Jan 18, 2024 • edited

Description

Checklist:

codecov bot commented Jan 18, 2024 • edited

Codecov Report

github-actions bot commented May 23, 2024

Cpp-Linter Report ⚠️

ystade commented Jan 18, 2024 •

edited

codecov bot commented Jan 18, 2024 •

edited