fix(cypher): conservative nullable default for complex expressions

[hemanta212]

Fix: Conservative nullability for Cypher expressions

Follow-up to PR #2 (Nullable return types). That PR added Required metadata from schema to codegen, allowing nullable fields to generate pointer types. However, it missed cases where nullability comes from query structure, not schema.

Problem

Two issues with the original approach:

1. OPTIONAL MATCH bindings - properties can be null regardless of schema:

OPTIONAL MATCH (author:User)-[:WROTE]->(c)
RETURN author.name  -- null if no author exists, even if schema says required

2. Complex expressions - null propagates through functions/arithmetic:

RETURN toUpper(u.name), u.age + 1, avg(u.age)  -- all can be null

Both generated non-pointer types, causing compile errors when mocks returned nil.

Solution

Conservative default: only trust schema Required for simple var.prop on non-optional bindings. Everything else bails to nullable.

// Before: default required, lookup schema
required := true

// After: default nullable, only trust simple patterns
required := false
if field, binding := lookupFieldFromExpression(expr, ctx); field != nil {
    if binding.optional { required = false }
    else { required = field.Required }
}

Result

Pattern	Type
u.name on MATCH	schema Required
u.name on OPTIONAL MATCH	*string
toUpper(u.name)	*string
count(u), avg(u.age)	*int, *float64

• dialects/cypher/analyzer.go: track optional bindings, flip default
• 12 focused test cases (5 existing schema + 7 new bailout patterns)
• repro example: 11/11 scopes passing

Design Decision

Chose conservative default over full null propagation tracking. Modeling Cypher's null semantics through arbitrary expressions (functions, operators, CASE) would require version-specific rules for dozens of constructs with limited benefit.

Being "over-nullable" (extra pointers) is safer than "under-nullable" (compile errors) for test scaffolding.

Future Work

Gradual whitelist for known non-null constructs:

• count(*) → always returns int, never null
• Literals (1, "foo", true) → non-null by definition
• IS NULL / IS NOT NULL → always returns bool
• coalesce(expr, <literal>) → non-null if fallback is non-null