rustfmt util.rs

schala-lang/language/src/util.rs

@@ -1,71 +1,71 @@
-use std::collections::HashMap;
+use std::{cmp::Eq, collections::HashMap, hash::Hash, ops::Deref};
-use std::hash::Hash;
-use std::cmp::Eq;
-use std::ops::Deref;
 
 pub fn deref_optional_box<T>(x: &Option<Box<T>>) -> Option<&T> {
-  x.as_ref().map(Deref::deref)
+    x.as_ref().map(Deref::deref)
 }
 
 #[derive(Default, Debug)]
-pub struct ScopeStack<'a, T: 'a, V: 'a, N=String>  where T: Hash + Eq {
+pub struct ScopeStack<'a, T: 'a, V: 'a, N = String>
-  parent: Option<&'a ScopeStack<'a, T, V, N>>,
+where T: Hash + Eq
-  values: HashMap<T, V>,
+{
-  scope_name: Option<N>
+    parent: Option<&'a ScopeStack<'a, T, V, N>>,
+    values: HashMap<T, V>,
+    scope_name: Option<N>,
 }
 
-impl<'a, T, V, N> ScopeStack<'a, T, V, N> where T: Hash + Eq {
+impl<'a, T, V, N> ScopeStack<'a, T, V, N>
-  pub fn new(scope_name: Option<N>) -> Self where T: Hash + Eq {
+where T: Hash + Eq
-    ScopeStack {
+{
-      parent: None,
+    pub fn new(scope_name: Option<N>) -> Self
-      values: HashMap::new(),
+    where T: Hash + Eq {
-      scope_name,
+        ScopeStack { parent: None, values: HashMap::new(), scope_name }
     }
-  }
+    pub fn insert(&mut self, key: T, value: V)
-  pub fn insert(&mut self, key: T, value: V) where T: Hash + Eq {
+    where T: Hash + Eq {
-    self.values.insert(key, value);
+        self.values.insert(key, value);
-  }
-  pub fn lookup(&self, key: &T) -> Option<&V> where T: Hash + Eq {
-    match (self.values.get(key), self.parent) {
-      (None, None) => None,
-      (None, Some(parent)) => parent.lookup(key),
-      (Some(value), _) => Some(value),
     }
-  }
+    pub fn lookup(&self, key: &T) -> Option<&V>
-
+    where T: Hash + Eq {
-  pub fn new_scope(&'a self, scope_name: Option<N>) -> Self where T: Hash + Eq {
+        match (self.values.get(key), self.parent) {
-    ScopeStack {
+            (None, None) => None,
-      parent: Some(self),
+            (None, Some(parent)) => parent.lookup(key),
-      values: HashMap::default(),
+            (Some(value), _) => Some(value),
-      scope_name,
+        }
     }
-  }
 
-  #[allow(dead_code)]
+    pub fn new_scope(&'a self, scope_name: Option<N>) -> Self
-  pub fn lookup_with_scope(&self, key: &T) -> Option<(&V, Option<&N>)> where T: Hash + Eq {
+    where T: Hash + Eq {
-      match (self.values.get(key), self.parent) {
+        ScopeStack { parent: Some(self), values: HashMap::default(), scope_name }
-          (None, None) => None,
+    }
-          (None, Some(parent)) => parent.lookup_with_scope(key),
-          (Some(value), _) => Some((value, self.scope_name.as_ref()))
-      }
-  }
 
-  pub fn get_name(&self) -> Option<&N> {
+    #[allow(dead_code)]
-    self.scope_name.as_ref()
+    pub fn lookup_with_scope(&self, key: &T) -> Option<(&V, Option<&N>)>
-  }
+    where T: Hash + Eq {
+        match (self.values.get(key), self.parent) {
+            (None, None) => None,
+            (None, Some(parent)) => parent.lookup_with_scope(key),
+            (Some(value), _) => Some((value, self.scope_name.as_ref())),
+        }
+    }
+
+    pub fn get_name(&self) -> Option<&N> {
+        self.scope_name.as_ref()
+    }
 }
 
 /// Quickly create an AST from a string, with no error checking. For test use only
 #[cfg(test)]
 pub fn quick_ast(input: &str) -> crate::ast::AST {
-  let tokens = crate::tokenizing::tokenize(input);
+    let tokens = crate::tokenizing::tokenize(input);
-  let mut parser = crate::parsing::Parser::new();
+    let mut parser = crate::parsing::Parser::new();
-  parser.add_new_tokens(tokens);
+    parser.add_new_tokens(tokens);
-  let output = parser.parse();
+    let output = parser.parse();
-  output.unwrap()
+    output.unwrap()
 }
 
 #[allow(unused_macros)]
 macro_rules! rc {
-  ($string:tt) => { Rc::new(stringify!($string).to_string()) }
+    ($string:tt) => {
+        Rc::new(stringify!($string).to_string())
+    };
 }