feat(helixc): integrate PR #666 - fix IS_IN validation and reserved property handling

## Changes

### 1. Added Reserved Property Support
- Created `ReservedProp` enum for built-in properties (id, label, version, etc.)
- Added `Step::ReservedPropertyAccess` variant to generate direct field access
- Reserved properties now return correct Value types (e.g., Value::Id for id field)

### 2. Updated Property Access Generator
- Modified `gen_property_access()` to identify reserved vs user-defined properties
- Reserved properties use direct struct field access
- User-defined properties continue using `get_property()` HashMap lookup

### 3. Enhanced Boolean Operation Optimization
- Updated `WhereRef` Display implementation for reserved property optimization
- Generates `Value::Id(ID::from(val.id))` for id field in filters
- Maintains `get_property()` optimization for user-defined properties

### 4. Fixed IS_IN Validation
- Separated IS_IN from scalar boolean operations
- IS_IN now correctly expects `Type::Array` arguments with scalar elements
- Added `get_reserved_property_type()` helper for type validation
- Updated Node/Edge/Vector validation to check reserved properties first

### 5. Testing
- Added IS_IN test with both reserved (id) and user-defined (field) properties
- Verified correct code generation and type safety

## Impact
Resolves the issues from original PR #666:
- IS_IN with arrays now validates at compile-time
- Reserved property access returns correct Value types for IS_IN operations
- Queries like `WHERE(_::{id}::IS_IN(node_ids))` now compile and execute correctly

Co-Authored-By: ishaksebsib <[email protected]>

Author: xav-db

helix-db/src/helixc/analyzer/methods/traversal_validation.rs

