fixing some bugs, got `in` query working passably

testsuite/query-in-expression/main.tri

···
+import "trilogy:debug" use dbg
+
+func make_twice n = [n, n]
+
+proc main!() {
+  for x in make_twice 3 {
+    dbg!(x)
+  }
+}
+

testsuite/query-in-expression/spec.toml

···
+output = "3\n3\n"

testsuite/query-in/main.tri

···
     dbg!(x)
   }
 
+  let mut n = 0
   for x in [|4, 4, 4, 5, 5|] {
-    dbg!(x)
+    n += 1
   }
+  assert n == 2
 
+  let mut m = 0
   for x in {| 'a => 1, 'b => 2 |} {
-    dbg!(x)
+    m += 1
   }
+  assert m == 2
 }

testsuite/query-in/spec.toml

···
-output = "1\n2\n3\n4\n5\na:1\nb:2\n"
+output = "1\n2\n3\n"

testsuite/record-elements-ref-eq/main.tri

···
+proc main!() {
+  let x = []
+  let y = []
+  let rec = {| x => 1 , y => 2 |}
+  assert rec.x == 1
+  assert rec.y == 2
+}

testsuite/rule-recursive/main.tri

···
 import "trilogy:debug" use dbg
 
 rule array_iterate(element, [element, .._])
