Update TableGen for Qwerty_BasisVectorTreeAttr

qwerty_mlir/include/CAPI/Qwerty.h

@@ -90,6 +90,13 @@ MLIR_CAPI_EXPORTED bool mlirQwertyBasisVectorAttrGetHasPhase(MlirAttribute attr)
 MLIR_CAPI_EXPORTED MlirAttribute mlirQwertyBasisVectorListAttrGet(
         MlirContext ctx, intptr_t numVectors, MlirAttribute const *vectors);
 
+MLIR_CAPI_EXPORTED MlirAttribute mlirQwertyBasisVectorTreeAttrGet(
+        MlirContext ctx, int64_t kind, bool hasTilt, double tiltDeg,
+        intptr_t numChildren, MlirAttribute const *children);
+
+/// Returns true if this is a qwerty::BasisVectorTreeAttr.
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAQwertyBasisVectorTree(MlirAttribute attr);
+
 /// Returns true if this is a qwerty::BasisVectorListAttr.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAQwertyBasisVectorList(MlirAttribute attr);
 
@@ -115,6 +122,7 @@ MLIR_CAPI_EXPORTED bool mlirAttributeIsAQwertyBasisElem(MlirAttribute attr);
 /// qwerty::BasisVectorAttrs.
 MLIR_CAPI_EXPORTED MlirAttribute mlirQwertyBasisAttrGet(
         MlirContext ctx, intptr_t numElems, MlirAttribute const *elems);
+
 
 /// Returns true if this is a qwerty::BasisAttr.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAQwertyBasis(MlirAttribute attr);

qwerty_mlir/include/Qwerty/IR/QwertyAttributes.td

@@ -172,6 +172,40 @@ def Qwerty_BasisVectorListAttr : Qwerty_Attr<"BasisVectorList", "veclist"> {
     let genVerifyDecl = 1;
 }
 
