From e1763fcb9da08b5115514ac9dd9c354d2ee63741 Mon Sep 17 00:00:00 2001
From: Eric van der Toorn <e.a.vandertoorn@student.tudelft.nl>
Date: Fri, 26 Mar 2021 21:58:34 +0100
Subject: [PATCH 1/8] 'float'

---
 common/src/float_ops.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/common/src/float_ops.rs b/common/src/float_ops.rs
index 731258d9b..5f006180d 100644
--- a/common/src/float_ops.rs
+++ b/common/src/float_ops.rs
@@ -1,6 +1,7 @@
 use num_bigint::{BigInt, ToBigInt};
 use num_traits::{Float, Signed, ToPrimitive, Zero};
 
+///
 pub fn ufrexp(value: f64) -> (f64, i32) {
     if 0.0 == value {
         (0.0, 0i32)
@@ -12,6 +13,22 @@ pub fn ufrexp(value: f64) -> (f64, i32) {
     }
 }
 
+/// Equate an integer to a float.
+///
+/// Returns true if and only if, when converted to each others types, both are equal.
+///
+/// # Examples
+///
+/// ```
+/// use num_bigint::BigInt;
+/// use rustpython_common::float_ops::eq_int;
+/// let a = 1.0f64;
+/// let b = BigInt::from(1);
+/// let c = 2.0f64;
+/// assert!(eq_int(a, &b));
+/// assert!(!eq_int(c, &b));
+/// ```
+///
 pub fn eq_int(value: f64, other: &BigInt) -> bool {
     if let (Some(self_int), Some(other_float)) = (value.to_bigint(), other.to_f64()) {
         value == other_float && self_int == *other

From 99740d1e8563ae52724466724a7b480d174c1994 Mon Sep 17 00:00:00 2001
From: Eric van der Toorn <e.a.vandertoorn@student.tudelft.nl>
Date: Sat, 27 Mar 2021 14:46:31 +0100
Subject: [PATCH 2/8] add documentation to most public parts of bytecode, along
 with examples

---
 bytecode/src/lib.rs | 140 ++++++++++++++++++++++++++++++++++++++------
 1 file changed, 121 insertions(+), 19 deletions(-)

diff --git a/bytecode/src/lib.rs b/bytecode/src/lib.rs
index 73e2e173d..afc17e93d 100644
--- a/bytecode/src/lib.rs
+++ b/bytecode/src/lib.rs
@@ -14,6 +14,7 @@ use std::collections::BTreeSet;
 use std::{fmt, hash};
 
 /// Sourcecode location.
+/// TODO start, end, middle?
 #[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct Location {
     row: usize,
@@ -21,28 +22,47 @@ pub struct Location {
 }
 
 impl Location {
+    /// Creates a new Location object at the given row and column.
+    ///
+    /// # Example
+    /// ```
+    /// use rustpython_bytecode::Location;
+    /// let loc = Location::new(10, 10);
+    /// ```
     pub fn new(row: usize, column: usize) -> Self {
         Location { row, column }
     }
 
+    /// Current row
     pub fn row(&self) -> usize {
         self.row
     }
 
+    /// Current column
     pub fn column(&self) -> usize {
         self.column
     }
 }
 
+/// A Constant object is
+/// TODO unclear
 pub trait Constant: Sized {
     type Name: AsRef<str>;
+
+    /// Tranforms the given Constant to a BorrowedConstant
     fn borrow_constant(&self) -> BorrowedConstant<Self>;
+    /// Get the data this Constant holds.
     fn into_data(self) -> ConstantData {
         self.borrow_constant().into_data()
     }
+    /// Map this Constant to a Bag's constant
+    ///
+    /// TODO Unclear.
     fn map_constant<Bag: ConstantBag>(self, bag: &Bag) -> Bag::Constant {
         bag.make_constant(self.into_data())
     }
+
+    /// Maps the name for the given Bag.
     fn map_name<Bag: ConstantBag>(
         name: Self::Name,
         bag: &Bag,
@@ -50,6 +70,7 @@ pub trait Constant: Sized {
         bag.make_name_ref(name.as_ref())
     }
 }
+
 impl Constant for ConstantData {
     type Name = String;
     fn borrow_constant(&self) -> BorrowedConstant<Self> {
@@ -77,6 +98,7 @@ impl Constant for ConstantData {
     }
 }
 
+/// A Constant Bag
 pub trait ConstantBag: Sized {
     type Constant: Constant;
     fn make_constant(&self, constant: ConstantData) -> Self::Constant;
@@ -91,6 +113,7 @@ pub trait ConstantBag: Sized {
 
 #[derive(Clone)]
 pub struct BasicBag;
+
 impl ConstantBag for BasicBag {
     type Constant = ConstantData;
     fn make_constant(&self, constant: ConstantData) -> Self::Constant {
@@ -108,18 +131,20 @@ pub struct CodeObject<C: Constant = ConstantData> {
     pub instructions: Box<[Instruction]>,
     pub locations: Box<[Location]>,
     pub flags: CodeFlags,
-    pub posonlyarg_count: usize, // Number of positional-only arguments
+    pub posonlyarg_count: usize,
+    // Number of positional-only arguments
     pub arg_count: usize,
     pub kwonlyarg_count: usize,
     pub source_path: C::Name,
     pub first_line_number: usize,
     pub max_stacksize: u32,
-    pub obj_name: C::Name, // Name of the object that created this code object
+    pub obj_name: C::Name,
+    // Name of the object that created this code object
     pub cell2arg: Option<Box<[isize]>>,
     pub constants: Box<[C]>,
     #[serde(bound(
-        deserialize = "C::Name: serde::Deserialize<'de>",
-        serialize = "C::Name: serde::Serialize"
+    deserialize = "C::Name: serde::Deserialize<'de>",
+    serialize = "C::Name: serde::Serialize"
     ))]
     pub names: Box<[C::Name]>,
     pub varnames: Box<[C::Name]>,
@@ -157,6 +182,7 @@ impl CodeFlags {
 // XXX: if you add a new instruction that stores a Label, make sure to add it in
 // Instruction::label_arg{,_mut}
 pub struct Label(pub u32);
+
 impl fmt::Display for Label {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.0.fmt(f)
@@ -176,6 +202,7 @@ pub enum ConversionFlag {
     Repr,
 }
 
+/// The kind of Raise that occurred.
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum RaiseKind {
     Reraise,
@@ -188,11 +215,15 @@ pub type NameIdx = u32;
 /// A Single bytecode instruction.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum Instruction {
+    /// Importing by name
     ImportName {
         idx: NameIdx,
     },
+    /// Importing without name
     ImportNameless,
+    /// Import *
     ImportStar,
+    /// from ... import ...
     ImportFrom {
         idx: NameIdx,
     },
@@ -400,6 +431,15 @@ bitflags! {
     }
 }
 
+/// A Constant (which usually encapsulates data within it)
+///
+/// # Examples
+/// ```
+/// use rustpython_bytecode::ConstantData;
+/// let a = ConstantData::Float {value: 120f64};
+/// let b = ConstantData::Boolean {value: false};
+/// assert_ne!(a, b);
+/// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ConstantData {
     Tuple { elements: Vec<ConstantData> },
@@ -436,6 +476,7 @@ impl PartialEq for ConstantData {
         }
     }
 }
+
 impl Eq for ConstantData {}
 
 impl hash::Hash for ConstantData {
@@ -460,6 +501,7 @@ impl hash::Hash for ConstantData {
     }
 }
 
+/// A borrowed Constant
 pub enum BorrowedConstant<'a, C: Constant> {
     Integer { value: &'a BigInt },
     Float { value: f64 },
@@ -472,7 +514,9 @@ pub enum BorrowedConstant<'a, C: Constant> {
     None,
     Ellipsis,
 }
-type BorrowedTupleIter<'a, C> = Box<dyn Iterator<Item = BorrowedConstant<'a, C>> + 'a>;
+
+type BorrowedTupleIter<'a, C> = Box<dyn Iterator<Item=BorrowedConstant<'a, C>> + 'a>;
+
 impl<C: Constant> BorrowedConstant<'_, C> {
     // takes `self` because we need to consume the iterator
     pub fn fmt_display(self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -530,6 +574,7 @@ impl<C: Constant> BorrowedConstant<'_, C> {
     }
 }
 
+/// The possible comparison operators
 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum ComparisonOperator {
     Greater,
@@ -542,9 +587,19 @@ pub enum ComparisonOperator {
     NotIn,
     Is,
     IsNot,
+    /// two exceptions that match?
+    /// TODO clarify
     ExceptionMatch,
 }
 
+/// The possible Binary operators
+/// # Examples
+///
+/// ```
+/// use rustpython_bytecode::Instruction::BinaryOperation;
+/// use rustpython_bytecode::BinaryOperator::Add;
+/// let op = BinaryOperation {op: Add};
+/// ```
 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum BinaryOperator {
     Power,
@@ -562,6 +617,7 @@ pub enum BinaryOperator {
     Or,
 }
 
+/// The possible unary operators
 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum UnaryOperator {
     Not,
@@ -578,6 +634,8 @@ pub enum BlockType {
 }
 */
 
+/// Argument structure
+/// TODO is this for parameters or arguments?
 pub struct Arguments<'a, N: AsRef<str>> {
     pub posonlyargs: &'a [N],
     pub args: &'a [N],
@@ -604,7 +662,12 @@ impl<N: AsRef<str>> fmt::Debug for Arguments<'_, N> {
 }
 
 impl<C: Constant> CodeObject<C> {
-    // like inspect.getargs
+    /// Get all arguments of the code object
+    /// like inspect.getargs
+    /// # Examples
+    ///
+    /// TODO I'm not sure what is the best way to construct a CodeObject
+    ///
     pub fn arg_names(&self) -> Arguments<C::Name> {
         let nargs = self.arg_count;
         let nkwargs = self.kwonlyarg_count;
@@ -635,6 +698,7 @@ impl<C: Constant> CodeObject<C> {
         }
     }
 
+    /// Return the labels targeted by the instructions of this CodeObject
     pub fn label_targets(&self) -> BTreeSet<Label> {
         let mut label_targets = BTreeSet::new();
         for instruction in &*self.instructions {
@@ -677,6 +741,7 @@ impl<C: Constant> CodeObject<C> {
         Ok(())
     }
 
+    /// Recursively display this CodeObject
     pub fn display_expand_codeobjects(&self) -> impl fmt::Display + '_ {
         struct Display<'a, C: Constant>(&'a CodeObject<C>);
         impl<C: Constant> fmt::Display for Display<'_, C> {
@@ -687,6 +752,8 @@ impl<C: Constant> CodeObject<C> {
         Display(self)
     }
 
+    /// Map this CodeObject to one that holds a Bag::Constant
+    /// TODO add example
     pub fn map_bag<Bag: ConstantBag>(self, bag: &Bag) -> CodeObject<Bag::Constant> {
         let map_names = |names: Box<[C::Name]>| {
             names
@@ -721,6 +788,8 @@ impl<C: Constant> CodeObject<C> {
         }
     }
 
+    /// Same as `map_bag` but clones `self`
+    /// TODO add example
     pub fn map_clone_bag<Bag: ConstantBag>(&self, bag: &Bag) -> CodeObject<Bag::Constant> {
         let map_names = |names: &[C::Name]| {
             names
@@ -754,12 +823,16 @@ impl<C: Constant> CodeObject<C> {
     }
 }
 
+/// Error that occurs during code deserialization
 #[derive(Debug)]
 #[non_exhaustive]
 pub enum CodeDeserializeError {
+    /// Unexpected End Of File
     Eof,
+    /// Invalid Bytecode
     Other,
 }
+
 impl fmt::Display for CodeDeserializeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -768,6 +841,7 @@ impl fmt::Display for CodeDeserializeError {
         }
     }
 }
+
 impl std::error::Error for CodeDeserializeError {}
 
 impl CodeObject<ConstantData> {
@@ -850,6 +924,16 @@ impl Instruction {
         }
     }
 
+    /// Whether this is an unconditional branching
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_bytecode::{Instruction, Label};
+    /// let label = Label(0xF);
+    /// let jump_inst = Instruction::Jump {target: label};
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
     pub fn unconditional_branch(&self) -> bool {
         matches!(
             self,
@@ -857,6 +941,20 @@ impl Instruction {
         )
     }
 
+    /// What effect this instruction has on the stack
+    ///
+    /// TODO what exactly do the numbers represent?
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_bytecode::{Instruction, Label, UnaryOperator};
+    /// let jump_instruction = Instruction::Jump {target: Label(0xF)};
+    /// let invert_instruction = Instruction::UnaryOperation {op: UnaryOperator::Invert};
+    /// assert_eq!(jump_instruction.stack_effect(true), 0);
+    /// assert_eq!(invert_instruction.stack_effect(false), 0);
+    /// ```
+    ///
     pub fn stack_effect(&self, jump: bool) -> i32 {
         match self {
             ImportName { .. } | ImportNameless => -1,
@@ -1130,11 +1228,13 @@ impl<C: Constant> fmt::Debug for CodeObject<C> {
     }
 }
 
+/// A frozen module. Holds a code object and whether it is part of a package
+/// TODO example
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FrozenModule<C: Constant = ConstantData> {
     #[serde(bound(
-        deserialize = "C: serde::Deserialize<'de>, C::Name: serde::Deserialize<'de>",
-        serialize = "C: serde::Serialize, C::Name: serde::Serialize"
+    deserialize = "C: serde::Deserialize<'de>, C::Name: serde::Deserialize<'de>",
+    serialize = "C: serde::Serialize, C::Name: serde::Serialize"
     ))]
     pub code: CodeObject<C>,
     pub package: bool,
@@ -1146,6 +1246,7 @@ pub mod frozen_lib {
     use std::convert::TryInto;
     use std::io;
 
+    /// Decode a library to a iterable of frozen modules
     pub fn decode_lib(bytes: &[u8]) -> FrozenModulesIter {
         let data = lz4_flex::decompress_size_prepended(bytes).unwrap();
         let r = VecReader { data, pos: 0 };
@@ -1183,10 +1284,11 @@ pub mod frozen_lib {
 
     impl ExactSizeIterator for FrozenModulesIter {}
 
+    /// Encode the given iterator of frozen modules into a compressed vector of bytes
     pub fn encode_lib<'a, I>(lib: I) -> Vec<u8>
-    where
-        I: IntoIterator<Item = (&'a str, &'a FrozenModule)>,
-        I::IntoIter: ExactSizeIterator + Clone,
+        where
+            I: IntoIterator<Item=(&'a str, &'a FrozenModule)>,
+            I::IntoIter: ExactSizeIterator + Clone,
     {
         let iter = lib.into_iter();
         let data = options().serialize(&SerializeLib { iter }).unwrap();
@@ -1198,12 +1300,12 @@ pub mod frozen_lib {
     }
 
     impl<'a, I> Serialize for SerializeLib<I>
-    where
-        I: ExactSizeIterator<Item = (&'a str, &'a FrozenModule)> + Clone,
+        where
+            I: ExactSizeIterator<Item=(&'a str, &'a FrozenModule)> + Clone,
     {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
+            where
+                S: serde::Serializer,
         {
             serializer.collect_seq(self.iter.clone())
         }
@@ -1244,8 +1346,8 @@ pub mod frozen_lib {
 
     impl<'storage> bincode::BincodeRead<'storage> for VecReader {
         fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> bincode::Result<V::Value>
-        where
-            V: serde::de::Visitor<'storage>,
+            where
+                V: serde::de::Visitor<'storage>,
         {
             let bytes = self.get_byte_slice(length)?;
             match ::std::str::from_utf8(bytes) {
@@ -1261,8 +1363,8 @@ pub mod frozen_lib {
         }
 
         fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> bincode::Result<V::Value>
-        where
-            V: serde::de::Visitor<'storage>,
+            where
+                V: serde::de::Visitor<'storage>,
         {
             visitor.visit_bytes(self.get_byte_slice(length)?)
         }

From 0bba55b3bfe3b48453816bce57bb0561643342d9 Mon Sep 17 00:00:00 2001
From: Eric van der Toorn <e.a.vandertoorn@student.tudelft.nl>
Date: Mon, 29 Mar 2021 15:18:59 +0200
Subject: [PATCH 3/8] format bytecode file

---
 bytecode/src/lib.rs | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/bytecode/src/lib.rs b/bytecode/src/lib.rs
index afc17e93d..29dc7c512 100644
--- a/bytecode/src/lib.rs
+++ b/bytecode/src/lib.rs
@@ -143,8 +143,8 @@ pub struct CodeObject<C: Constant = ConstantData> {
     pub cell2arg: Option<Box<[isize]>>,
     pub constants: Box<[C]>,
     #[serde(bound(
-    deserialize = "C::Name: serde::Deserialize<'de>",
-    serialize = "C::Name: serde::Serialize"
+        deserialize = "C::Name: serde::Deserialize<'de>",
+        serialize = "C::Name: serde::Serialize"
     ))]
     pub names: Box<[C::Name]>,
     pub varnames: Box<[C::Name]>,
@@ -515,7 +515,7 @@ pub enum BorrowedConstant<'a, C: Constant> {
     Ellipsis,
 }
 
-type BorrowedTupleIter<'a, C> = Box<dyn Iterator<Item=BorrowedConstant<'a, C>> + 'a>;
+type BorrowedTupleIter<'a, C> = Box<dyn Iterator<Item = BorrowedConstant<'a, C>> + 'a>;
 
 impl<C: Constant> BorrowedConstant<'_, C> {
     // takes `self` because we need to consume the iterator
@@ -1233,8 +1233,8 @@ impl<C: Constant> fmt::Debug for CodeObject<C> {
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FrozenModule<C: Constant = ConstantData> {
     #[serde(bound(
-    deserialize = "C: serde::Deserialize<'de>, C::Name: serde::Deserialize<'de>",
-    serialize = "C: serde::Serialize, C::Name: serde::Serialize"
+        deserialize = "C: serde::Deserialize<'de>, C::Name: serde::Deserialize<'de>",
+        serialize = "C: serde::Serialize, C::Name: serde::Serialize"
     ))]
     pub code: CodeObject<C>,
     pub package: bool,
@@ -1286,9 +1286,9 @@ pub mod frozen_lib {
 
     /// Encode the given iterator of frozen modules into a compressed vector of bytes
     pub fn encode_lib<'a, I>(lib: I) -> Vec<u8>
-        where
-            I: IntoIterator<Item=(&'a str, &'a FrozenModule)>,
-            I::IntoIter: ExactSizeIterator + Clone,
+    where
+        I: IntoIterator<Item = (&'a str, &'a FrozenModule)>,
+        I::IntoIter: ExactSizeIterator + Clone,
     {
         let iter = lib.into_iter();
         let data = options().serialize(&SerializeLib { iter }).unwrap();
@@ -1300,12 +1300,12 @@ pub mod frozen_lib {
     }
 
     impl<'a, I> Serialize for SerializeLib<I>
-        where
-            I: ExactSizeIterator<Item=(&'a str, &'a FrozenModule)> + Clone,
+    where
+        I: ExactSizeIterator<Item = (&'a str, &'a FrozenModule)> + Clone,
     {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
+        where
+            S: serde::Serializer,
         {
             serializer.collect_seq(self.iter.clone())
         }
@@ -1346,8 +1346,8 @@ pub mod frozen_lib {
 
     impl<'storage> bincode::BincodeRead<'storage> for VecReader {
         fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> bincode::Result<V::Value>
-            where
-                V: serde::de::Visitor<'storage>,
+        where
+            V: serde::de::Visitor<'storage>,
         {
             let bytes = self.get_byte_slice(length)?;
             match ::std::str::from_utf8(bytes) {
@@ -1363,8 +1363,8 @@ pub mod frozen_lib {
         }
 
         fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> bincode::Result<V::Value>
-            where
-                V: serde::de::Visitor<'storage>,
+        where
+            V: serde::de::Visitor<'storage>,
         {
             visitor.visit_bytes(self.get_byte_slice(length)?)
         }

From 029a3cb45df9f8d3749e7933b5afc008563d25de Mon Sep 17 00:00:00 2001
From: Eric van der Toorn <e.a.vandertoorn@student.tudelft.nl>
Date: Mon, 29 Mar 2021 15:20:50 +0200
Subject: [PATCH 4/8] add some comments in derive

---
 derive/src/compile_bytecode.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/derive/src/compile_bytecode.rs b/derive/src/compile_bytecode.rs
index bca2e7621..43d84c770 100644
--- a/derive/src/compile_bytecode.rs
+++ b/derive/src/compile_bytecode.rs
@@ -32,8 +32,11 @@ static CARGO_MANIFEST_DIR: Lazy<PathBuf> = Lazy::new(|| {
 });
 
 enum CompilationSourceKind {
+    /// Source is a File (Path)
     File(PathBuf),
+    /// Direct Raw sourcecode
     SourceCode(String),
+    /// Source is a directory
     Dir(PathBuf),
 }
 

From 91e4dd0ae42bacb0edf7d26695c4e4603f4ca7f0 Mon Sep 17 00:00:00 2001
From: Eric van der Toorn <e.a.vandertoorn@student.tudelft.nl>
Date: Tue, 6 Apr 2021 16:20:44 +0200
Subject: [PATCH 5/8] add initial example to interpreter

---
 vm/src/vm.rs | 220 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 123 insertions(+), 97 deletions(-)

diff --git a/vm/src/vm.rs b/vm/src/vm.rs
index ffafe0c8c..35b9704fe 100644
--- a/vm/src/vm.rs
+++ b/vm/src/vm.rs
@@ -42,6 +42,8 @@ use crate::{builtins, bytecode, frozen, import, iterator, stdlib, sysmodule};
 
 /// Top level container of a python virtual machine. In theory you could
 /// create more instances of this struct and have them operate fully isolated.
+///
+/// To construct this, please refer to the [`Interpreter`](Interpreter)
 pub struct VirtualMachine {
     pub builtins: PyObjectRef,
     pub sys_module: PyObjectRef,
@@ -87,8 +89,8 @@ pub(crate) mod thread {
     }
 
     pub fn with_vm<F, R>(obj: &PyObjectRef, f: F) -> Option<R>
-    where
-        F: Fn(&VirtualMachine) -> R,
+        where
+            F: Fn(&VirtualMachine) -> R,
     {
         let vm_owns_obj = |intp: NonNull<VirtualMachine>| {
             // SAFETY: all references in VM_STACK should be valid
@@ -315,36 +317,36 @@ impl VirtualMachine {
 
         let mut inner_init = || -> PyResult<()> {
             #[cfg(not(target_arch = "wasm32"))]
-            import::import_builtin(self, "_signal")?;
+                import::import_builtin(self, "_signal")?;
 
             #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
-            {
-                // this isn't fully compatible with CPython; it imports "io" and sets
-                // builtins.open to io.OpenWrapper, but this is easier, since it doesn't
-                // require the Python stdlib to be present
-                let io = import::import_builtin(self, "_io")?;
-                let set_stdio = |name, fd, mode: &str| {
-                    let stdio = crate::stdlib::io::open(
-                        self.ctx.new_int(fd),
-                        Some(mode),
-                        Default::default(),
-                        self,
-                    )?;
-                    self.set_attr(
-                        &self.sys_module,
-                        format!("__{}__", name), // e.g. __stdin__
-                        stdio.clone(),
-                    )?;
-                    self.set_attr(&self.sys_module, name, stdio)?;
-                    Ok(())
-                };
-                set_stdio("stdin", 0, "r")?;
-                set_stdio("stdout", 1, "w")?;
-                set_stdio("stderr", 2, "w")?;
+                {
+                    // this isn't fully compatible with CPython; it imports "io" and sets
+                    // builtins.open to io.OpenWrapper, but this is easier, since it doesn't
+                    // require the Python stdlib to be present
+                    let io = import::import_builtin(self, "_io")?;
+                    let set_stdio = |name, fd, mode: &str| {
+                        let stdio = crate::stdlib::io::open(
+                            self.ctx.new_int(fd),
+                            Some(mode),
+                            Default::default(),
+                            self,
+                        )?;
+                        self.set_attr(
+                            &self.sys_module,
+                            format!("__{}__", name), // e.g. __stdin__
+                            stdio.clone(),
+                        )?;
+                        self.set_attr(&self.sys_module, name, stdio)?;
+                        Ok(())
+                    };
+                    set_stdio("stdin", 0, "r")?;
+                    set_stdio("stdout", 1, "w")?;
+                    set_stdio("stderr", 2, "w")?;
 
-                let io_open = self.get_attribute(io, "open")?;
-                self.set_attr(&self.builtins, "open", io_open)?;
-            }
+                    let io_open = self.get_attribute(io, "open")?;
+                    self.set_attr(&self.builtins, "open", io_open)?;
+                }
 
             import::init_importlib(self, initialize_parameter)?;
 
@@ -367,8 +369,8 @@ impl VirtualMachine {
 
     /// Can only be used in the initialization closure passed to [`Interpreter::new_with_init`]
     pub fn add_frozen<I>(&mut self, frozen: I)
-    where
-        I: IntoIterator<Item = (String, bytecode::FrozenModule)>,
+        where
+            I: IntoIterator<Item=(String, bytecode::FrozenModule)>,
     {
         let frozen = frozen::map_frozen(self, frozen).collect::<Vec<_>>();
         let state = PyRc::get_mut(&mut self.state)
@@ -386,10 +388,10 @@ impl VirtualMachine {
     /// not in the context of any vm.
     #[cfg(feature = "threading")]
     pub fn start_thread<F, R>(&self, f: F) -> std::thread::JoinHandle<R>
-    where
-        F: FnOnce(&VirtualMachine) -> R,
-        F: Send + 'static,
-        R: Send + 'static,
+        where
+            F: FnOnce(&VirtualMachine) -> R,
+            F: Send + 'static,
+            R: Send + 'static,
     {
         let thread = self.new_thread();
         std::thread::spawn(|| thread.run(f))
@@ -723,13 +725,13 @@ impl VirtualMachine {
             "text",
             error.statement.clone().into_pyobject(self),
         )
-        .unwrap();
+            .unwrap();
         self.set_attr(
             syntax_error.as_object(),
             "filename",
             self.ctx.new_str(error.source_path.clone()),
         )
-        .unwrap();
+            .unwrap();
         syntax_error
     }
 
@@ -758,29 +760,29 @@ impl VirtualMachine {
     // TODO: #[track_caller] when stabilized
     fn _py_panic_failed(&self, exc: PyBaseExceptionRef, msg: &str) -> ! {
         #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
-        {
-            let show_backtrace = std::env::var_os("RUST_BACKTRACE").map_or(false, |v| &v != "0");
-            let after = if show_backtrace {
-                exceptions::print_exception(self, exc);
-                "exception backtrace above"
-            } else {
-                "run with RUST_BACKTRACE=1 to see Python backtrace"
-            };
-            panic!("{}; {}", msg, after)
-        }
+            {
+                let show_backtrace = std::env::var_os("RUST_BACKTRACE").map_or(false, |v| &v != "0");
+                let after = if show_backtrace {
+                    exceptions::print_exception(self, exc);
+                    "exception backtrace above"
+                } else {
+                    "run with RUST_BACKTRACE=1 to see Python backtrace"
+                };
+                panic!("{}; {}", msg, after)
+            }
         #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
-        {
-            use wasm_bindgen::prelude::*;
-            #[wasm_bindgen]
-            extern "C" {
-                #[wasm_bindgen(js_namespace = console)]
-                fn error(s: &str);
+            {
+                use wasm_bindgen::prelude::*;
+                #[wasm_bindgen]
+                extern "C" {
+                    #[wasm_bindgen(js_namespace = console)]
+                    fn error(s: &str);
+                }
+                let mut s = Vec::<u8>::new();
+                exceptions::write_exception(&mut s, self, &exc).unwrap();
+                error(std::str::from_utf8(&s).unwrap());
+                panic!("{}; exception backtrace above", msg)
             }
-            let mut s = Vec::<u8>::new();
-            exceptions::write_exception(&mut s, self, &exc).unwrap();
-            error(std::str::from_utf8(&s).unwrap());
-            panic!("{}; exception backtrace above", msg)
-        }
     }
     pub fn unwrap_pyresult<T>(&self, result: PyResult<T>) -> T {
         result.unwrap_or_else(|exc| {
@@ -874,8 +876,8 @@ impl VirtualMachine {
         let weird = module.borrow_value().contains('.')
             || level != 0
             || from_list
-                .as_ref()
-                .map_or(false, |x| !x.borrow_value().is_empty());
+            .as_ref()
+            .map_or(false, |x| !x.borrow_value().is_empty());
 
         let cached_module = if weird {
             None
@@ -925,7 +927,7 @@ impl VirtualMachine {
         if obj.class().is(cls) {
             Ok(true)
         } else {
-            let ret = self.call_method(cls.as_object(), "__instancecheck__", (obj.clone(),))?;
+            let ret = self.call_method(cls.as_object(), "__instancecheck__", (obj.clone(), ))?;
             pybool::boolval(self, ret)
         }
     }
@@ -933,7 +935,7 @@ impl VirtualMachine {
     /// Determines if `subclass` is a subclass of `cls`, either directly, indirectly or virtually
     /// via the __subclasscheck__ magic method.
     pub fn issubclass(&self, subclass: &PyTypeRef, cls: &PyTypeRef) -> PyResult<bool> {
-        let ret = self.call_method(cls.as_object(), "__subclasscheck__", (subclass.clone(),))?;
+        let ret = self.call_method(cls.as_object(), "__subclasscheck__", (subclass.clone(), ))?;
         pybool::boolval(self, ret)
     }
 
@@ -964,8 +966,8 @@ impl VirtualMachine {
     }
 
     pub fn call_method<T>(&self, obj: &PyObjectRef, method_name: &str, args: T) -> PyResult
-    where
-        T: IntoFuncArgs,
+        where
+            T: IntoFuncArgs,
     {
         flame_guard!(format!("call_method({:?})", method_name));
 
@@ -999,8 +1001,8 @@ impl VirtualMachine {
 
     #[inline]
     pub fn invoke<T>(&self, func_ref: &PyObjectRef, args: T) -> PyResult
-    where
-        T: IntoFuncArgs,
+        where
+            T: IntoFuncArgs,
     {
         self._invoke(func_ref, args.into_args(self))
     }
@@ -1049,8 +1051,8 @@ impl VirtualMachine {
     }
 
     pub fn extract_elements_func<T, F>(&self, value: &PyObjectRef, func: F) -> PyResult<Vec<T>>
-    where
-        F: Fn(PyObjectRef) -> PyResult<T>,
+        where
+            F: Fn(PyObjectRef) -> PyResult<T>,
     {
         // Extract elements from item, if possible:
         let cls = value.class();
@@ -1085,8 +1087,8 @@ impl VirtualMachine {
         obj: &PyObjectRef,
         mut f: F,
     ) -> PyResult<PyResult<Vec<R>>>
-    where
-        F: FnMut(PyObjectRef) -> PyResult<R>,
+        where
+            F: FnMut(PyObjectRef) -> PyResult<R>,
     {
         match_class!(match obj {
             ref l @ PyList => {
@@ -1122,8 +1124,8 @@ impl VirtualMachine {
     // get_attribute should be used for full attribute access (usually from user code).
     #[cfg_attr(feature = "flame-it", flame("VirtualMachine"))]
     pub fn get_attribute<T>(&self, obj: PyObjectRef, attr_name: T) -> PyResult
-    where
-        T: TryIntoRef<PyStr>,
+        where
+            T: TryIntoRef<PyStr>,
     {
         let attr_name = attr_name.try_into_ref(self)?;
         vm_trace!("vm.__getattribute__: {:?} {:?}", obj, attr_name);
@@ -1139,8 +1141,8 @@ impl VirtualMachine {
         obj: PyObjectRef,
         attr_name: T,
     ) -> PyResult<Option<PyObjectRef>>
-    where
-        T: TryIntoRef<PyStr>,
+        where
+            T: TryIntoRef<PyStr>,
     {
         match self.get_attribute(obj, attr_name) {
             Ok(attr) => Ok(Some(attr)),
@@ -1150,16 +1152,16 @@ impl VirtualMachine {
     }
 
     pub fn set_attr<K, V>(&self, obj: &PyObjectRef, attr_name: K, attr_value: V) -> PyResult
-    where
-        K: TryIntoRef<PyStr>,
-        V: Into<PyObjectRef>,
+        where
+            K: TryIntoRef<PyStr>,
+            V: Into<PyObjectRef>,
     {
         let attr_name = attr_name.try_into_ref(self)?;
         self.call_method(obj, "__setattr__", (attr_name, attr_value.into()))
     }
 
     pub fn del_attr(&self, obj: &PyObjectRef, attr_name: PyObjectRef) -> PyResult<()> {
-        self.call_method(&obj, "__delattr__", (attr_name,))?;
+        self.call_method(&obj, "__delattr__", (attr_name, ))?;
         Ok(())
     }
 
@@ -1171,8 +1173,8 @@ impl VirtualMachine {
         method_name: &str,
         err_msg: F,
     ) -> PyResult
-    where
-        F: FnOnce() -> String,
+        where
+            F: FnOnce() -> String,
     {
         match obj.get_class_attr(method_name) {
             Some(method) => self.call_if_get_descriptor(method, obj),
@@ -1197,12 +1199,12 @@ impl VirtualMachine {
         method: &str,
         unsupported: F,
     ) -> PyResult
-    where
-        F: Fn(&VirtualMachine, &PyObjectRef, &PyObjectRef) -> PyResult,
+        where
+            F: Fn(&VirtualMachine, &PyObjectRef, &PyObjectRef) -> PyResult,
     {
         if let Some(method_or_err) = self.get_method(obj.clone(), method) {
             let method = method_or_err?;
-            let result = self.invoke(&method, (arg.clone(),))?;
+            let result = self.invoke(&method, (arg.clone(), ))?;
             if let PyArithmaticValue::Implemented(x) = PyArithmaticValue::from_object(self, result)
             {
                 return Ok(x);
@@ -1297,13 +1299,13 @@ impl VirtualMachine {
     /// platforms where signals are not supported.
     pub fn check_signals(&self) -> PyResult<()> {
         #[cfg(not(target_arch = "wasm32"))]
-        {
-            crate::stdlib::signal::check_signals(self)
-        }
+            {
+                crate::stdlib::signal::check_signals(self)
+            }
         #[cfg(target_arch = "wasm32")]
-        {
-            Ok(())
-        }
+            {
+                Ok(())
+            }
     }
 
     /// Returns a basic CompileOpts instance with options accurate to the vm. Used
@@ -1804,15 +1806,23 @@ impl VirtualMachine {
 
 mod sealed {
     use super::*;
+
     pub trait SealedInternable {}
+
     impl SealedInternable for String {}
+
     impl SealedInternable for &str {}
+
     impl SealedInternable for PyRefExact<PyStr> {}
 }
+
 /// A sealed marker trait for `DictKey` types that always become an exact instance of `str`
 pub trait Internable: sealed::SealedInternable + crate::dictdatatype::DictKey {}
+
 impl Internable for String {}
+
 impl Internable for &str {}
+
 impl Internable for PyRefExact<PyStr> {}
 
 pub struct ReprGuard<'vm> {
@@ -1848,14 +1858,30 @@ pub struct Interpreter {
     vm: VirtualMachine,
 }
 
+/// The general interface for the VM
+///
+/// # Examples
+/// Runs a simple embedded hello world program.
+/// ```
+/// use rustpython_vm::Interpreter;
+/// use rustpython_vm::compile::Mode;
+/// Interpreter::default().enter(|vm| {
+///     let scope = vm.new_scope_with_builtins();
+///     let code_obj = vm.compile(r#"print("Hello World!")"#,
+///             Mode::Exec,
+///             "<embedded>".to_owned(),
+///     ).map_err(|err| vm.new_syntax_error(&err)).unwrap();
+///     vm.run_code_obj(code_obj, scope).unwrap();
+/// });
+/// ```
 impl Interpreter {
     pub fn new(settings: PySettings, init: InitParameter) -> Self {
         Self::new_with_init(settings, |_| init)
     }
 
     pub fn new_with_init<F>(settings: PySettings, init: F) -> Self
-    where
-        F: FnOnce(&mut VirtualMachine) -> InitParameter,
+        where
+            F: FnOnce(&mut VirtualMachine) -> InitParameter,
     {
         let mut vm = VirtualMachine::new(settings);
         let init = init(&mut vm);
@@ -1864,8 +1890,8 @@ impl Interpreter {
     }
 
     pub fn enter<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&VirtualMachine) -> R,
+        where
+            F: FnOnce(&VirtualMachine) -> R,
     {
         thread::enter_vm(&self.vm, || f(&self.vm))
     }
@@ -1905,8 +1931,8 @@ impl PyThread {
     /// as `PyObjectRef`'s `Drop` implementation tries to run the `__del__` destructor of a
     /// Python object but finds that it's not in the context of any vm.
     pub fn make_spawn_func<F, R>(self, f: F) -> impl FnOnce() -> R
-    where
-        F: FnOnce(&VirtualMachine) -> R,
+        where
+            F: FnOnce(&VirtualMachine) -> R,
     {
         move || self.run(f)
     }
@@ -1920,8 +1946,8 @@ impl PyThread {
     /// the current thread will panic as `PyObjectRef`'s `Drop` implementation tries to run the `__del__`
     /// destructor of a python object but finds that it's not in the context of any vm.
     pub fn run<F, R>(self, f: F) -> R
-    where
-        F: FnOnce(&VirtualMachine) -> R,
+        where
+            F: FnOnce(&VirtualMachine) -> R,
     {
         let vm = &self.thread_vm;
         thread::enter_vm(vm, || f(vm))

From 5a743d5ae20b015a865ea5c099734ef91a67eccb Mon Sep 17 00:00:00 2001
From: Eric van der Toorn <e.a.vandertoorn@student.tudelft.nl>
Date: Tue, 6 Apr 2021 16:22:11 +0200
Subject: [PATCH 6/8] undo CLion formatting

---
 vm/src/vm.rs | 194 +++++++++++++++++++++++++--------------------------
 1 file changed, 97 insertions(+), 97 deletions(-)

diff --git a/vm/src/vm.rs b/vm/src/vm.rs
index 35b9704fe..8e1cdf5b0 100644
--- a/vm/src/vm.rs
+++ b/vm/src/vm.rs
@@ -89,8 +89,8 @@ pub(crate) mod thread {
     }
 
     pub fn with_vm<F, R>(obj: &PyObjectRef, f: F) -> Option<R>
-        where
-            F: Fn(&VirtualMachine) -> R,
+    where
+        F: Fn(&VirtualMachine) -> R,
     {
         let vm_owns_obj = |intp: NonNull<VirtualMachine>| {
             // SAFETY: all references in VM_STACK should be valid
@@ -317,36 +317,36 @@ impl VirtualMachine {
 
         let mut inner_init = || -> PyResult<()> {
             #[cfg(not(target_arch = "wasm32"))]
-                import::import_builtin(self, "_signal")?;
+            import::import_builtin(self, "_signal")?;
 
             #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
-                {
-                    // this isn't fully compatible with CPython; it imports "io" and sets
-                    // builtins.open to io.OpenWrapper, but this is easier, since it doesn't
-                    // require the Python stdlib to be present
-                    let io = import::import_builtin(self, "_io")?;
-                    let set_stdio = |name, fd, mode: &str| {
-                        let stdio = crate::stdlib::io::open(
-                            self.ctx.new_int(fd),
-                            Some(mode),
-                            Default::default(),
-                            self,
-                        )?;
-                        self.set_attr(
-                            &self.sys_module,
-                            format!("__{}__", name), // e.g. __stdin__
-                            stdio.clone(),
-                        )?;
-                        self.set_attr(&self.sys_module, name, stdio)?;
-                        Ok(())
-                    };
-                    set_stdio("stdin", 0, "r")?;
-                    set_stdio("stdout", 1, "w")?;
-                    set_stdio("stderr", 2, "w")?;
+            {
+                // this isn't fully compatible with CPython; it imports "io" and sets
+                // builtins.open to io.OpenWrapper, but this is easier, since it doesn't
+                // require the Python stdlib to be present
+                let io = import::import_builtin(self, "_io")?;
+                let set_stdio = |name, fd, mode: &str| {
+                    let stdio = crate::stdlib::io::open(
+                        self.ctx.new_int(fd),
+                        Some(mode),
+                        Default::default(),
+                        self,
+                    )?;
+                    self.set_attr(
+                        &self.sys_module,
+                        format!("__{}__", name), // e.g. __stdin__
+                        stdio.clone(),
+                    )?;
+                    self.set_attr(&self.sys_module, name, stdio)?;
+                    Ok(())
+                };
+                set_stdio("stdin", 0, "r")?;
+                set_stdio("stdout", 1, "w")?;
+                set_stdio("stderr", 2, "w")?;
 
-                    let io_open = self.get_attribute(io, "open")?;
-                    self.set_attr(&self.builtins, "open", io_open)?;
-                }
+                let io_open = self.get_attribute(io, "open")?;
+                self.set_attr(&self.builtins, "open", io_open)?;
+            }
 
             import::init_importlib(self, initialize_parameter)?;
 
@@ -369,8 +369,8 @@ impl VirtualMachine {
 
     /// Can only be used in the initialization closure passed to [`Interpreter::new_with_init`]
     pub fn add_frozen<I>(&mut self, frozen: I)
-        where
-            I: IntoIterator<Item=(String, bytecode::FrozenModule)>,
+    where
+        I: IntoIterator<Item = (String, bytecode::FrozenModule)>,
     {
         let frozen = frozen::map_frozen(self, frozen).collect::<Vec<_>>();
         let state = PyRc::get_mut(&mut self.state)
@@ -388,10 +388,10 @@ impl VirtualMachine {
     /// not in the context of any vm.
     #[cfg(feature = "threading")]
     pub fn start_thread<F, R>(&self, f: F) -> std::thread::JoinHandle<R>
-        where
-            F: FnOnce(&VirtualMachine) -> R,
-            F: Send + 'static,
-            R: Send + 'static,
+    where
+        F: FnOnce(&VirtualMachine) -> R,
+        F: Send + 'static,
+        R: Send + 'static,
     {
         let thread = self.new_thread();
         std::thread::spawn(|| thread.run(f))
@@ -725,13 +725,13 @@ impl VirtualMachine {
             "text",
             error.statement.clone().into_pyobject(self),
         )
-            .unwrap();
+        .unwrap();
         self.set_attr(
             syntax_error.as_object(),
             "filename",
             self.ctx.new_str(error.source_path.clone()),
         )
-            .unwrap();
+        .unwrap();
         syntax_error
     }
 
@@ -760,29 +760,29 @@ impl VirtualMachine {
     // TODO: #[track_caller] when stabilized
     fn _py_panic_failed(&self, exc: PyBaseExceptionRef, msg: &str) -> ! {
         #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
-            {
-                let show_backtrace = std::env::var_os("RUST_BACKTRACE").map_or(false, |v| &v != "0");
-                let after = if show_backtrace {
-                    exceptions::print_exception(self, exc);
-                    "exception backtrace above"
-                } else {
-                    "run with RUST_BACKTRACE=1 to see Python backtrace"
-                };
-                panic!("{}; {}", msg, after)
-            }
+        {
+            let show_backtrace = std::env::var_os("RUST_BACKTRACE").map_or(false, |v| &v != "0");
+            let after = if show_backtrace {
+                exceptions::print_exception(self, exc);
+                "exception backtrace above"
+            } else {
+                "run with RUST_BACKTRACE=1 to see Python backtrace"
+            };
+            panic!("{}; {}", msg, after)
+        }
         #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
-            {
-                use wasm_bindgen::prelude::*;
-                #[wasm_bindgen]
-                extern "C" {
-                    #[wasm_bindgen(js_namespace = console)]
-                    fn error(s: &str);
-                }
-                let mut s = Vec::<u8>::new();
-                exceptions::write_exception(&mut s, self, &exc).unwrap();
-                error(std::str::from_utf8(&s).unwrap());
-                panic!("{}; exception backtrace above", msg)
+        {
+            use wasm_bindgen::prelude::*;
+            #[wasm_bindgen]
+            extern "C" {
+                #[wasm_bindgen(js_namespace = console)]
+                fn error(s: &str);
             }
+            let mut s = Vec::<u8>::new();
+            exceptions::write_exception(&mut s, self, &exc).unwrap();
+            error(std::str::from_utf8(&s).unwrap());
+            panic!("{}; exception backtrace above", msg)
+        }
     }
     pub fn unwrap_pyresult<T>(&self, result: PyResult<T>) -> T {
         result.unwrap_or_else(|exc| {
@@ -876,8 +876,8 @@ impl VirtualMachine {
         let weird = module.borrow_value().contains('.')
             || level != 0
             || from_list
-            .as_ref()
-            .map_or(false, |x| !x.borrow_value().is_empty());
+                .as_ref()
+                .map_or(false, |x| !x.borrow_value().is_empty());
 
         let cached_module = if weird {
             None
@@ -927,7 +927,7 @@ impl VirtualMachine {
         if obj.class().is(cls) {
             Ok(true)
         } else {
-            let ret = self.call_method(cls.as_object(), "__instancecheck__", (obj.clone(), ))?;
+            let ret = self.call_method(cls.as_object(), "__instancecheck__", (obj.clone(),))?;
             pybool::boolval(self, ret)
         }
     }
@@ -935,7 +935,7 @@ impl VirtualMachine {
     /// Determines if `subclass` is a subclass of `cls`, either directly, indirectly or virtually
     /// via the __subclasscheck__ magic method.
     pub fn issubclass(&self, subclass: &PyTypeRef, cls: &PyTypeRef) -> PyResult<bool> {
-        let ret = self.call_method(cls.as_object(), "__subclasscheck__", (subclass.clone(), ))?;
+        let ret = self.call_method(cls.as_object(), "__subclasscheck__", (subclass.clone(),))?;
         pybool::boolval(self, ret)
     }
 
@@ -966,8 +966,8 @@ impl VirtualMachine {
     }
 
     pub fn call_method<T>(&self, obj: &PyObjectRef, method_name: &str, args: T) -> PyResult
-        where
-            T: IntoFuncArgs,
+    where
+        T: IntoFuncArgs,
     {
         flame_guard!(format!("call_method({:?})", method_name));
 
@@ -1001,8 +1001,8 @@ impl VirtualMachine {
 
     #[inline]
     pub fn invoke<T>(&self, func_ref: &PyObjectRef, args: T) -> PyResult
-        where
-            T: IntoFuncArgs,
+    where
+        T: IntoFuncArgs,
     {
         self._invoke(func_ref, args.into_args(self))
     }
@@ -1051,8 +1051,8 @@ impl VirtualMachine {
     }
 
     pub fn extract_elements_func<T, F>(&self, value: &PyObjectRef, func: F) -> PyResult<Vec<T>>
-        where
-            F: Fn(PyObjectRef) -> PyResult<T>,
+    where
+        F: Fn(PyObjectRef) -> PyResult<T>,
     {
         // Extract elements from item, if possible:
         let cls = value.class();
@@ -1087,8 +1087,8 @@ impl VirtualMachine {
         obj: &PyObjectRef,
         mut f: F,
     ) -> PyResult<PyResult<Vec<R>>>
-        where
-            F: FnMut(PyObjectRef) -> PyResult<R>,
+    where
+        F: FnMut(PyObjectRef) -> PyResult<R>,
     {
         match_class!(match obj {
             ref l @ PyList => {
@@ -1124,8 +1124,8 @@ impl VirtualMachine {
     // get_attribute should be used for full attribute access (usually from user code).
     #[cfg_attr(feature = "flame-it", flame("VirtualMachine"))]
     pub fn get_attribute<T>(&self, obj: PyObjectRef, attr_name: T) -> PyResult
-        where
-            T: TryIntoRef<PyStr>,
+    where
+        T: TryIntoRef<PyStr>,
     {
         let attr_name = attr_name.try_into_ref(self)?;
         vm_trace!("vm.__getattribute__: {:?} {:?}", obj, attr_name);
@@ -1141,8 +1141,8 @@ impl VirtualMachine {
         obj: PyObjectRef,
         attr_name: T,
     ) -> PyResult<Option<PyObjectRef>>
-        where
-            T: TryIntoRef<PyStr>,
+    where
+        T: TryIntoRef<PyStr>,
     {
         match self.get_attribute(obj, attr_name) {
             Ok(attr) => Ok(Some(attr)),
@@ -1152,16 +1152,16 @@ impl VirtualMachine {
     }
 
     pub fn set_attr<K, V>(&self, obj: &PyObjectRef, attr_name: K, attr_value: V) -> PyResult
-        where
-            K: TryIntoRef<PyStr>,
-            V: Into<PyObjectRef>,
+    where
+        K: TryIntoRef<PyStr>,
+        V: Into<PyObjectRef>,
     {
         let attr_name = attr_name.try_into_ref(self)?;
         self.call_method(obj, "__setattr__", (attr_name, attr_value.into()))
     }
 
     pub fn del_attr(&self, obj: &PyObjectRef, attr_name: PyObjectRef) -> PyResult<()> {
-        self.call_method(&obj, "__delattr__", (attr_name, ))?;
+        self.call_method(&obj, "__delattr__", (attr_name,))?;
         Ok(())
     }
 
@@ -1173,8 +1173,8 @@ impl VirtualMachine {
         method_name: &str,
         err_msg: F,
     ) -> PyResult
-        where
-            F: FnOnce() -> String,
+    where
+        F: FnOnce() -> String,
     {
         match obj.get_class_attr(method_name) {
             Some(method) => self.call_if_get_descriptor(method, obj),
@@ -1199,12 +1199,12 @@ impl VirtualMachine {
         method: &str,
         unsupported: F,
     ) -> PyResult
-        where
-            F: Fn(&VirtualMachine, &PyObjectRef, &PyObjectRef) -> PyResult,
+    where
+        F: Fn(&VirtualMachine, &PyObjectRef, &PyObjectRef) -> PyResult,
     {
         if let Some(method_or_err) = self.get_method(obj.clone(), method) {
             let method = method_or_err?;
-            let result = self.invoke(&method, (arg.clone(), ))?;
+            let result = self.invoke(&method, (arg.clone(),))?;
             if let PyArithmaticValue::Implemented(x) = PyArithmaticValue::from_object(self, result)
             {
                 return Ok(x);
@@ -1299,13 +1299,13 @@ impl VirtualMachine {
     /// platforms where signals are not supported.
     pub fn check_signals(&self) -> PyResult<()> {
         #[cfg(not(target_arch = "wasm32"))]
-            {
-                crate::stdlib::signal::check_signals(self)
-            }
+        {
+            crate::stdlib::signal::check_signals(self)
+        }
         #[cfg(target_arch = "wasm32")]
-            {
-                Ok(())
-            }
+        {
+            Ok(())
+        }
     }
 
     /// Returns a basic CompileOpts instance with options accurate to the vm. Used
@@ -1880,8 +1880,8 @@ impl Interpreter {
     }
 
     pub fn new_with_init<F>(settings: PySettings, init: F) -> Self
-        where
-            F: FnOnce(&mut VirtualMachine) -> InitParameter,
+    where
+        F: FnOnce(&mut VirtualMachine) -> InitParameter,
     {
         let mut vm = VirtualMachine::new(settings);
         let init = init(&mut vm);
@@ -1890,8 +1890,8 @@ impl Interpreter {
     }
 
     pub fn enter<F, R>(&self, f: F) -> R
-        where
-            F: FnOnce(&VirtualMachine) -> R,
+    where
+        F: FnOnce(&VirtualMachine) -> R,
     {
         thread::enter_vm(&self.vm, || f(&self.vm))
     }
@@ -1931,8 +1931,8 @@ impl PyThread {
     /// as `PyObjectRef`'s `Drop` implementation tries to run the `__del__` destructor of a
     /// Python object but finds that it's not in the context of any vm.
     pub fn make_spawn_func<F, R>(self, f: F) -> impl FnOnce() -> R
-        where
-            F: FnOnce(&VirtualMachine) -> R,
+    where
+        F: FnOnce(&VirtualMachine) -> R,
     {
         move || self.run(f)
     }
@@ -1946,8 +1946,8 @@ impl PyThread {
     /// the current thread will panic as `PyObjectRef`'s `Drop` implementation tries to run the `__del__`
     /// destructor of a python object but finds that it's not in the context of any vm.
     pub fn run<F, R>(self, f: F) -> R
-        where
-            F: FnOnce(&VirtualMachine) -> R,
+    where
+        F: FnOnce(&VirtualMachine) -> R,
     {
         let vm = &self.thread_vm;
         thread::enter_vm(vm, || f(vm))

From b2c02838dbfb59fa0932d670de878758965f82fb Mon Sep 17 00:00:00 2001
From: Pluriscient <erictoorn@gmail.com>
Date: Thu, 15 Apr 2021 14:54:36 +0200
Subject: [PATCH 7/8] Remove todos from vm

---
 bytecode/src/lib.rs | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/bytecode/src/lib.rs b/bytecode/src/lib.rs
index 29dc7c512..b59ded2b9 100644
--- a/bytecode/src/lib.rs
+++ b/bytecode/src/lib.rs
@@ -14,7 +14,6 @@ use std::collections::BTreeSet;
 use std::{fmt, hash};
 
 /// Sourcecode location.
-/// TODO start, end, middle?
 #[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct Location {
     row: usize,
@@ -44,8 +43,6 @@ impl Location {
     }
 }
 
-/// A Constant object is
-/// TODO unclear
 pub trait Constant: Sized {
     type Name: AsRef<str>;
 
@@ -56,8 +53,6 @@ pub trait Constant: Sized {
         self.borrow_constant().into_data()
     }
     /// Map this Constant to a Bag's constant
-    ///
-    /// TODO Unclear.
     fn map_constant<Bag: ConstantBag>(self, bag: &Bag) -> Bag::Constant {
         bag.make_constant(self.into_data())
     }
@@ -588,7 +583,6 @@ pub enum ComparisonOperator {
     Is,
     IsNot,
     /// two exceptions that match?
-    /// TODO clarify
     ExceptionMatch,
 }
 
@@ -635,7 +629,6 @@ pub enum BlockType {
 */
 
 /// Argument structure
-/// TODO is this for parameters or arguments?
 pub struct Arguments<'a, N: AsRef<str>> {
     pub posonlyargs: &'a [N],
     pub args: &'a [N],
@@ -664,10 +657,6 @@ impl<N: AsRef<str>> fmt::Debug for Arguments<'_, N> {
 impl<C: Constant> CodeObject<C> {
     /// Get all arguments of the code object
     /// like inspect.getargs
-    /// # Examples
-    ///
-    /// TODO I'm not sure what is the best way to construct a CodeObject
-    ///
     pub fn arg_names(&self) -> Arguments<C::Name> {
         let nargs = self.arg_count;
         let nkwargs = self.kwonlyarg_count;
@@ -753,7 +742,6 @@ impl<C: Constant> CodeObject<C> {
     }
 
     /// Map this CodeObject to one that holds a Bag::Constant
-    /// TODO add example
     pub fn map_bag<Bag: ConstantBag>(self, bag: &Bag) -> CodeObject<Bag::Constant> {
         let map_names = |names: Box<[C::Name]>| {
             names
@@ -789,7 +777,6 @@ impl<C: Constant> CodeObject<C> {
     }
 
     /// Same as `map_bag` but clones `self`
-    /// TODO add example
     pub fn map_clone_bag<Bag: ConstantBag>(&self, bag: &Bag) -> CodeObject<Bag::Constant> {
         let map_names = |names: &[C::Name]| {
             names
@@ -943,8 +930,6 @@ impl Instruction {
 
     /// What effect this instruction has on the stack
     ///
-    /// TODO what exactly do the numbers represent?
-    ///
     /// # Examples
     ///
     /// ```
@@ -1229,7 +1214,6 @@ impl<C: Constant> fmt::Debug for CodeObject<C> {
 }
 
 /// A frozen module. Holds a code object and whether it is part of a package
-/// TODO example
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FrozenModule<C: Constant = ConstantData> {
     #[serde(bound(

From 7881fb85476e6606091b0cc5b246b6a5d97f05d6 Mon Sep 17 00:00:00 2001
From: Pluriscient <erictoorn@gmail.com>
Date: Thu, 15 Apr 2021 14:56:39 +0200
Subject: [PATCH 8/8] Remove floating comment ufrexp

---
 common/src/float_ops.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/common/src/float_ops.rs b/common/src/float_ops.rs
index 5f006180d..49430bd58 100644
--- a/common/src/float_ops.rs
+++ b/common/src/float_ops.rs
@@ -1,7 +1,6 @@
 use num_bigint::{BigInt, ToBigInt};
 use num_traits::{Float, Signed, ToPrimitive, Zero};
 
-///
 pub fn ufrexp(value: f64) -> (f64, i32) {
     if 0.0 == value {
         (0.0, 0i32)