-rule array_iterate(element, [_, ..rest]) <- array_iterate(element, rest)
+rule array_iterate(element, [_, ..rest]) <- array_iterate(element, ^rest)
 rule array_iterate(_, []) <- end
 
 proc main!() {

testsuite/set-elements-ref-eq/main.tri

···
+proc main!() {
+  let x = []
+  let y = []
+  let set = [| x, y |]
+  assert set == [| x, y |]
+  assert set != [| x |]
+}

trilogy-ir/src/visitor/bindings.rs

···
 use std::collections::HashSet;
 
 pub struct Bindings {
+    is_bindable: bool,
     bindings: HashSet<Id>,
 }
 
 impl Bindings {
     pub fn of<N: IrVisitable>(node: &N) -> HashSet<Id> {
         let mut bindings = Self {
+            is_bindable: true,
             bindings: HashSet::default(),
         };
         node.visit(&mut bindings);
···
             Disjunction(pair) => self.visit_disjunction(pair),
             Application(application) => self.visit_application(application),
             Reference(ident) => {
-                self.bindings.insert(ident.id.clone());
+                if self.is_bindable {
+                    self.bindings.insert(ident.id.clone());
+                }
             }
             Set(pack) => self.visit_set(pack),
             Array(pack) => self.visit_array(pack),
···
     fn visit_application(&mut self, node: &Application) {
         match &node.function.value {
             Value::Builtin(Builtin::Pin) => {}
-            _ => node.visit(self),
+            Value::Builtin(Builtin::Glue)
+            | Value::Builtin(Builtin::Negate)
+            | Value::Builtin(Builtin::Cons)
+            | Value::Builtin(Builtin::Typeof)
+            | Value::Builtin(Builtin::Construct) => {
+                self.is_bindable = true;
+                node.argument.visit(self);
+            }
+            _ => {
+                let was_bindable = self.is_bindable;
+                self.is_bindable = false;
+                node.function.visit(self);
+                node.argument.visit(self);
+                self.is_bindable = self.is_bindable || was_bindable;
+            }
         }
     }
 

trilogy-llvm/core/trilogy_record.c

···
             if (insert_to && *insert_to == record->cap) *insert_to = h;
             continue;
         }
-        if (trilogy_value_structural_eq(key, &entry->fst)) {
+        if (trilogy_value_referential_eq(key, &entry->fst)) {
             if (insert_to) *insert_to = h;
             return h;
         }

trilogy-llvm/core/trilogy_set.c

···
             if (insert_to && *insert_to == set->cap) *insert_to = h;
             continue;
         }
-        if (trilogy_value_structural_eq(key, &entry->fst)) {
+        if (trilogy_value_referential_eq(key, &entry->fst)) {
             if (insert_to) *insert_to = h;
             return h;
         }

trilogy-llvm/src/query.rs

···
                 // NOTE: at this time, the lookup expression is not an arbitrary expression, only a
                 // reference/module path, so branching is not possible here.
                 let rule = self.compile_expression(&lookup.path, "rule")?;
-                self.perform_lookup(rule, &lookup.patterns, next_to, done_to, bound_ids)?;
+
+                let arguments = lookup
+                    .patterns
+                    .iter()
+                    .map(|pattern| self.compile_input_pattern(pattern))
+                    .collect::<Option<Vec<_>>>()?;
+
+                let (next_iteration_inner, output_arguments) = self.call_rule(
+                    rule,
+                    &arguments,
+                    self.use_temporary(done_to).unwrap(),
+                    "lookup_next",
+                );
+
+                self.bind_temporary(next_iteration_inner);
+
+                // Wrap the next iteration with our own, as a lookup requires some cleanup
+                // before starting its next internal iteration.
+                let next_iteration_with_cleanup = self.add_continuation("lookup.next");
+                let (next_iteration_with_cleanup_continuation, next_iteration_with_cleanup_cp) =
+                    self.capture_current_continuation(next_iteration_with_cleanup, "lookup.next");
+
+                let bound_before_lookup = bound_ids.len();
+                for (pattern, out_value) in lookup.patterns.iter().zip(output_arguments) {
+                    let out_value = self.use_temporary(out_value).unwrap();
+                    self.compile_pattern_match_with_bindings(
+                        pattern,
+                        out_value,
+                        next_iteration_with_cleanup_continuation,
+                        bound_ids,
+                    )?;
+                }
+
+                self.call_known_continuation(
+                    self.use_temporary(next_to).unwrap(),
+                    next_iteration_with_cleanup_continuation,
+                );
+
+                self.become_continuation_point(next_iteration_with_cleanup_cp);
+                self.begin_next_function(next_iteration_with_cleanup);
+                self.cleanup_go_next(next_iteration_inner, bound_ids, bound_before_lookup);
             }
             ir::QueryValue::Disjunction(disj) => {
                 let disj_second_fn = self.add_continuation("disj.second");
···
                 self.next_cleanup(done_to, next_to, bound_ids, pre_len, "assign_next");
             }
             ir::QueryValue::Element(unification) => {
+                let input = self.compile_input_pattern(&unification.pattern)?;
+                let collection =
+                    self.compile_expression(&unification.expression, "in.collection")?;
                 let elem = self.elem();
-                self.perform_lookup(
+                let (next_iteration_inner, output_arguments) = self.call_rule(
                     elem,
-                    [&unification.pattern, &unification.expression],
-                    next_to,
-                    done_to,
+                    &[self.use_temporary(input).unwrap(), collection],
+                    self.use_temporary(done_to).unwrap(),
+                    "lookup_next",
+                );
+
+                // The element unification is kind of implemented weird. The actual iteration
+                // is implemented as a rule in core.tri, but we call it in a way that would be
+                // syntactically invalid, though functionally possible; the difference being
+                // that the second argument is an expression (not a pattern) and does not get
+                // used as an output parameter.
+                self.bind_temporary(next_iteration_inner);
+
+                // Wrap the next iteration with our own, as a lookup requires some cleanup
+                // before starting its next internal iteration.
+                let next_iteration_with_cleanup = self.add_continuation("in.next");
+                let (next_iteration_with_cleanup_continuation, next_iteration_with_cleanup_cp) =
+                    self.capture_current_continuation(next_iteration_with_cleanup, "in.next");
+
+                let bound_before_lookup = bound_ids.len();
+                self.compile_pattern_match_with_bindings(
+                    &unification.pattern,
+                    output_arguments[0],
+                    next_iteration_with_cleanup_continuation,
                     bound_ids,
                 )?;
+
+                self.call_known_continuation(
+                    self.use_temporary(next_to).unwrap(),
+                    next_iteration_with_cleanup_continuation,
+                );
+
+                self.become_continuation_point(next_iteration_with_cleanup_cp);
+                self.begin_next_function(next_iteration_with_cleanup);
+                self.cleanup_go_next(next_iteration_inner, bound_ids, bound_before_lookup);
             }
             ir::QueryValue::Not(query) => {
                 let go_next_fn = self.add_continuation("not.next");
···
         self.void_call_continuation(next_iteration);
     }
 
-    fn perform_lookup<'a>(
-        &self,
-        rule: PointerValue<'ctx>,
-        patterns: impl IntoIterator<Item = &'a ir::Expression> + Copy,
-        next_to: PointerValue<'ctx>,
-        done_to: PointerValue<'ctx>,
-        bound_ids: &mut Vec<Id>,
-    ) -> Option<()> {
-        // NOTE: similarly, the arguments of a query must be syntactically both patterns and
+    fn compile_input_pattern(&self, pattern: &ir::Expression) -> Option<PointerValue<'ctx>> {
+        // NOTE: the arguments of a query must be syntactically both patterns and
         // expressions, so we can again guarantee that branching is not possible.
-        let arguments = patterns
-            .into_iter()
-            .map(|pattern| {
-                if !pattern.can_evaluate() {
-                    // This pattern is not possibly an expression, e.g. due to containing a wildcard
-                    // or other pattern-only syntax element. It can only be used as an output parameter.
-                    let arg = self.allocate_undefined("out_arg");
-                    self.bind_temporary(arg);
-                    return Some(arg);
-                }
-                let variables = pattern
-                    .bindings()
-                    .iter()
-                    .map(|var| self.get_variable(var).unwrap())
-                    .collect::<Vec<_>>();
-                if variables.is_empty() {
-                    let arg = self.compile_expression(pattern, "in_arg")?;
-                    self.bind_temporary(arg);
-                    return Some(arg);
-                }
-                // This pattern is (potentially) fully defined. We must confirm by checking all
-                // the variables at runtime, and if they are all set, then we can construct
-                // this pattern.
-                let out_block = self.context.append_basic_block(self.get_function(), "out");
-                let original_function = self.get_function();
-                let snapshot = self.snapshot_function_context();
-                for variable in variables {
-                    let next_arg = self.context.append_basic_block(self.get_function(), "next");
-                    self.branch_undefined(variable.ptr(), out_block, next_arg);
-                    self.builder.position_at_end(next_arg);
-                }
-                let in_arg = self.compile_expression(pattern, "in_arg")?;
-                let final_function = self.get_function();
-                if original_function == final_function {
-                    let merge_block = self.context.append_basic_block(final_function, "merge_arg");
+        if !pattern.can_evaluate() {
+            // This pattern is not possibly an expression, e.g. due to containing a wildcard
+            // or other pattern-only syntax element. It can only be used as an output parameter.
+            let arg = self.allocate_undefined("out_arg");
+            self.bind_temporary(arg);
+            return Some(arg);
+        }
+        let variables = pattern
+            .bindings()
+            .iter()
+            .map(|var| self.get_variable(var).unwrap())
+            .collect::<Vec<_>>();
+        if variables.is_empty() {
+            let arg = self.compile_expression(pattern, "in_arg")?;
+            self.bind_temporary(arg);
+            return Some(arg);
+        }
+        // This pattern is (potentially) fully defined. We must confirm by checking all
+        // the variables at runtime, and if they are all set, then we can construct
+        // this pattern.
+        let out_block = self.context.append_basic_block(self.get_function(), "out");
+        let original_function = self.get_function();
+        let snapshot = self.snapshot_function_context();
+        for variable in variables {
+            let next_arg = self.context.append_basic_block(self.get_function(), "next");
+            self.branch_undefined(variable.ptr(), out_block, next_arg);
+            self.builder.position_at_end(next_arg);
+        }
+        let in_arg = self.compile_expression(pattern, "in_arg")?;
+        let final_function = self.get_function();
+        if original_function == final_function {
+            let merge_block = self.context.append_basic_block(final_function, "merge_arg");
 
-                    let in_block = self.builder.get_insert_block().unwrap();
-                    self.builder
-                        .build_unconditional_branch(merge_block)
-                        .unwrap();
-
-                    self.builder.position_at_end(out_block);
-                    let out_arg = self.allocate_undefined("out_arg");
-                    self.builder
-                        .build_unconditional_branch(merge_block)
-                        .unwrap();
-
-                    self.builder.position_at_end(merge_block);
-                    let phi = self
-                        .builder
-                        .build_phi(self.context.ptr_type(AddressSpace::default()), "arg")
-                        .unwrap();
-                    phi.add_incoming(&[(&in_arg, in_block), (&out_arg, out_block)]);
-                    let arg = phi.as_basic_value().into_pointer_value();
-                    self.bind_temporary(arg);
-                    Some(arg)
-                } else {
-                    let arg_continuation = self.add_continuation("arg");
-                    let end = self.continue_in_scope(arg_continuation, in_arg);
-                    self.end_continuation_point_as_close(end);
-
-                    self.restore_function_context(snapshot);
-                    self.builder.position_at_end(out_block);
-                    let end = self.void_continue_in_scope(arg_continuation);
-                    self.end_continuation_point_as_close(end);
+            let in_block = self.builder.get_insert_block().unwrap();
+            self.builder
+                .build_unconditional_branch(merge_block)
+                .unwrap();
 
-                    self.begin_next_function(arg_continuation);
-                    let arg = self.get_continuation("arg");
-                    self.bind_temporary(arg);
-                    Some(arg)
-                }
-            })
-            .collect::<Option<Vec<_>>>()?;
+            self.builder.position_at_end(out_block);
+            let out_arg = self.allocate_undefined("out_arg");
+            self.builder
+                .build_unconditional_branch(merge_block)
+                .unwrap();
 
-        let (next_iteration_inner, output_arguments) = self.call_rule(
-            rule,
-            &arguments,
-            self.use_temporary(done_to).unwrap(),
-            "lookup_next",
-        );
-        self.bind_temporary(next_iteration_inner);
+            self.builder.position_at_end(merge_block);
+            let phi = self
+                .builder
+                .build_phi(self.context.ptr_type(AddressSpace::default()), "arg")
+                .unwrap();
+            phi.add_incoming(&[(&in_arg, in_block), (&out_arg, out_block)]);
+            let arg = phi.as_basic_value().into_pointer_value();
+            self.bind_temporary(arg);
+            Some(arg)
+        } else {
+            let arg_continuation = self.add_continuation("arg");
+            let end = self.continue_in_scope(arg_continuation, in_arg);
+            self.end_continuation_point_as_close(end);
 
-        // Wrap the next iteration with our own, as a lookup requires some cleanup
-        // before starting its next internal iteration.
-        let next_iteration_with_cleanup = self.add_continuation("lookup.next");
-        let (next_iteration_with_cleanup_continuation, next_iteration_with_cleanup_cp) =
-            self.capture_current_continuation(next_iteration_with_cleanup, "lookup.next");
+            self.restore_function_context(snapshot);
+            self.builder.position_at_end(out_block);
+            let end = self.void_continue_in_scope(arg_continuation);
+            self.end_continuation_point_as_close(end);
 
-        let bound_before_lookup = bound_ids.len();
-        for (pattern, out_value) in patterns.into_iter().zip(output_arguments) {
-            let out_value = self.use_temporary(out_value).unwrap();
-            self.compile_pattern_match_with_bindings(
-                pattern,
-                out_value,
-                next_iteration_with_cleanup_continuation,
-                bound_ids,
-            )?;
+            self.begin_next_function(arg_continuation);
+            let arg = self.get_continuation("arg");
+            self.bind_temporary(arg);
+            Some(arg)
         }
-
-        self.call_known_continuation(
-            self.use_temporary(next_to).unwrap(),
-            next_iteration_with_cleanup_continuation,
-        );
-
-        self.become_continuation_point(next_iteration_with_cleanup_cp);
-        self.begin_next_function(next_iteration_with_cleanup);
-        self.cleanup_go_next(next_iteration_inner, bound_ids, bound_before_lookup);
-        Some(())
     }
 }

trilogy/src/stdlib/core.tri

···
 export to_array
 
 rule elem(element, [element, .._])
-rule elem(element, [_, ..rest]) <- elem(element, rest)
+rule elem(element, [_, ..rest]) <- elem(element, ^rest)
 rule elem(_, []) <- end
 rule elem(element, set and typeof 'set) <-
   array = c::set_to_array!(set)
-  and elem(element, array)
-rule elem(element, record and typeof 'record) <- array = c::record_to_array!(record)
-  and elem(element, array)
+  and elem(element, ^array)
+rule elem(element, record and typeof 'record) <-
+  array = c::record_to_array!(record)
+  and elem(element, ^array)
 export elem