+def Qwerty_BasisVectorTreeKindAttr : I64EnumAttr<
+        "BasisVectorTreeKind", "Kind of a recursive basis-vector tree node",
+        [
+            I64EnumAttrCase<"ZeroVector",   0>,
+            I64EnumAttrCase<"OneVector",    1>,
+            I64EnumAttrCase<"PadVector",    2>,
+            I64EnumAttrCase<"TargetVector", 3>,
+            I64EnumAttrCase<"VectorUnit",   4>,
+            I64EnumAttrCase<"VectorTilt",            5>,
+            I64EnumAttrCase<"UniformVectorSuperpos", 6>,
+            I64EnumAttrCase<"VectorTensor",          7>,
+        ]> {
+    let cppNamespace = "::qwerty";
+}
+
+def Qwerty_BasisVectorTreeAttr : Qwerty_Attr<"BasisVectorTree", "vectree"> {
+    let summary = "A recursive basis vector mirroring the AST `Vector` enum";
+    let description = [{
+        A mirror of the AST `Vector` type: one tree node per AST node. 
+        The front-end transcribes a `Vector` structurally, with no Pauli recognition,
+        factoring, or flattening; all semantic analysis happens downstream on
+        the tree.
+    }];
+    let parameters = (ins
+        "BasisVectorTreeKind":$kind,
+        OptionalParameter<"mlir::FloatAttr">:$tilt,
+        ArrayRefParameter<"BasisVectorTreeAttr", "">:$children
+    );
+
+    let hasCustomAssemblyFormat = 1;
+
+    let genVerifyDecl = 1;
+}
+
 def Qwerty_BasisElemAttr : Qwerty_Attr<"BasisElem", "basiselem"> {
     let summary = "Union of BuiltinBasisAttr, BasisVectorListAttr, and ApplyRevolveGeneratorAttr";
     let description = [{

qwerty_mlir/lib/CAPI/Qwerty.cpp

@@ -132,6 +132,28 @@ MlirAttribute mlirQwertyBasisVectorListAttrGet(
     return wrap(qwerty::BasisVectorListAttr::get(unwrap(ctx), vecs));
 }
 
+MlirAttribute mlirQwertyBasisVectorTreeAttrGet(
+        MlirContext ctx, int64_t kind, bool hasTilt, double tiltDeg,
+        intptr_t numChildren, MlirAttribute const *children) {
+    llvm::SmallVector<mlir::Attribute> attrs;
+    (void)unwrapList(static_cast<size_t>(numChildren), children, attrs);
+
+    llvm::SmallVector<qwerty::BasisVectorTreeAttr> trees;
+    for (mlir::Attribute attr : attrs) {
+        trees.push_back(llvm::cast<qwerty::BasisVectorTreeAttr>(attr));
+    }
+    mlir::FloatAttr tilt;
+    if (hasTilt) {
+        tilt = mlir::FloatAttr::get(mlir::Float64Type::get(unwrap(ctx)), tiltDeg);
+    }
+
+    return wrap(qwerty::BasisVectorTreeAttr::get(unwrap(ctx), static_cast<qwerty::BasisVectorTreeKind>(kind), tilt, trees));
+}
+
+bool mlirAttributeIsAQwertyBasisVectorTree(MlirAttribute attr) {
+    return llvm::isa<qwerty::BasisVectorTreeAttr>(unwrap(attr));
+}
+
 bool mlirAttributeIsAQwertyBasisVectorList(MlirAttribute attr) {
     return llvm::isa<qwerty::BasisVectorListAttr>(unwrap(attr));
 }

qwerty_mlir/lib/Qwerty/IR/QwertyAttributes.cpp

@@ -499,6 +499,118 @@ mlir::LogicalResult BasisVectorListAttr::verify(
     return mlir::success();
 }
 
+mlir::LogicalResult BasisVectorTreeAttr::verify(
+        llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
+        BasisVectorTreeKind kind,
+        mlir::FloatAttr tilt,
+        llvm::ArrayRef<BasisVectorTreeAttr> children) {
+    bool hasTilt = (bool)tilt;
+    size_t n = children.size();
+
+    auto angleErr = [&](bool requiredAngle) {
+        return emitError() << stringifyBasisVectorTreeKind(kind)
+                           << (requiredAngle ? " requires an angle"
+                                         : " must not carry an angle");
+    };
+    auto arityErr = [&](const char *numChildren) {
+        return emitError() << stringifyBasisVectorTreeKind(kind) << " expects "
+                           << numChildren << " child(ren), got " << n;
+    };
+
+    switch (kind) {
+    case BasisVectorTreeKind::ZeroVector:
+    case BasisVectorTreeKind::OneVector:
+    case BasisVectorTreeKind::PadVector:
+    case BasisVectorTreeKind::TargetVector:
+    case BasisVectorTreeKind::VectorUnit:
+        if (hasTilt) return angleErr(false);
+        if (n != 0) return arityErr("no");
+        return mlir::success();
+
+    case BasisVectorTreeKind::VectorTilt:
+        if (!hasTilt) return angleErr(true);
+        if (n != 1) return arityErr("exactly 1");
+        return mlir::success();
+
+    case BasisVectorTreeKind::UniformVectorSuperpos:
+        if (hasTilt) return angleErr(false);
+        if (n != 2) return arityErr("exactly 2");
+        return mlir::success();
+
+    case BasisVectorTreeKind::VectorTensor:
+        if (hasTilt) return angleErr(false);
+        if (n < 2) return arityErr("at least 2");
+        return mlir::success();
+    }
+    return emitError() << "unknown BasisVectorTreeKind";
+}
+
+void BasisVectorTreeAttr::print(mlir::AsmPrinter &printer) const {
+    printer << "<" << stringifyBasisVectorTreeKind(getKind());
+    if (mlir::FloatAttr tilt = getTilt()) {
+        printer << " tilt " << tilt;
+    }
+    printer << " [";
+    llvm::ArrayRef<BasisVectorTreeAttr> children = getChildren();
+    for (size_t i = 0; i < children.size(); i++) {
+        if (i) {
+            printer << ", ";
+        }
+        printer << children[i];
+    }
+    printer << "]>";
+}
+
+mlir::Attribute BasisVectorTreeAttr::parse(mlir::AsmParser &parser, mlir::Type odsType) {
+    llvm::SMLoc loc = parser.getCurrentLocation();
+    if (parser.parseLess()) {
+        return {};
+    }
+
+    llvm::StringRef kindKeyword;
+    if (parser.parseKeyword(&kindKeyword)) {
+        return {};
+    }
+    std::optional<BasisVectorTreeKind> kind =
+        symbolizeBasisVectorTreeKind(kindKeyword);
+    if (!kind) {
+        parser.emitError(loc, "unknown BasisVectorTreeKind: '")
+            << kindKeyword << "'";
+        return {};
+    }
+
+    mlir::FloatAttr tilt;
+    if (succeeded(parser.parseOptionalKeyword("tilt"))) {
+        if (parser.parseAttribute(tilt)) {
+            return {};
+        }
+    }
+
+    llvm::SmallVector<BasisVectorTreeAttr> children;
+    if (parser.parseLSquare()) {
+        return {};
+    }
+    if (failed(parser.parseOptionalRSquare())) {
+        do {
+            BasisVectorTreeAttr child;
+            if (parser.parseAttribute(child)) {
+                return {};
+            }
+            children.push_back(child);
+        } while (succeeded(parser.parseOptionalComma()));
+        if (parser.parseRSquare()) {
+            return {};
+        }
+    }
+
+    if (parser.parseGreater()) {
+        return {};
+    }
+
+    return parser.getChecked<BasisVectorTreeAttr>(
+        loc, parser.getContext(), *kind, tilt, children);
+}
+
 mlir::LogicalResult ApplyRevolveGeneratorAttr::verify(
         llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
         BasisAttr foo,

qwerty_mlir/tests/Qwerty/IR/vectree.mlir

@@ -0,0 +1,21 @@
+// RUN: qwerty-opt -split-input-file %s | qwerty-opt -split-input-file | FileCheck --strict-whitespace %s
+//
+// Happy-path round-trip (parse -> print -> parse -> print) of
+// BasisVectorTreeAttr. If any case were malformed, parsing would fail and the round-trip would error here.
+
+
+// A bare leaf atom: '0'  (0 children -> empty brackets)
+// CHECK: qwerty.t = #qwerty.vectree<ZeroVector []>
+module attributes {qwerty.t = #qwerty.vectree<ZeroVector []>} {}
+
+// -----
+
+// A tensor of computational atoms: '00'
+// CHECK: qwerty.t = #qwerty.vectree<VectorTensor [#qwerty.vectree<ZeroVector []>, #qwerty.vectree<ZeroVector []>]>
+module attributes {qwerty.t = #qwerty.vectree<VectorTensor [#qwerty.vectree<ZeroVector []>, #qwerty.vectree<ZeroVector []>]>} {}
+
+// -----
+
+// The non-Pauli vector '0'@45 + '1'.
+// CHECK: qwerty.t = #qwerty.vectree<UniformVectorSuperpos [#qwerty.vectree<VectorTilt tilt {{[0-9.eE+-]+}} : f64 [#qwerty.vectree<ZeroVector []>]>, #qwerty.vectree<OneVector []>]>
+module attributes {qwerty.t = #qwerty.vectree<UniformVectorSuperpos [#qwerty.vectree<VectorTilt tilt 45.0 : f64 [#qwerty.vectree<ZeroVector []>]>, #qwerty.vectree<OneVector []>]>} {}