#![forbid(unsafe_code)]

#![warn(

    clippy::cargo,

    missing_docs,

    clippy::pedantic,

    future_incompatible,

    rust_2018_idioms

)]

#![allow(

    clippy::option_if_let_else,

    clippy::module_name_repetitions,

    clippy::missing_errors_doc

)]

use std::{

    any::{type_name, Any},

    borrow::Cow,

    cmp::Ordering,

    collections::{HashMap as StdHashMap, VecDeque},

    fmt::{Debug, Display, Write},

    hash::{Hash, Hasher},

    marker::PhantomData,

    ops::{Add, Bound, Deref, Div, Index, IndexMut, Mul, RangeBounds, Sub},

    str::FromStr,

    sync::Arc,

    vec,

};

/// A `HashMap` implementation that provides a defined iteration order.

pub mod budmap;

mod dynamic;

pub mod ir;

pub mod lexer_util;

mod list;

mod map;

mod string;

mod symbol;

use crate::ir::{Scope, ScopeSymbolKind};

pub use self::{

    dynamic::{Dynamic, DynamicValue},

    list::List,

    map::HashMap,

    string::StringLiteralDisplay,

    symbol::Symbol,

};

/// A virtual machine instruction.

///

/// This enum contains all instructions that the virtual machine is able to

/// perform.

pub enum Instruction<Intrinsic> {

    /// Adds `left` and `right` and places the result in `destination`.

    ///

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

    /// the destination instead.

