feat: add synthetic file

Author: indietyp

libs/@local/hashql/core/src/symbol/mod.rs

@@ -258,6 +258,15 @@ impl<'heap> Symbol<'heap> {
     }
 }
 
+impl From<ConstantSymbol> for Symbol<'_> {
+    #[inline]
+    #[expect(unsafe_code)]
+    fn from(value: ConstantSymbol) -> Self {
+        // SAFETY: The constant symbol is already interned, so the repr is valid.
+        unsafe { Symbol::from_repr(Repr::constant(value.repr)) }
+    }
+}
+
 impl AsRef<Self> for Symbol<'_> {
     #[inline]
     fn as_ref(&self) -> &Self {

libs/@local/hashql/core/src/symbol/sym.rs

@@ -206,6 +206,8 @@ hashql_macros::define_symbols! {
     json,
     JsonPath,
     JsonPathSegment,
+    lhs,
+    rhs,
     // [tidy] sort alphabetically end
 
     internal: {

libs/@local/hashql/mir/src/reify/atom.rs

@@ -1,12 +1,15 @@
 use core::alloc::Allocator;
 
 use hashql_core::{id::Id as _, r#type::kind::TypeKind, value::Primitive};
-use hashql_hir::node::{
-    Node,
-    access::{Access, FieldAccess, IndexAccess},
-    data::Data,
-    kind::NodeKind,
-    variable::Variable,
+use hashql_hir::{
+    node::{
+        Node,
+        access::{Access, FieldAccess, IndexAccess},
+        data::Data,
+        kind::NodeKind,
+        variable::Variable,
+    },
+    path::QualifiedPath,
 };
 
 use super::{
@@ -154,6 +157,10 @@ impl<'heap, A: Allocator, S: Allocator> Reifier<'_, '_, '_, '_, 'heap, A, S> {
         }
     }
 
+    pub(super) fn qualified_variable(&mut self, path: QualifiedPath<'heap>, requires_thunk: bool) {
+        todo!()
+    }
+
     pub(super) fn operand(&mut self, node: Node<'heap>) -> Operand<'heap> {
         match node.kind {
             NodeKind::Variable(Variable::Qualified(_)) => {

libs/@local/hashql/mir/src/reify/error.rs

@@ -247,3 +247,76 @@ pub(crate) fn fat_call_on_constant(span: SpanId) -> ReifyDiagnostic {
 
     diagnostic
 }
+
+// Synthetic body diagnostics
+
+/// ICE: monomorphized closure type has wrong parameter count for a synthetic binary
+/// operation body.
+#[coverage(off)]
+pub(crate) fn synthetic_binary_arity_mismatch(
+    span: SpanId,
+    name: Symbol<'_>,
+    actual_params: usize,
+) -> ReifyDiagnostic<Critical> {
+    let mut diagnostic = Diagnostic::new(ReifyDiagnosticCategory::TypeInvariant, Critical::BUG)
+        .primary(Label::new(
+            span,
+            format!("monomorphized type of `{name}` has {actual_params} parameters, expected 2"),
+        ));
+
+    diagnostic.add_message(Message::note(
+        "binary operations require exactly 2 parameters after monomorphization",
+    ));
+
+    diagnostic.add_message(Message::help(
+        "type checking should have ensured the correct arity before reification",
+    ));
+
+    diagnostic
+}
+
+/// ICE: monomorphized closure type has wrong parameter count for a synthetic unary
+/// operation body.
+#[coverage(off)]
+pub(crate) fn synthetic_unary_arity_mismatch(
+    span: SpanId,
+    name: Symbol<'_>,
+    actual_params: usize,
+) -> ReifyDiagnostic<Critical> {
+    let mut diagnostic = Diagnostic::new(ReifyDiagnosticCategory::TypeInvariant, Critical::BUG)
+        .primary(Label::new(
+            span,
+            format!("monomorphized type of `{name}` has {actual_params} parameters, expected 1"),
+        ));
+
+    diagnostic.add_message(Message::note(
+        "unary operations require exactly 1 parameter after monomorphization",
+    ));
+
+    diagnostic.add_message(Message::help(
+        "type checking should have ensured the correct arity before reification",
+    ));
+
+    diagnostic
+}
+
+/// Intrinsic cannot be used as a first-class value.
+pub(crate) fn intrinsic_not_first_class(
+    span: SpanId,
+    name: Symbol<'_>,
+) -> ReifyDiagnostic<Critical> {
+    let mut diagnostic =
+        Diagnostic::new(ReifyDiagnosticCategory::UnsupportedFeature, Critical::ERROR).primary(
+            Label::new(span, format!("`{name}` cannot be used as a value")),
+        );
+
+    diagnostic.add_message(Message::note(format!(
+        "`{name}` is a syntactic form that is only valid at a call site"
+    )));
+
+    diagnostic.add_message(Message::help(
+        "call this intrinsic directly instead of passing it as an argument",
+    ));
+
+    diagnostic
+}

libs/@local/hashql/mir/src/reify/mod.rs

@@ -2,6 +2,7 @@ mod atom;
 mod current;
 mod error;
 mod rvalue;
+mod synthetic;
 mod terminator;
 mod transform;
 mod types;