Implement keyword suggestion routine

`suggestions.rs` is almost porting of implementation of
[this](python/cpython#16856) and
[this](python/cpython#25397).

Signed-off-by: snowapril <[email protected]>

Author: Snowapril

vm/src/builtins/code.rs

@@ -256,7 +256,7 @@ impl PyRef<PyCode> {
     }
 
     #[pyproperty]
-    fn co_varnames(self, vm: &VirtualMachine) -> PyTupleRef {
+    pub fn co_varnames(self, vm: &VirtualMachine) -> PyTupleRef {
         let varnames = self
             .code
             .varnames

vm/src/lib.rs

@@ -70,6 +70,7 @@ mod sequence;
 mod signal;
 pub mod sliceable;
 pub mod stdlib;
+pub mod suggestion;
 pub mod types;
 pub mod utils;
 pub mod version;

vm/src/suggestion.rs

@@ -0,0 +1,176 @@
+use crate::{
+    builtins::{PyList, PyStrRef},
+    exceptions::types::PyBaseExceptionRef,
+    sliceable::PySliceableSequence,
+    IdProtocol, PyObjectRef, TryFromObject, TypeProtocol, VirtualMachine,
+};
+use std::cell::RefCell;
+use std::thread_local;
+
+const MAX_CANDIDATE_ITEMS: usize = 750;
+const MAX_STRING_SIZE: usize = 40;
+
+const MOVE_COST: usize = 2;
+const CASE_COST: usize = 1;
+
+fn substitution_cost(mut a: u8, mut b: u8) -> usize {
+    if (a & 31) != (b & 31) {
+        return MOVE_COST;
+    }
+    if a == b {
+        return 0usize;
+    }
+    if (b'A'..=b'Z').contains(&a) {
+        a += b'a' - b'A';
+    }
+    if (b'A'..=b'Z').contains(&b) {
+        b += b'a' - b'A';
+    }
+    if a == b {
+        CASE_COST
+    } else {
+        MOVE_COST
+    }
+}
+
+fn levenshtein_distance(a: &str, b: &str, max_cost: usize) -> usize {
+    thread_local! {
+        static BUFFER: RefCell<[usize; MAX_STRING_SIZE]> = RefCell::new([0usize; MAX_STRING_SIZE]);
+    }
+
+    if a == b {
+        return 0;
+    }
+
+    let (mut a_bytes, mut b_bytes) = (a.as_bytes(), b.as_bytes());
+    let (mut a_begin, mut a_end) = (0usize, a.len());
+    let (mut b_begin, mut b_end) = (0usize, b.len());
+
+    while a_end > 0 && b_end > 0 && (a_bytes[a_begin] == b_bytes[b_begin]) {
+        a_begin += 1;
+        b_begin += 1;
+        a_end -= 1;
+        b_end -= 1;
+    }
+    while a_end > 0 && b_end > 0 && (a_bytes[a_begin + a_end - 1] == b_bytes[b_begin + b_end - 1]) {
+        a_end -= 1;
+        b_end -= 1;
+    }
+    if a_end == 0 || b_end == 0 {
+        return (a_end + b_end) * MOVE_COST;
+    }
+    if a_end > MAX_STRING_SIZE || b_end > MAX_STRING_SIZE {
+        return max_cost + 1;
+    }
+
+    if b_end < a_end {
+        std::mem::swap(&mut a_bytes, &mut b_bytes);
+        std::mem::swap(&mut a_begin, &mut b_begin);
+        std::mem::swap(&mut a_end, &mut b_end);
+    }
+
+    if (b_end - a_end) * MOVE_COST > max_cost {
+        return max_cost + 1;
+    }
+
+    BUFFER.with(|buffer| {
+        for i in 0..a_end {
+            buffer.borrow_mut()[i] = (i + 1) * MOVE_COST;
+        }
+
+        let mut result = 0usize;
+        for (b_index, b_code) in b_bytes[b_begin..(b_begin + b_end)].iter().enumerate() {
+            result = b_index * MOVE_COST;
+            let mut distance = result;
+            let mut minimum = usize::MAX;
+            for (a_index, a_code) in a_bytes[a_begin..(a_begin + a_end)].iter().enumerate() {
+                let substitute = distance + substitution_cost(*b_code, *a_code);
+                distance = buffer.borrow()[a_index];
+                let insert_delete = usize::min(result, distance) + MOVE_COST;
+                result = usize::min(insert_delete, substitute);
+
+                buffer.borrow_mut()[a_index] = result;
+                if result < minimum {
+                    minimum = result;
+                }
+            }
+            if minimum > max_cost {
+                return max_cost + 1;
+            }
+        }
+        result
+    })
+}
+
+fn calculate_suggestions(dir: PyList, name: &PyObjectRef, vm: &VirtualMachine) -> Option<PyStrRef> {
+    let dir = dir.borrow_vec();
+    if dir.len() >= MAX_CANDIDATE_ITEMS {
+        return None;
+    }
+
+    let mut suggestion: Option<PyStrRef> = None;
+    let mut suggestion_distance = usize::MAX;
+    let name = match PyStrRef::try_from_object(vm, name.clone()) {
+        Ok(name) => name,
+        Err(_) => return None,
+    };
+
+    for item in dir.iter() {
+        let item_name = match PyStrRef::try_from_object(vm, item.clone()) {
+            Ok(name) => name,
+            Err(_) => return None,
+        };
+        if name.to_string() == item_name.to_string() {
+            continue;
+        }
+        let max_distance = usize::min(
+            (name.len() + item_name.len() + 3) * MOVE_COST / 6,
+            suggestion_distance - 1,
+        );
+        let current_distance =
+            levenshtein_distance(name.as_str(), item_name.as_str(), max_distance);
+        if current_distance > max_distance {
+            continue;
+        }
+        if suggestion.is_none() || current_distance < suggestion_distance {
+            suggestion = Some(item_name);
+            suggestion_distance = current_distance;
+        }
+    }
+    suggestion
+}
+
+pub fn offer_suggestions(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> Option<PyStrRef> {
+    if exc.class().is(&vm.ctx.exceptions.attribute_error) {
+        let name = vm.get_attribute(exc.as_object().clone(), "name").unwrap();
+        let obj = vm.get_attribute(exc.as_object().clone(), "obj").unwrap();
+
+        match vm.dir(Some(obj)) {
+            Ok(dir_list) => calculate_suggestions(dir_list, &name, vm),
+            Err(_) => None,
+        }
+    } else if exc.class().is(&vm.ctx.exceptions.name_error) {
+        let name = vm.get_attribute(exc.as_object().clone(), "name").unwrap();
+        let mut tb = exc.traceback().unwrap();
+        while let Some(traceback) = tb.next.clone() {
+            tb = traceback;
+        }
+
+        let frame = tb.frame.clone();
+        let code = frame.code.clone();
+        let varnames = PyList::from(code.co_varnames(vm).as_slice().to_vec());
+        if let Some(suggestions) = calculate_suggestions(varnames, &name, vm) {
+            return Some(suggestions);
+        };
+
+        let globals = PyList::from(vm.extract_elements(frame.globals.as_object()).unwrap());
+        if let Some(suggestions) = calculate_suggestions(globals, &name, vm) {
+            return Some(suggestions);
+        };
+
+        let builtins = PyList::from(vm.extract_elements(frame.builtins.as_object()).unwrap());
+        calculate_suggestions(builtins, &name, vm)
+    } else {
+        None
+    }
+}