pub trait ReconstructingReducer {
Show 45 methods
fn in_circuit(&self) -> bool;
fn swap_in_circuit(&mut self);
fn reduce_type(
&mut self,
_type_: &Type,
new: Type,
_span: &Span
) -> Result<Type, ReducerError> { ... }
fn reduce_expression(
&mut self,
_expression: &Expression,
new: Expression
) -> Result<Expression, ReducerError> { ... }
fn reduce_identifier(
&mut self,
identifier: &Identifier
) -> Result<Identifier, ReducerError> { ... }
fn reduce_group_tuple(
&mut self,
group_tuple: &GroupTuple
) -> Result<GroupTuple, ReducerError> { ... }
fn reduce_group_value(
&mut self,
_group_value: &GroupValue,
new: GroupValue
) -> Result<GroupValue, ReducerError> { ... }
fn reduce_string(
&mut self,
string: &[Char],
span: &Span
) -> Result<Expression, ReducerError> { ... }
fn reduce_value(
&mut self,
_value: &ValueExpression,
new: Expression
) -> Result<Expression, ReducerError> { ... }
fn reduce_binary(
&mut self,
binary: &BinaryExpression,
left: Expression,
right: Expression,
op: BinaryOperation
) -> Result<BinaryExpression, ReducerError> { ... }
fn reduce_unary(
&mut self,
unary: &UnaryExpression,
inner: Expression,
op: UnaryOperation
) -> Result<UnaryExpression, ReducerError> { ... }
fn reduce_ternary(
&mut self,
ternary: &TernaryExpression,
condition: Expression,
if_true: Expression,
if_false: Expression
) -> Result<TernaryExpression, ReducerError> { ... }
fn reduce_cast(
&mut self,
cast: &CastExpression,
inner: Expression,
target_type: Type
) -> Result<CastExpression, ReducerError> { ... }
fn reduce_array_inline(
&mut self,
array_inline: &ArrayInlineExpression,
elements: Vec<SpreadOrExpression>
) -> Result<ArrayInlineExpression, ReducerError> { ... }
fn reduce_array_init(
&mut self,
array_init: &ArrayInitExpression,
element: Expression
) -> Result<ArrayInitExpression, ReducerError> { ... }
fn reduce_array_access(
&mut self,
array_access: &ArrayAccessExpression,
array: Expression,
index: Expression
) -> Result<ArrayAccessExpression, ReducerError> { ... }
fn reduce_array_range_access(
&mut self,
array_rage_access: &ArrayRangeAccessExpression,
array: Expression,
left: Option<Expression>,
right: Option<Expression>
) -> Result<ArrayRangeAccessExpression, ReducerError> { ... }
fn reduce_tuple_init(
&mut self,
tuple_init: &TupleInitExpression,
elements: Vec<Expression>
) -> Result<TupleInitExpression, ReducerError> { ... }
fn reduce_tuple_access(
&mut self,
tuple_access: &TupleAccessExpression,
tuple: Expression
) -> Result<TupleAccessExpression, ReducerError> { ... }
fn reduce_circuit_implied_variable_definition(
&mut self,
_variable: &CircuitImpliedVariableDefinition,
identifier: Identifier,
expression: Option<Expression>
) -> Result<CircuitImpliedVariableDefinition, ReducerError> { ... }
fn reduce_circuit_init(
&mut self,
circuit_init: &CircuitInitExpression,
name: Identifier,
members: Vec<CircuitImpliedVariableDefinition>
) -> Result<CircuitInitExpression, ReducerError> { ... }
fn reduce_circuit_member_access(
&mut self,
circuit_member_access: &CircuitMemberAccessExpression,
circuit: Expression,
name: Identifier
) -> Result<CircuitMemberAccessExpression, ReducerError> { ... }
fn reduce_circuit_static_fn_access(
&mut self,
circuit_static_fn_access: &CircuitStaticFunctionAccessExpression,
circuit: Expression,
name: Identifier
) -> Result<CircuitStaticFunctionAccessExpression, ReducerError> { ... }
fn reduce_call(
&mut self,
call: &CallExpression,
function: Expression,
arguments: Vec<Expression>
) -> Result<CallExpression, ReducerError> { ... }
fn reduce_statement(
&mut self,
_statement: &Statement,
new: Statement
) -> Result<Statement, ReducerError> { ... }
fn reduce_return(
&mut self,
return_statement: &ReturnStatement,
expression: Expression
) -> Result<ReturnStatement, ReducerError> { ... }
fn reduce_variable_name(
&mut self,
variable_name: &VariableName,
identifier: Identifier
) -> Result<VariableName, ReducerError> { ... }
fn reduce_definition(
&mut self,
definition: &DefinitionStatement,
variable_names: Vec<VariableName>,
type_: Option<Type>,
value: Expression
) -> Result<DefinitionStatement, ReducerError> { ... }
fn reduce_assignee_access(
&mut self,
_access: &AssigneeAccess,
new: AssigneeAccess
) -> Result<AssigneeAccess, ReducerError> { ... }
fn reduce_assignee(
&mut self,
assignee: &Assignee,
identifier: Identifier,
accesses: Vec<AssigneeAccess>
) -> Result<Assignee, ReducerError> { ... }
fn reduce_assign(
&mut self,
assign: &AssignStatement,
assignee: Assignee,
value: Expression
) -> Result<AssignStatement, ReducerError> { ... }
fn reduce_conditional(
&mut self,
conditional: &ConditionalStatement,
condition: Expression,
block: Block,
statement: Option<Statement>
) -> Result<ConditionalStatement, ReducerError> { ... }
fn reduce_iteration(
&mut self,
iteration: &IterationStatement,
variable: Identifier,
start: Expression,
stop: Expression,
block: Block
) -> Result<IterationStatement, ReducerError> { ... }
fn reduce_console(
&mut self,
console: &ConsoleStatement,
function: ConsoleFunction
) -> Result<ConsoleStatement, ReducerError> { ... }
fn reduce_expression_statement(
&mut self,
expression_statement: &ExpressionStatement,
expression: Expression
) -> Result<ExpressionStatement, ReducerError> { ... }
fn reduce_block(
&mut self,
block: &Block,
statements: Vec<Statement>
) -> Result<Block, ReducerError> { ... }
fn reduce_program(
&mut self,
program: &Program,
expected_input: Vec<FunctionInput>,
imports: Vec<ImportStatement>,
circuits: IndexMap<Identifier, Circuit>,
functions: IndexMap<Identifier, Function>,
global_consts: IndexMap<String, DefinitionStatement>
) -> Result<Program, ReducerError> { ... }
fn reduce_function_input_variable(
&mut self,
variable: &FunctionInputVariable,
identifier: Identifier,
type_: Type
) -> Result<FunctionInputVariable, ReducerError> { ... }
fn reduce_function_input(
&mut self,
_input: &FunctionInput,
new: FunctionInput
) -> Result<FunctionInput, ReducerError> { ... }
fn reduce_package_or_packages(
&mut self,
_package_or_packages: &PackageOrPackages,
new: PackageOrPackages
) -> Result<PackageOrPackages, ReducerError> { ... }
fn reduce_import(
&mut self,
import: &ImportStatement,
package_or_packages: PackageOrPackages
) -> Result<ImportStatement, ReducerError> { ... }
fn reduce_circuit_member(
&mut self,
_circuit_member: &CircuitMember,
new: CircuitMember
) -> Result<CircuitMember, ReducerError> { ... }
fn reduce_circuit(
&mut self,
_circuit: &Circuit,
circuit_name: Identifier,
members: Vec<CircuitMember>
) -> Result<Circuit, ReducerError> { ... }
fn reduce_annotation(
&mut self,
annotation: &Annotation,
name: Identifier
) -> Result<Annotation, ReducerError> { ... }
fn reduce_function(
&mut self,
function: &Function,
identifier: Identifier,
annotations: Vec<Annotation>,
input: Vec<FunctionInput>,
output: Option<Type>,
block: Block
) -> Result<Function, ReducerError> { ... }