newton-regorus 0.2.0

A fast, lightweight Rego (OPA policy language) interpreter with Newton extensions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

#![allow(clippy::pattern_type_mismatch)]

//! Planner support for `some .. in` expressions.

use alloc::{collections::BTreeSet, string::String};

use crate::{
    ast::{Expr, ExprRef},
    compiler::destructuring_planner::{
        destructuring::create_destructuring_plan_with_tracking,
        utils::{check_literal_structure, validate_pattern_bindings, LiteralStructureCheck},
        BindingPlan, BindingPlannerError, Result, ScopingMode, VariableBindingContext,
    },
};

/// Convenience function for some..in expressions (always allow shadowing for new bindings).
pub fn create_some_in_binding_plan<T: VariableBindingContext>(
    key_expr: &Option<ExprRef>,
    value_expr: &ExprRef,
    collection_expr: &ExprRef,
    context: &T,
) -> Result<BindingPlan> {
    let key_plan = if let Some(key) = key_expr {
        let mut newly_bound = BTreeSet::new();
        let plan = create_destructuring_plan_with_tracking(
            key,
            context,
            ScopingMode::RespectParent,
            &mut newly_bound,
        );
        if let Some(plan) = plan {
            validate_pattern_bindings(key, &newly_bound, context)?;
            Some(plan)
        } else {
            None
        }
    } else {
        None
    };

    let mut newly_bound_value = BTreeSet::new();
    let value_plan = create_destructuring_plan_with_tracking(
        value_expr,
        context,
        ScopingMode::RespectParent,
        &mut newly_bound_value,
    )
    .ok_or_else(|| BindingPlannerError::FailedToCreateDestructuringPlan {
        plan_type: String::from("some-in value"),
        span: value_expr.span().clone(),
    })?;

    validate_pattern_bindings(value_expr, &newly_bound_value, context)?;

    if let Expr::Array { items, .. } = collection_expr.as_ref() {
        let mut found_match = false;
        let mut mismatch_error: Option<BindingPlannerError> = None;
        let mut saw_unknown = false;

        for collection_item in items {
            match check_literal_structure(&value_plan, collection_item) {
                LiteralStructureCheck::Match => {
                    found_match = true;
                }
                LiteralStructureCheck::Unknown => {
                    saw_unknown = true;
                }
                mismatch => {
                    if let Some(err) = mismatch.into_error() {
                        if mismatch_error.is_none() {
                            mismatch_error = Some(err);
                        }
                    }
                }
            }
        }

        if !found_match && !saw_unknown {
            if let Some(err) = mismatch_error {
                return Err(err);
            }
        }
    }

    Ok(BindingPlan::SomeIn {
        collection_expr: collection_expr.clone(),
        key_plan,
        value_plan,
    })
}