Integrate PR #666: Fix IS_IN validation and reserved property handling (#674)

## Summary

This PR integrates the fixes from PR #666 into the current
`arena-implementation` branch. PR #666 originally fixed IS_IN validation
and runtime handling for reserved properties, but the current
implementation has diverged significantly from when that PR was created.

## Problem

**Analyzer Issue**: The type validator incorrectly grouped `IS_IN` with
other boolean operations, expecting scalar arguments instead of arrays.
This caused compilation errors for queries like
`nodes::WHERE(_::{id}::IS_IN(node_ids))` when `node_ids` is `[ID]`.

**Runtime Issue**: The current implementation removed `filterable.rs`
and its special handling for reserved properties (id, label, etc.).
Reserved properties are now struct fields, not in the properties
HashMap, so `get_property("id")` returns `None`.

**Root Cause**: 
1. IS_IN validation expects scalars instead of arrays
2. Reserved properties lost special handling during refactoring
3. Type mismatch between `Value::String` and `Value::Id` for ID
operations

## Solution

### 1. Added Reserved Property Support
- Created `ReservedProp` enum for built-in properties: Id, Label,
Version, FromNode, ToNode, Deleted, Level, Distance, Data
- 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()` in `analyzer/utils.rs` to identify
reserved vs user-defined properties
- Reserved properties use direct struct field access:
`Value::Id(ID::from(val.id))`
- User-defined properties continue using `get_property()` HashMap lookup

### 3. Enhanced Boolean Operation Optimization
- Updated `WhereRef` Display implementation in `traversal_steps.rs` for
reserved properties
- Generates optimized filter code with correct Value types
- Example: `Value::Id(ID::from(val.id)).is_in(&data.node_ids)`

### 4. Fixed IS_IN Validation
- Separated IS_IN from scalar boolean operations in
`traversal_validation.rs`
- IS_IN now correctly expects `Type::Array(Box<Type::Scalar(ft)))`
arguments
- Added `get_reserved_property_type()` helper for type-safe validation
- Updated Node/Edge/Vector validation to check reserved properties first

## Files Changed

- `helix-db/src/helixc/generator/traversal_steps.rs` - Added
ReservedProp enum and Display logic
- `helix-db/src/helixc/analyzer/utils.rs` - Updated
gen_property_access()
- `helix-db/src/helixc/analyzer/methods/traversal_validation.rs` - Fixed
IS_IN validation and reserved property checking
- `hql-tests/tests/is_in/` - Added test cases for IS_IN with reserved
and user-defined properties

## Testing

Added comprehensive IS_IN tests:
```hql
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
```

**Verified**:
- ✅ Queries compile successfully
- ✅ Correct code generation for reserved properties (direct field
access)
- ✅ Correct code generation for user-defined properties (get_property)
- ✅ Type safety maintained for array operations

## Generated Code Example

For reserved property `id`:
```rust
.filter_ref(|val, txn|{
    if let Ok(val) = val {
        Ok(Value::Id(ID::from(val.id)).is_in(&data.node_ids))
    } else {
        Ok(false)
    }
})
```

For user-defined property `field`:
```rust
.filter_ref(|val, txn|{
    if let Ok(val) = val {
        Ok(val
        .get_property("field")
        .map_or(false, |v| v.is_in(&data.fields)))
    } else {
        Ok(false)
    }
})
```

## Impact

- IS_IN operations now work correctly with arrays at compile-time and
runtime
- Reserved properties return proper Value types for IS_IN comparisons
- Queries like `WHERE(_::{id}::IS_IN(node_ids))` compile and execute
without panics
- No breaking changes to existing functionality

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