    Add {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Subtracts `right` from `left` and places the result in `destination`.

    ///

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

    /// the destination instead.

    Sub {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Multiply `left` by `right` and places the result in `destination`.

    ///

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

    /// the destination instead.

    Multiply {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Divides `left` by `right` and places the result in `destination`.

    ///

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

    /// the destination instead.

    Divide {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a logical and of `left` and `right` and places the result in

    /// `destination`. This operation always results in a [`Value::Boolean`].

    ///

    /// `left` and `right` will be checked for thruthyness. If both are truthy,

    /// this operation will store true in `destination`. Otherwise, false will

    /// be stored.

    ///

    /// # Short Circuiting

    ///

    /// This instruction will not evaluate `right`'s truthiness if `left` is

    /// false.

    LogicalAnd {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a logical or of `left` and `right` and places the result in

    /// `destination`. This operation always results in a [`Value::Boolean`].

    ///

    /// `left` and `right` will be checked for thruthyness. If either are

    /// truthy, this operation will store true in `destination`. Otherwise,

    /// false will be stored.

    ///

    /// # Short Circuiting

    ///

    /// This instruction will not evaluate `right`'s truthiness if `left` is

    /// true.

    LogicalOr {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a logical exclusive-or of `left` and `right` and places the result in

    /// `destination`. This operation always results in a [`Value::Boolean`].

    ///

    /// `left` and `right` will be checked for thruthyness. If one is truthy and

    /// the other is not, this operation will store true in `destination`.

    /// Otherwise, false will be stored.

    LogicalXor {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a bitwise and of `left` and `right` and places the result in

    /// `destination`. This operation always results in a [`Value::Integer`].

    ///

    /// If either `left` or `right ` are not [`Value::Integer`], a fault will be

    /// returned.

    ///

    /// The result will have each bit set based on whether the corresponding bit

    /// in both `left` and `right` are both 1.

    BitwiseAnd {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a bitwise or of `left` and `right` and places the result in

    /// `destination`. This operation always results in a [`Value::Integer`].

    ///

    /// If either `left` or `right ` are not [`Value::Integer`], a fault will be

    /// returned.

    ///

    /// The result will have each bit set based on whether either corresponding bit

    /// in `left` or `right` are 1.

    BitwiseOr {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a bitwise exclusive-or of `left` and `right` and places the

    /// result in `destination`. This operation always results in a

    /// [`Value::Integer`].

    ///

    /// If either `left` or `right ` are not [`Value::Integer`], a fault will be

    /// returned.

    ///

    /// The result will have each bit set based on whether only one

    /// corresponding bit in either `left` or `right` are 1.

    BitwiseXor {

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a bitwise shift left of `left` by `right` bits, storing

    /// the result in `destination`.

    ///

    /// This operation requires both operands to be integers. If either are not

    /// integers, a fault will be returned.

    ShiftLeft {

        /// The value to shift

        left: ValueOrSource,

        /// The number of bits to shift by

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a bitwise shift right of `left` by `right` bits, storing the

    /// result in `destination`.

    ///

    /// This operation requires both operands to be integers. If either are not

    /// integers, a fault will be returned.

    ShiftRight {

        /// The value to shift

        left: ValueOrSource,

        /// The number of bits to shift by

        right: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a logical `not` operation for `value`, storing the result in

    /// `destination`.

    ///

    /// If the value is truthy, false will be stored in the destination. If the

    /// value is falsey, true will be stored in the destination.

    LogicalNot {

        /// The left hand side of the operation.

        value: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Performs a bitwise not operation for `value`, storing the result in

    /// `destination`. This operation always results in a [`Value::Integer`].

    ///

    /// If `value` cannot be coerced to an integer, a fault will be returned.

    ///

    /// The result will be `value` with each bit flipped.

    BitwiseNot {

        /// The left hand side of the operation.

        value: ValueOrSource,

        /// The destination for the result to be stored in.

        destination: Destination,

    },

    /// Converts a value to another type, storing the result in `destination`.

    ///

    /// If `value` cannot be converted, a fault will be returned.

    Convert {

        /// The left hand side of the operation.

        value: ValueOrSource,

        /// The type to convert to.

        kind: ValueKind,

        /// The destination for the converted value to be stored in.

        destination: Destination,

    },

    /// Checks [`condition.is_truthy()`](Value::is_truthy), jumping to the

    /// target instruction if false.

    ///

    /// If truthy, the virtual machine continues executing the next instruction

    /// in sequence.

    ///

    /// If not truthy, the virtual machine jumps to number `false_jump_to`. This

    /// number is the absolute number from the start of the set of instructions

    /// being executed.

    ///

    /// Jumping beyond the end of the function will not cause an error, but will

    /// instead cause the current function to return.

    If {

        /// The source of the condition.

        condition: ValueOrSource,

        /// The 0-based index of the instruction to jump to. This index is

        /// relative to the begining of the set of instructions being executed.

        false_jump_to: usize,

    },

    /// Jumps to the instruction number within the current function.

    ///

    /// This number is the absolute number from the start of the function being

    /// executed.

    ///

    /// Jumping beyond the end of the function will not cause an error, but will

    /// instead cause the current function to return.

    JumpTo(usize),

    /// Compares `left` and `right` using `comparison` to evaluate a boolean

    /// result.

    ///

    /// If [`CompareAction::Store`] is used, the boolean result will

    /// be stored in the provided destination.

    ///

    /// If [`CompareAction::JumpIfFalse`] is used and the result is false,

    /// execution will jump to the 0-based instruction index within the current

    /// set of executing instructions. If the result is true, the next

    /// instruction will continue executing.

    Compare {

        /// The comparison to perform.

        comparison: Comparison,

        /// The left hand side of the operation.

        left: ValueOrSource,

        /// The right hand side of the operation.

        right: ValueOrSource,

        /// The action to take with the result of the comparison.

        action: CompareAction,

    },

    /// Pushes a value to the stack.

    Push(ValueOrSource),

    /// Returns from the current stack frame.

    Return(Option<ValueOrSource>),

    /// Loads a `value` into a variable.

    Load {

        /// The index of the variable to store the value in.

        variable_index: usize,

        /// The value or source of the value to store.

        value: ValueOrSource,

    },

    /// Calls a function.

    ///

    /// When calling a function, values on the stack are "passed" to the

    /// function being pushed to the stack before calling the function. To

    /// ensure the correct number of arguments are taken even when variable

    /// argument lists are supported, the number of arguments is passed and

    /// controls the baseline of the stack.

    ///  

    /// Upon returning from a function call, the arguments will no longer be on

    /// the stack. The value returned from the function (or [`Value::Void`] if

    /// no value was returned) will be placed in `destination`.

    Call {

        /// The vtable index within the current module of the function to call.

        /// If None, the current function is called recursively.

        ///

        /// If a vtable index is provided but is beyond the number of functions

        /// registered to the current module, [`FaultKind::InvalidVtableIndex`]

        /// will be returned.

        vtable_index: Option<usize>,

        /// The number of arguments on the stack that should be used as

        /// arguments to this call.

        arg_count: usize,

        /// The destination for the result of the call.

        destination: Destination,

    },

    /// Calls an intrinsic runtime function.

    ///

    /// When calling a function, values on the stack are "passed" to the

    /// function being pushed to the stack before calling the function. To

    /// ensure the correct number of arguments are taken even when variable

    /// argument lists are supported, the number of arguments is passed and

    /// controls the baseline of the stack.

    ///  

    /// Upon returning from a function call, the arguments will no longer be on

    /// the stack. The value returned from the function (or [`Value::Void`] if

    /// no value was returned) will be placed in `destination`.

    CallIntrinsic {

        /// The runtime intrinsic to call.

        intrinsic: Intrinsic,

        /// The number of arguments on the stack that should be used as

        /// arguments to this call.

        arg_count: usize,

        /// The destination for the result of the call.

        destination: Destination,

    },

    /// Calls a function by name on a value.

    ///

    /// When calling a function, values on the stack are "passed" to the

    /// function being pushed to the stack before calling the function. To

    /// ensure the correct number of arguments are taken even when variable

    /// argument lists are supported, the number of arguments is passed and

    /// controls the baseline of the stack.

    ///  

    /// Upon returning from a function call, the arguments will no longer be on

    /// the stack. The value returned from the function (or [`Value::Void`] if

    /// no value was returned) will be placed in `destination`.

    CallInstance {

        /// The target of the function call. If [`ValueOrSource::Stack`], the value on the

        /// stack prior to the arguments is the target of the call.

        target: ValueOrSource,

        /// The name of the function to call.

        name: Symbol,

        /// The number of arguments on the stack that should be used as

        /// arguments to this call.

        arg_count: usize,

        /// The destination for the result of the call.

        destination: Destination,

    },

}

impl<Intrinsic> Display for Instruction<Intrinsic>

where

    Intrinsic: Display,

{

    #[allow(clippy::too_many_lines)]

            Instruction::Add {

            Instruction::Sub {

            Instruction::Multiply {

            Instruction::Divide {

            Instruction::LogicalAnd {

            Instruction::LogicalOr {

            Instruction::LogicalXor {

            Instruction::BitwiseAnd {

            Instruction::BitwiseOr {

            Instruction::BitwiseXor {

            Instruction::ShiftLeft {

            Instruction::ShiftRight {

            }

            }

            Instruction::Convert {

            }

            Instruction::If {

            Instruction::Compare {

            Instruction::Load {

                } else {

                }

            }

            Instruction::Call {

            } => {

                } else {

                }

            }

            Instruction::CallInstance {

            }

            Instruction::CallIntrinsic {

            }

        }

}

/// An action to take during an [`Instruction::Compare`].

pub enum CompareAction {

    /// Store the boolean result in the destination indicated.

    Store(Destination),

    /// If the comparison is false, jump to the 0-based instruction index

    /// indicated.

    JumpIfFalse(usize),

}

impl Display for CompareAction {

        }

}

/// A destination for a value.

pub enum Destination {

    /// Store the value in the 0-based variable index provided.

    Variable(usize),

    /// Push the value to the stack.

    Stack,

    /// Store the value in the return register.

    Return,

}

impl Display for Destination {

        }

}

/// The source of a value.

pub enum ValueSource {

    /// The value is in an argument at the provided 0-based index.

    Argument(usize),

    /// The value is in a variable at the provided 0-based index.

    Variable(usize),

}

impl Display for ValueSource {

        }

}

/// A value or a location of a value

pub enum ValueOrSource {

    /// A value.

    Value(Value),

    /// The value is in an argument at the provided 0-based index.

    Argument(usize),

    /// The value is in a variable at the provided 0-based index.

    Variable(usize),

    /// The value is popped from the stack

    ///

    /// The order of popping is the order the fields apear in the [`Instruction ]

    Stack,

}

impl Display for ValueOrSource {

        }

}

/// A method for comparing [`Value`]s.

pub enum Comparison {

    /// Pushes true if left and right are equal. Otherwise, pushes false.

    Equal,

    /// Pushes true if left and right are not equal. Otherwise, pushes false.

    NotEqual,

    /// Pushes true if left is less than right. Otherwise, pushes false.

    LessThan,

    /// Pushes true if left is less than or equal to right. Otherwise, pushes false.

    LessThanOrEqual,

    /// Pushes true if left is greater than right. Otherwise, pushes false.

    GreaterThan,

    /// Pushes true if left is greater than or equal to right. Otherwise, pushes false.

    GreaterThanOrEqual,

}

impl Display for Comparison {

        }

}

/// A virtual machine function.

pub struct Function<Intrinsic> {

    /// The name of the function.

    pub name: Symbol,

    /// The number of arguments this function expects.

    pub arg_count: usize,

    /// The number of variables this function requests space for.

    pub variable_count: usize,

    /// The instructions that make up the function body.

    pub code: Vec<Instruction<Intrinsic>>,

}

impl<Intrinsic> Function<Intrinsic> {

    /// Returns a new function for a given code block.

}

/// A virtual machine value.

pub enum Value {

    /// A value representing the lack of a value.

    Void,

    /// A signed 64-bit integer value.

    Integer(i64),

    /// A real number value (64-bit floating point).

    Real(f64),

    /// A boolean representing true or false.

    Boolean(bool),

    /// A type exposed from Rust.

    Dynamic(Dynamic),

}

impl Default for Value {

    #[inline]

}

impl Value {

    /// Returns a new value containing the Rust value provided.

    #[must_use]

    /// Returns a reference to the contained value, if it was one originally

    /// created with [`Value::dynamic()`]. If the value isn't a dynamic value or

    /// `T` is not the correct type, None will be returned.

    #[must_use]

    pub fn as_dynamic<T: DynamicValue>(&self) -> Option<&T> {

        } else {

        }

    /// Returns the contained value if `T` matches the contained type and this

    /// is the final reference to the value. If the value contains another type

    /// or additional references exist, `Err(self)` will be returned. Otherwise,

    /// the original value will be returned.

            // We can now destruct self safely without worrying about needing to

            // return an error.

            } else {

            }

        } else {

        }

    /// Returns the contained value, if it was one originally created with

    /// [`Value::dynamic()`] and `T` is the same type. If the value contains

    /// another type, `Err(self)` will be returned. Otherwise, the original

    /// value will be returned.

    ///

    /// Because dynamic values are cheaply cloned by wrapping the value in an

    /// [`std::sync::Arc`], this method will return a clone if there are any

    /// other instances that point to the same contained value. If this is the

    /// final instance of this value, the contained value will be returned

    /// without additional allocations.

            // We can now destruct self safely without worrying about needing to

            // return an error.

            } else {

            }

        } else {

        }

    /// If this value is a [`Value::Integer`], this function returns the

    /// contained value. Otherwise, `None` is returned.

    #[must_use]

        }

    /// If this value is a [`Value::Real`], this function returns the

    /// contained value. Otherwise, `None` is returned.

    #[must_use]

    pub fn as_f64(&self) -> Option<f64> {

        } else {

        }

    /// Converts this value to another kind, if possible.

    #[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)]

                    } else {

                    }

                }

            },

            },

        };

    /// Tries to convert this value into a String.

    ///

    /// This is a shorthand for calling `convert()` and then `into_dynamic()` on

    /// the resulting value.

    /// Returns true if the value is considered truthy.

    ///

    /// | value type | condition     |

    /// |------------|---------------|

    /// | Integer    | value != 0    |

    /// | Boolean    | value is true |

    /// | Void       | always false  |

    #[must_use]

        }

    /// Returns the inverse of [`is_truthy()`](Self::is_truthy)

    #[must_use]

    #[inline]

    /// Returns the kind of the contained value.

    #[must_use]

        }

    /// Returns true if value contained supports hashing.

    ///

    /// Using [`Hash`] on a value that does not support hashing will not panic,

    /// but unique hash values will not be generated.

    #[must_use]

    /// Attempts to compute a hash over this value. Returns true if the value

    /// contained supports hashing.

    ///

    /// The `state` may be mutated even if the contained value does not contain

    /// a hashable value.

            }

        }

}

impl From<i64> for Value {

}

impl From<f64> for Value {

}

impl From<()> for Value {

}

impl<'a> From<&'a str> for Value {

}

impl<T> From<T> for Value

where

    T: DynamicValue,

{

}

impl Hash for Value {

}

impl Eq for Value {}

impl PartialEq for Value {

    fn eq(&self, other: &Self) -> bool {

        }

}

impl Display for Value {

        }

}

#[inline]

        // Neither are NaNs

        (false, false) => {

                // Neither are infinite -- perform a fuzzy floating point eq

                // check using EPSILON as the step.

                // Both are infinite, equality is determined by the signs matching.

                // One is finite, one is infinite, they aren't equal

            }

        }