@@ -5,7 +5,7 @@ use crate::{
     helixc::{
         analyzer::{Ctx, errors::push_query_err, types::Type},
         generator::{
-            traversal_steps::Step,
+            traversal_steps::{Step, ReservedProp},
             utils::{GenRef, GeneratedValue},
         },
         parser::{location::Loc, types::*},
@@ -185,8 +185,15 @@ pub(super) fn get_field_type_from_item_fields(
 
 pub(super) fn gen_property_access(name: &str) -> Step {
     match name {
-        "id" => Step::PropertyFetch(GenRef::Literal("id".to_string())),
-        "ID" => Step::PropertyFetch(GenRef::Literal("id".to_string())),
+        "id" | "ID" | "Id" => Step::ReservedPropertyAccess(ReservedProp::Id),
+        "label" | "Label" => Step::ReservedPropertyAccess(ReservedProp::Label),
+        "version" | "Version" => Step::ReservedPropertyAccess(ReservedProp::Version),
+        "from_node" | "fromNode" | "FromNode" => Step::ReservedPropertyAccess(ReservedProp::FromNode),
+        "to_node" | "toNode" | "ToNode" => Step::ReservedPropertyAccess(ReservedProp::ToNode),
+        "deleted" | "Deleted" => Step::ReservedPropertyAccess(ReservedProp::Deleted),
+        "level" | "Level" => Step::ReservedPropertyAccess(ReservedProp::Level),
+        "distance" | "Distance" => Step::ReservedPropertyAccess(ReservedProp::Distance),
+        "data" | "Data" => Step::ReservedPropertyAccess(ReservedProp::Data),
         n => Step::PropertyFetch(GenRef::Literal(n.to_string())),
     }
 }

helix-db/src/helixc/analyzer/utils.rs

@@ -192,6 +192,21 @@ impl Traversal {
         result
     }
 }
+
+/// Reserved properties that are accessed directly from struct fields
+#[derive(Clone, Debug)]
+pub enum ReservedProp {
+    Id,
+    Label,
+    Version,
+    FromNode,
+    ToNode,
+    Deleted,
+    Level,
+    Distance,
+    Data,
+}
+
 #[derive(Clone)]
 pub enum Step {
     // graph steps
@@ -217,6 +232,7 @@ pub enum Step {
 
     // property
     PropertyFetch(GenRef<String>),
+    ReservedPropertyAccess(ReservedProp),
 
     // closure
     // Closure(ClosureRemapping),
@@ -243,6 +259,17 @@ impl Display for Step {
             Step::ToN => write!(f, "to_n()"),
             Step::ToV(to_v) => write!(f, "{to_v}"),
             Step::PropertyFetch(property) => write!(f, "get_property({property})"),
+            Step::ReservedPropertyAccess(prop) => match prop {
+                ReservedProp::Id => write!(f, "map(|item| Ok(Value::from(uuid_str(item.id, &arena))))"),
+                ReservedProp::Label => write!(f, "map(|item| Ok(Value::from(item.label)))"),
+                ReservedProp::Version => write!(f, "map(|item| Ok(Value::from(item.version)))"),
+                ReservedProp::FromNode => write!(f, "map(|item| Ok(Value::from(uuid_str(item.from_node, &arena))))"),
+                ReservedProp::ToNode => write!(f, "map(|item| Ok(Value::from(uuid_str(item.to_node, &arena))))"),
+                ReservedProp::Deleted => write!(f, "map(|item| Ok(Value::from(item.deleted)))"),
+                ReservedProp::Level => write!(f, "map(|item| Ok(Value::from(item.level)))"),
+                ReservedProp::Distance => write!(f, "map(|item| Ok(item.distance.map(Value::from).unwrap_or(Value::Empty)))"),
+                ReservedProp::Data => write!(f, "map(|item| Ok(Value::from(item.data)))"),
+            },
 
             Step::Out(out) => write!(f, "{out}"),
             Step::In(in_) => write!(f, "{in_}"),
@@ -271,6 +298,7 @@ impl Debug for Step {
             Step::FromN => write!(f, "FromN"),
             Step::ToN => write!(f, "ToN"),
             Step::PropertyFetch(property) => write!(f, "get_property({property})"),
+            Step::ReservedPropertyAccess(prop) => write!(f, "ReservedProperty({:?})", prop),
             Step::FromV(_) => write!(f, "FromV"),
             Step::ToV(_) => write!(f, "ToV"),
             Step::Out(_) => write!(f, "Out"),
@@ -401,23 +429,63 @@ impl Display for WhereRef {
             let is_val = matches!(var, GenRef::Std(s) | GenRef::Literal(s) if s == "val");
 
             if is_val && traversal.steps.len() == 2 {
-                // Check if we have PropertyFetch followed by BoolOp
+                // Check if we have PropertyFetch or ReservedPropertyAccess followed by BoolOp
                 let mut prop: Option<&GenRef<String>> = None;
+                let mut reserved_prop: Option<&ReservedProp> = None;
                 let mut bool_op: Option<&BoolOp> = None;
 
                 for step in &traversal.steps {
                     match step {
                         Separator::Period(Step::PropertyFetch(p))
                         | Separator::Newline(Step::PropertyFetch(p))
                         | Separator::Empty(Step::PropertyFetch(p)) => prop = Some(p),
+                        Separator::Period(Step::ReservedPropertyAccess(rp))
+                        | Separator::Newline(Step::ReservedPropertyAccess(rp))
+                        | Separator::Empty(Step::ReservedPropertyAccess(rp)) => reserved_prop = Some(rp),
                         Separator::Period(Step::BoolOp(op))
                         | Separator::Newline(Step::BoolOp(op))
                         | Separator::Empty(Step::BoolOp(op)) => bool_op = Some(op),
                         _ => {}
                     }
                 }
 
-                // If we found both PropertyFetch and BoolOp, generate optimized code
+                // Handle ReservedPropertyAccess with BoolOp - generate direct field access
+                if let (Some(reserved_prop), Some(bool_op)) = (reserved_prop, bool_op) {
+                    let value_expr = match reserved_prop {
+                        ReservedProp::Id => "Value::Id(ID::from(val.id))".to_string(),
+                        ReservedProp::Label => "Value::from(val.label)".to_string(),
+                        ReservedProp::Version => "Value::from(val.version)".to_string(),
+                        ReservedProp::FromNode => "Value::Id(ID::from(val.from_node))".to_string(),
+                        ReservedProp::ToNode => "Value::Id(ID::from(val.to_node))".to_string(),
+                        ReservedProp::Deleted => "Value::from(val.deleted)".to_string(),
+                        ReservedProp::Level => "Value::from(val.level)".to_string(),
+                        ReservedProp::Distance => "val.distance.map(Value::from).unwrap_or(Value::Empty)".to_string(),
+                        ReservedProp::Data => "Value::from(val.data)".to_string(),
+                    };
+                    let bool_expr = match bool_op {
+                        BoolOp::Gt(gt) => format!("{}{}", value_expr, gt),
+                        BoolOp::Gte(gte) => format!("{}{}", value_expr, gte),
+                        BoolOp::Lt(lt) => format!("{}{}", value_expr, lt),
+                        BoolOp::Lte(lte) => format!("{}{}", value_expr, lte),
+                        BoolOp::Eq(eq) => format!("{}{}", value_expr, eq),
+                        BoolOp::Neq(neq) => format!("{}{}", value_expr, neq),
+                        BoolOp::Contains(contains) => format!("{}{}", value_expr, contains),
+                        BoolOp::IsIn(is_in) => format!("{}{}", value_expr, is_in),
+                    };
+                    return write!(
+                        f,
+                        "filter_ref(|val, txn|{{
+                if let Ok(val) = val {{
+                    Ok({})
+                }} else {{
+                    Ok(false)
+                }}
+            }})",
+                        bool_expr
+                    );
+                }
+
+                // Handle PropertyFetch with BoolOp - use get_property
                 if let (Some(prop), Some(bool_op)) = (prop, bool_op) {
                     let bool_expr = match bool_op {
                         BoolOp::Gt(gt) => format!("*v{gt}"),

helix-db/src/helixc/generator/traversal_steps.rs

@@ -0,0 +1,9 @@
+[project]
+name = "mcp_macro"
+queries = "."
+
+[local.dev]
+port = 6969
+build_mode = "debug"
+
+[cloud]

hql-tests/tests/is_in/helix.toml

@@ -0,0 +1,13 @@
+N::MyNode { 
+    field: String,
+}
+
+
+QUERY GetNodes (fields: [String]) =>
+	node <- N<MyNode>::WHERE(_::{field}::IS_IN(fields))
+    RETURN node
+
+
+QUERY GetNodesByID (node_ids: [ID]) =>
+	node <- N<MyNode>::WHERE(_::{id}::IS_IN(node_ids))
+    RETURN node