refactor(builtins): migrate to Object/Set API

Migrates ~85 sites across src/builtins/ to the Object/Set API:
- objects.rs uses Object::get_or_insert_with for the merge path.
- sets.rs uses Set algebra methods (union/intersection/difference)
  returning fresh Set; replaces the previous Rc<BTreeSet> Deref +
  local BTreeSet pattern.
- graph.rs uses explicit iter_sorted().rev() where DoubleEndedIterator
  is required.
- utils.rs ensure_object / ensure_set return Rc<Object> / Rc<Set>.
- azure_policy template functions migrate to Object construction.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: anakrish

src/builtins/azure_policy/template_functions_collection.rs

@@ -7,11 +7,11 @@
 
 use crate::ast::{Expr, Ref};
 use crate::builtins;
+use crate::collections::Object;
 use crate::lexer::Span;
 use crate::value::Value;
 use crate::Rc;
 
-use alloc::collections::BTreeMap;
 use alloc::vec::Vec;
 use anyhow::Result;
 
@@ -72,7 +72,7 @@ fn fn_intersection(
             // Intersection of objects: keep key-value pairs from the first
             // object only when the key exists in every other object AND
             // the value is equal across all of them.
-            let mut result: BTreeMap<Value, Value> = first.as_ref().clone();
+            let mut result: Object = first.as_ref().clone();
             for arg in rest {
                 let Value::Object(ref other) = *arg else {
                     return Ok(Value::Undefined);
@@ -114,7 +114,7 @@ fn fn_union(_span: &Span, _params: &[Ref<Expr>], args: &[Value], _strict: bool)
         Value::Object(_) => {
             // Union of objects: recursive merge. Nested objects are merged
             // recursively; all other types (including arrays) use last-writer-wins.
-            let mut result = BTreeMap::<Value, Value>::new();
+            let mut result = Object::new();
             for arg in args {
                 let Value::Object(ref obj) = *arg else {
                     return Ok(Value::Undefined);
@@ -264,7 +264,7 @@ fn fn_create_object(
         );
     }
 
-    let mut map = BTreeMap::<Value, Value>::new();
+    let mut map = Object::new();
 
     for pair in args.chunks(2) {
         #[allow(clippy::pattern_type_mismatch)]
@@ -280,9 +280,9 @@ fn fn_create_object(
 
 /// Recursively merge two objects.  Nested objects are merged; everything
 /// else (including arrays) uses the value from `incoming`.
-fn merge_objects(base: &BTreeMap<Value, Value>, overlay: &BTreeMap<Value, Value>) -> Value {
+fn merge_objects(base: &Object, overlay: &Object) -> Value {
     let mut result = base.clone();
-    for (k, v) in overlay {
+    for (k, v) in overlay.iter() {
         #[allow(clippy::needless_borrowed_reference)]
         let merged = match (result.get(k), v) {
             (Some(&Value::Object(ref prev)), &Value::Object(ref next)) => merge_objects(prev, next),

src/builtins/azure_policy/template_functions_misc.rs

@@ -7,11 +7,11 @@
 
 use crate::ast::{Expr, Ref};
 use crate::builtins;
+use crate::collections::Object;
 use crate::lexer::Span;
 use crate::value::Value;
 use crate::Rc;
 
-use alloc::collections::BTreeMap;
 use alloc::string::{String, ToString as _};
 use alloc::vec::Vec;
 use anyhow::Result;
@@ -85,7 +85,7 @@ fn fn_items(_span: &Span, _params: &[Ref<Expr>], args: &[Value], _strict: bool)
     };
     let mut result = Vec::with_capacity(obj.len());
     for (k, v) in obj.as_ref() {
-        let mut entry = BTreeMap::<Value, Value>::new();
+        let mut entry = Object::new();
         entry.insert(Value::from("key"), k.clone());
         entry.insert(Value::from("value"), v.clone());
         result.push(Value::Object(Rc::new(entry)));

src/builtins/graph.rs

@@ -10,7 +10,7 @@ use crate::lexer::Span;
 use crate::value::Value;
 use crate::*;
 
-use alloc::collections::{BTreeMap, BTreeSet};
+use alloc::collections::BTreeSet;
 
 use anyhow::{bail, Result};
 
@@ -80,7 +80,7 @@ fn reachable(span: &Span, params: &[Ref<Expr>], args: &[Value], strict: bool) ->
 }
 
 fn visit(
-    graph: &BTreeMap<Value, Value>,
+    graph: &Object,
     visited: &mut BTreeSet<Value>,
     node: &Value,
     path: &mut Vec<Value>,
@@ -127,7 +127,7 @@ fn visit(
                 arr.len()
             }
             Some(Value::Set(set)) => {
-                for n in set.iter().rev() {
+                for n in set.iter_sorted().rev() {
                     visit(graph, visited, n, path, paths)?;
                 }
                 set.len()
@@ -173,7 +173,7 @@ fn reachable_paths(
             }
         }
         Value::Set(set) => {
-            for node in set.iter() {
+            for node in set.iter_sorted() {
                 visit(&graph, &mut visited, node, &mut path, &mut paths)?;
             }
         }

src/builtins/objects.rs

@@ -205,7 +205,7 @@ fn merge_filters(
                     let vref = match f {
                         Value::Object(obj) => {
                             let obj = Rc::make_mut(obj);
-                            let entry = obj.entry(p.clone()).or_insert_with(Value::new_object);
+                            let entry = obj.get_or_insert_with(p.clone(), Value::new_object);
                             // Guard filter map growth when creating nested objects.
                             enforce_limit()?;
                             entry

src/builtins/sets.rs

@@ -8,10 +8,9 @@ use crate::builtins;
 use crate::builtins::utils::{ensure_args_count, ensure_set};
 use crate::lexer::Span;
 use crate::value::Value;
+use crate::Set;
 use crate::*;
 
-use alloc::collections::BTreeSet;
-
 use anyhow::{bail, Result};
 
 pub fn register(m: &mut builtins::BuiltinsMap<&'static str, builtins::BuiltinFcn>) {
@@ -24,19 +23,19 @@ pub fn register(m: &mut builtins::BuiltinsMap<&'static str, builtins::BuiltinFcn
 pub fn intersection(expr1: &Expr, expr2: &Expr, v1: Value, v2: Value) -> Result<Value> {
     let s1 = ensure_set("intersection", expr1, v1)?;
     let s2 = ensure_set("intersection", expr2, v2)?;
-    Ok(Value::from_set(s1.intersection(&s2).cloned().collect()))
+    Ok(s1.intersection(&s2).into_value())
 }
 
 pub fn union(expr1: &Expr, expr2: &Expr, v1: Value, v2: Value) -> Result<Value> {
     let s1 = ensure_set("union", expr1, v1)?;
     let s2 = ensure_set("union", expr2, v2)?;
-    Ok(Value::from_set(s1.union(&s2).cloned().collect()))
+    Ok(s1.union(&s2).into_value())
 }
 
 pub fn difference(expr1: &Expr, expr2: &Expr, v1: Value, v2: Value) -> Result<Value> {
     let s1 = ensure_set("difference", expr1, v1)?;
     let s2 = ensure_set("difference", expr2, v2)?;
-    Ok(Value::from_set(s1.difference(&s2).cloned().collect()))
+    Ok(s1.difference(&s2).into_value())
 }
 
 fn binary_set_union(
@@ -49,7 +48,7 @@ fn binary_set_union(
     ensure_args_count(span, name, params, args, 2)?;
     let left = ensure_set(name, &params[0], args[0].clone())?;
     let right = ensure_set(name, &params[1], args[1].clone())?;
-    Ok(Value::from_set(left.union(&right).cloned().collect()))
+    Ok(left.union(&right).into_value())
 }
 
 fn binary_set_intersection(
@@ -62,9 +61,7 @@ fn binary_set_intersection(
     ensure_args_count(span, name, params, args, 2)?;
     let left = ensure_set(name, &params[0], args[0].clone())?;
     let right = ensure_set(name, &params[1], args[1].clone())?;
-    Ok(Value::from_set(
-        left.intersection(&right).cloned().collect(),
-    ))
+    Ok(left.intersection(&right).into_value())
 }
 
 fn intersection_of_set_of_sets(
@@ -77,8 +74,7 @@ fn intersection_of_set_of_sets(
     ensure_args_count(span, name, params, args, 1)?;
     let set = ensure_set(name, &params[0], args[0].clone())?;
 
-    let mut res = BTreeSet::new();
-    let mut first = true;
+    let mut res: Option<Set> = None;
 
     for s in set.iter() {
         let s = match s {
@@ -88,15 +84,13 @@ fn intersection_of_set_of_sets(
             ),
         };
 
-        if first {
-            res.clone_from(s);
-            first = false;
-        } else {
-            res = res.intersection(s).cloned().collect();
-        }
+        res = Some(match res {
+            None => (**s).clone(),
+            Some(prev) => prev.intersection(s),
+        });
     }
 
-    Ok(Value::from_set(res))
+    Ok(res.unwrap_or_default().into_value())
 }
 
 fn union_of_set_of_sets(
@@ -109,7 +103,7 @@ fn union_of_set_of_sets(
     ensure_args_count(span, name, params, args, 1)?;
     let set = ensure_set(name, &params[0], args[0].clone())?;
 
-    let mut res = BTreeSet::new();
+    let mut res = Set::new();
 
     for s in set.iter() {
         let s = match s {
@@ -119,8 +113,8 @@ fn union_of_set_of_sets(
             ),
         };
 
-        res = res.union(s).cloned().collect();
+        res = res.union(s);
     }
 
-    Ok(Value::from_set(res))
+    Ok(res.into_value())
 }

src/builtins/utils.rs

@@ -9,8 +9,6 @@ use crate::Rc;
 use crate::Value;
 use crate::*;
 
-use alloc::collections::{BTreeMap, BTreeSet};
-
 use anyhow::{bail, Result};
 
 #[inline]
@@ -158,7 +156,7 @@ pub fn ensure_array(fcn: &str, arg: &Expr, v: Value) -> Result<Rc<Vec<Value>>> {
     })
 }
 
-pub fn ensure_set(fcn: &str, arg: &Expr, v: Value) -> Result<Rc<BTreeSet<Value>>> {
+pub fn ensure_set(fcn: &str, arg: &Expr, v: Value) -> Result<Rc<Set>> {
     Ok(match v {
         Value::Set(s) => s,
         _ => {
@@ -168,7 +166,7 @@ pub fn ensure_set(fcn: &str, arg: &Expr, v: Value) -> Result<Rc<BTreeSet<Value>>
     })
 }
 
-pub fn ensure_object(fcn: &str, arg: &Expr, v: Value) -> Result<Rc<BTreeMap<Value, Value>>> {
+pub fn ensure_object(fcn: &str, arg: &Expr, v: Value) -> Result<Rc<Object>> {
     Ok(match v {
         Value::Object(o) => o,
         _ => {