        // Both are NaN. They are only equal if the signs are equal.

        // One is NaN, the other isn't.

    }

impl PartialEq<bool> for Value {

    fn eq(&self, other: &bool) -> bool {

        } else {

        }

}

impl PartialEq<i64> for Value {

    fn eq(&self, other: &i64) -> bool {

        } else {

        }

}

impl PartialEq<f64> for Value {

    // floating point casts are intentional in this code.

    #[allow(clippy::cast_precision_loss)]

        }

}

impl PartialOrd for Value {

    #[inline]

                }

            },

                }

            },

                }

            },

            Value::Void => {

                } else {

                }

            }

        }

}

/// All primitive [`Value`] kinds.

pub enum ValueKind {

    /// A signed 64-bit integer value.

    Integer,

    /// A real number value (64-bit floating point).

    Real,

    /// A boolean representing true or false.

    Boolean,

    /// A dynamically exposed Rust type.

    Dynamic(Symbol),

    /// A value representing the lack of a value.

    Void,

}

impl ValueKind {

    /// Returns this kind as a string.

    #[must_use]

        }

}

impl From<&ValueKind> for ValueKind {

}

impl<'a> From<&'a str> for ValueKind {

        }

}

impl From<Symbol> for ValueKind {

        }

}

impl From<&Symbol> for ValueKind {

        }

}

