mirror of
https://github.com/microsoft/regorus.git
synced 2026-08-05 02:16:11 +00:00
a3a20a1235
# RVM compiler test cases Coverage: - arithmetic - arrays - chained lookups - comparisons - comprehensions - default rules - destructuring - function rules - loops/quantifiers - multiple entrypoints - objects/sets - variables - negative/edge scenarios such as data/rule conflicts - virtual data lookups - etc # Modify interpreter and compiled policy for RVM Compilation - Interpreter::eval_default_rule_for_compiler: evaluates a named default rule in isolation - allows compiler to emit a constant value instead of instructions for the default value # feat: Rego Compiler Scaffolding - Introduce the rego::compiler module surface and entry point wiring - Add the core compiler concepts: - register allocator - scope tracking - literal/builtin tables - rule worklists - instruction emit helpers - compiler-specific error types - context structs for rules, comprehensions, and loops to support later lowering passes. # feat: Compile Rules/Queries - add compiler::compile_from_policy workflow plus rule worklist, entry-point wiring, and recursion checks - implement query lowering: - scheduling-aware statement ordering - loop hoisting - “every/some” semantics - context yields - literal assertions - finalize Program construction # feat: Expression Lowering - add compile_rego_expr and helpers to translate every AST expression into RVM instructions, - interop with binding plans, comprehensions, and membership checks. - implement collection literal builders (ArrayCreate, SetCreate, ObjectCreate) - dedupe literal keys and handle mixed literal/dynamic fields via instruction data blocks. - operations: - arithmetic/boolean/bin operators - membership - unary minus - set unions/intersections - etc - user-defined and builtin function calls - reference handling - analyse chained refs - distinguishe data/input/local roots - perform rule dispatch or virtual document lookups - emits optimized Index/ChainedIndex instructions. # feat: Comprehensions & Loops - shared comprehension emitter - wraps array/set/object comprehensions with ComprehensionBegin/End - context management - loop lowering utilities - read hoisting metadata - emit LoopStart/LoopNext - some in lowering - every quantifiers - index iteration - propagate binding plans into stored registers so downstream statements see bound variables. # feat: Destructuring Lowering - destructuring planner integration - assignment/parameter/loop bindings use hoisted plans instead of re-walking ASTs. - handle :=, =, wildcard matches, and equality - evaluate RHS - applying destructuring plans - emit assert condition as needed - support nested array/object destructuring, dynamic keys, and some ... in forms # test: Shared Testing + RVM Suites - move YAML test helpers into test_utils.rs and re-export via common.rs for use by interpreter and vm test suites - comprehensive compiler test suite - compiles policies with the new Rego→RVM compiler - runs them through RegoVM - compares against interpreter behavior - supports multiple entry points - provides assembly listings - filterable YAML suites. Signed-off-by: Anand Krishnamoorthi <anakrish@microsoft.com>
72 lines
2.0 KiB
Rust
72 lines
2.0 KiB
Rust
// Copyright (c) Microsoft Corporation.
|
|
// Licensed under the MIT License.
|
|
|
|
use alloc::format;
|
|
use alloc::string::String;
|
|
|
|
#[derive(thiserror::Error, Debug)]
|
|
pub enum CompilerError {
|
|
#[error("Not a builtin function: {name}")]
|
|
NotBuiltinFunction { name: String },
|
|
|
|
#[error("Unknown builtin function: {name}")]
|
|
UnknownBuiltinFunction { name: String },
|
|
|
|
#[error("internal: missing context for yield")]
|
|
MissingYieldContext,
|
|
|
|
#[error(
|
|
"Direct access to 'data' root is not allowed. Use a specific path like 'data.package.rule'"
|
|
)]
|
|
DirectDataAccess,
|
|
|
|
#[error("Not a simple reference chain")]
|
|
NotSimpleReferenceChain,
|
|
|
|
#[error("Missing binding plan for {context}")]
|
|
MissingBindingPlan { context: String },
|
|
|
|
#[error("Unexpected binding plan variant for {context}: {found}")]
|
|
UnexpectedBindingPlan { context: String, found: String },
|
|
|
|
#[error("Invalid destructuring pattern in assignment")]
|
|
InvalidDestructuringPattern,
|
|
|
|
#[error("Unsupported expression type in chained reference")]
|
|
UnsupportedChainedExpression,
|
|
|
|
#[error("internal: no rule type found for '{rule_path}'")]
|
|
RuleTypeNotFound { rule_path: String },
|
|
|
|
#[error("unary - can only be used with numeric literals")]
|
|
InvalidUnaryMinus,
|
|
|
|
#[error("Unknown function: '{name}'")]
|
|
UnknownFunction { name: String },
|
|
|
|
#[error("Undefined variable: '{name}'")]
|
|
UndefinedVariable { name: String },
|
|
|
|
#[error("SomeIn should have been hoisted as a loop")]
|
|
SomeInNotHoisted,
|
|
|
|
#[error("Invalid function expression")]
|
|
InvalidFunctionExpression,
|
|
|
|
#[error("Invalid function expression with package")]
|
|
InvalidFunctionExpressionWithPackage,
|
|
|
|
#[error("Compilation error: {message}")]
|
|
General { message: String },
|
|
}
|
|
|
|
impl From<anyhow::Error> for CompilerError {
|
|
fn from(err: anyhow::Error) -> Self {
|
|
CompilerError::General {
|
|
message: format!("{}", err),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type Result<T> = ::core::result::Result<T, CompilerError>;
|