impl Display for ValueKind {

}

struct Module<Intrinsic> {

    contents: StdHashMap<Symbol, ModuleItem>,

    vtable: Vec<VtableEntry<Intrinsic>>,

}

impl<Intrinsic> Default for Module<Intrinsic> {

}

impl<Intrinsic> Module<Intrinsic> {

    // #[must_use]

    // pub fn with_function(mut self, name: impl Into<Symbol>, function: Function) -> Self {

    //     self.define_function(name, function);

    //     self

    // }

}

enum VtableEntry<Intrinsic> {

    Function(Function<Intrinsic>),

    NativeFunction(Arc<dyn NativeFunction>),

}

impl<Intrinsic> Debug for VtableEntry<Intrinsic>

where

    Intrinsic: Debug,

{

        }

}

impl<Intrinsic> PartialEq for VtableEntry<Intrinsic>

where

    Intrinsic: PartialEq,

{

    fn eq(&self, other: &Self) -> bool {

        }

}

/// A native function for Bud.

pub trait NativeFunction {

    /// Invoke this function with `args`.

    fn invoke(&self, args: &mut PoppedValues<'_>) -> Result<Value, FaultKind>;

    #[doc(hidden)]

    fn as_ptr(&self) -> *const u8;

}

impl<T> NativeFunction for T

where

    T: for<'a, 'b> Fn(&'b mut PoppedValues<'a>) -> Result<Value, FaultKind>,

{

}

enum ModuleItem {

    Function(usize),

    // Module(Module),

}

/// A Bud virtual machine instance.

///

/// Each instance of this type has its own sandboxed environment. Its stack

/// space, function declarations, and [`Environment`] are unique from all other

/// instances of Bud with the exception that [`Symbol`]s are tracked globally.

///

/// # General Virtual Machine design

///

/// At the core of this type is a [`Stack`], which is a list of [`Value`]s. The

/// virtual machine divides the stack into "frames" (regions of [`Value`]s) as

/// it executes and calls functions.

///

/// Each stack frame is divided into two sections: arguments that were passed to

/// the function, and space for local variables. Stack frames are automatically

/// managed by the virtual machine.

///

/// The only time [`Value`]s need to be pushed to the stack directly is when

/// calling a function. Each argument being passed to the function is pushed to

/// the stack, and the virtual machine adopts the pushed values as part of the

/// called function's stack frame.

///

/// This example demonstrates a basic function that takes one argument and uses

/// 1 local variable. It performs the equivalent of creating a string like

/// `Hello, {name}!`.

///

/// ```rust

/// use std::borrow::Cow;

/// use budvm::{VirtualMachine, Function, Instruction, Value, ValueOrSource, Destination, Symbol};

///

/// let greet = Function {

///     name: Symbol::from("greet"),

///     arg_count: 1,

///     variable_count: 1,

///     code: vec![

///         Instruction::Add {

///             left: ValueOrSource::Value(Value::dynamic(String::from("Hello, "))),

///             right: ValueOrSource::Argument(0),

///             destination: Destination::Variable(0),

///         },

///         Instruction::Add {

///             left: ValueOrSource::Variable(0),

///             right: ValueOrSource::Value(Value::dynamic(String::from("!"))),

///             destination: Destination::Return,

///         },

///     ],

/// };

///

/// let mut vm = VirtualMachine::empty().with_function(greet);