Merge #819

819: Remove function inlining r=Marwes a=Marwes



Co-authored-by: Markus Westerlind <[email protected]>

Author: bors[bot]

base/src/merge.rs

@@ -74,7 +74,7 @@ where
     T: Clone + 'a,
     R: std::iter::FromIterator<T>,
 {
-    merge_collect(&mut (), types, |_, (l, r)| f(l, r), |(l, _)| l.clone())
+    merge_collect(&mut (), types, |_, (l, r)| f(l, r), |_, (l, _)| l.clone())
 }
 
 pub struct MergeIter<'s, I, F, G, T, S>
@@ -95,13 +95,15 @@ where
     S: ?Sized,
     I: Iterator,
     F: FnMut(&mut S, I::Item) -> Option<U>,
-    G: FnMut(I::Item) -> U,
+    G: FnMut(&mut S, I::Item) -> U,
 {
     type Item = U;
     fn next(&mut self) -> Option<Self::Item> {
         if self.clone_types > 0 {
             self.clone_types -= 1;
-            self.clone_types_iter.next().map(&mut self.converter)
+            let converter = &mut self.converter;
+            let state = &mut self.state;
+            self.clone_types_iter.next().map(|e| converter(state, e))
         } else if let Some(typ) = self.next.take() {
             self.clone_types_iter.next();
             Some(typ)
@@ -135,7 +137,7 @@ where
     S: ?Sized,
     I: ExactSizeIterator,
     F: FnMut(&mut S, I::Item) -> Option<U>,
-    G: FnMut(I::Item) -> U,
+    G: FnMut(&mut S, I::Item) -> U,
 {
     fn len(&self) -> usize {
         self.clone_types_iter.len()
@@ -153,7 +155,7 @@ where
     I: IntoIterator,
     I::IntoIter: FusedIterator + Clone,
     F: FnMut(&mut S, I::Item) -> Option<U>,
-    G: FnMut(I::Item) -> U,
+    G: FnMut(&mut S, I::Item) -> U,
     R: std::iter::FromIterator<U>,
 {
     merge_iter(state, types, action, converter).map(|iter| iter.collect())
@@ -170,7 +172,7 @@ where
     I: IntoIterator,
     I::IntoIter: FusedIterator + Clone,
     F: FnMut(&mut S, I::Item) -> Option<U>,
-    G: FnMut(I::Item) -> U,
+    G: FnMut(&mut S, I::Item) -> U,
 {
     let mut types = types.into_iter();
     let clone_types_iter = types.clone();

base/src/scoped_map.rs

@@ -75,29 +75,28 @@ impl<K: Eq + Hash + Clone, V> ScopedMap<K, V> {
     }
 
     /// Removes a previously inserted value from the map.
-    pub fn remove<Q>(&mut self, k: &Q) -> bool
+    pub fn remove<Q>(&mut self, k: &Q) -> Option<V>
     where
         K: Borrow<Q>,
-        Q: Eq + Hash,
+        Q: ?Sized + Eq + Hash,
         K: ::std::fmt::Debug,
         V: ::std::fmt::Debug,
     {
-        match self.map.get_mut(k).map(|x| x.pop()) {
-            Some(..) => {
-                let mut i = self.scopes.len() as isize - 1;
-                while i >= 0 {
-                    if self.scopes[i as usize]
-                        .as_ref()
-                        .map_or(false, |x| x.borrow() == k)
-                    {
-                        self.scopes.remove(i as usize);
-                    }
-                    i -= 1;
-                }
-                true
+        let x = self.map.get_mut(k).map(|x| x.pop())?;
+        let mut i = self.scopes.len() as isize - 1;
+        while i >= 0 {
+            if self.scopes[i as usize]
+                .as_ref()
+                .expect("Tried to remove entry not in the current scope")
+                .borrow()
+                == k
+            {
+                self.scopes.remove(i as usize);
+                break;
             }
-            None => false,
+            i -= 1;
         }
+        x
     }
 
     /// Returns true if the key has a value declared in the last declared scope
@@ -230,6 +229,12 @@ impl<K: Eq + Hash + Clone, V> ScopedMap<K, V> {
             }
         }
     }
+
+    pub fn into_iter(self) -> impl Iterator<Item = (K, V)> {
+        self.map
+            .into_iter()
+            .filter_map(|(k, mut v)| Some((k, v.pop()?)))
+    }
 }
 
 impl<K: Eq + Hash, V> ScopedMap<K, V> {
@@ -427,4 +432,20 @@ mod tests {
         assert_eq!(map.get(&"a"), Some(&0));
         assert_eq!(map.get(&"c"), None);
     }
+
+    #[test]
+    fn remove() {
+        let mut map = ScopedMap::new();
+        map.insert("a", 0);
+        map.enter_scope();
+        map.insert("a", 1);
+        map.insert("b", 2);
+        assert_eq!(map.get("a"), Some(&1));
+        map.remove("a");
+        assert_eq!(map.get("a"), Some(&0));
+        assert_eq!(map.get("b"), Some(&2));
+        map.remove("b");
+        assert_eq!(map.get("b"), None);
+        map.exit_scope();
+    }
 }

base/src/symbol.rs

@@ -161,6 +161,15 @@ impl From<String> for Symbol {
     }
 }
 
+impl<N> From<SymbolData<N>> for Symbol
+where
+    N: Into<NameBuf>,
+{
+    fn from(name: SymbolData<N>) -> Symbol {
+        Symbol(Arc::new(SymbolInner::new(name)))
+    }
+}
+
 impl From<&'_ str> for Symbol {
     fn from(name: &str) -> Symbol {
         Symbol(Arc::new(SymbolInner::new(SymbolData::<NameBuf>::from(
@@ -282,6 +291,10 @@ impl Symbol {
                 .location
                 .map_or_else(|| self.0.name.len(), |l| l as usize)]
     }
+
+    pub fn as_data(&self) -> SymbolData<&Name> {
+        SymbolData::from(&self.0.name.0[..])
+    }
 }
 
 impl SymbolRef {

base/src/types/mod.rs

@@ -4473,7 +4473,7 @@ where
     T: Clone + 'a,
     R: FromIterator<T>,
 {
-    merge_collect(state, types, f, Clone::clone)
+    merge_collect(state, types, f, |_, e| e.clone())
 }
 
 pub fn translate_alias<Id, T, U, F, I>(

check/src/unify_type.rs

@@ -1581,6 +1581,49 @@ impl<'a, 'e> Unifier<State<'a>, RcType> for UnifierState<'a, Smaller> {
     }
 }
 
+pub fn instantiation<'a>(
+    env: &'a (dyn TypeEnv<Type = RcType> + 'a),
+    f: &mut dyn FnMut(&Symbol, &RcType),
+    l: &RcType,
+    r: &RcType,
+) {
+    let subs = Default::default();
+    let state = State::new(env, &subs);
+    let mut unifier = UnifierState {
+        unifier: Instantiation { consumer: f },
+        state,
+    };
+
+    unifier.try_match(l, r);
+}
+
+pub struct Instantiation<'a, 'b> {
+    consumer: &'a mut (dyn FnMut(&Symbol, &RcType) + 'b),
+}
+
+impl<'a> Unifier<State<'a>, RcType> for UnifierState<'a, Instantiation<'_, '_>> {
+    fn report_error(&mut self, _error: UnifyError<TypeError<Symbol, RcType>, RcType>) {}
+
+    fn try_match_res(
+        &mut self,
+        l: &RcType,
+        r: &RcType,
+    ) -> Result<Option<RcType>, UnifyError<TypeError<Symbol, RcType>, RcType>> {
+        match (&**l, &**r) {
+            (Type::Generic(l), _) => {
+                (self.unifier.consumer)(&l.id, r);
+                Ok(None)
+            }
+
+            _ => l.zip_match(r, self),
+        }
+    }
+
+    fn error_type(&self) -> RcType {
+        RcType::error_type(&self.state)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

check/tests/implicits.rs

@@ -47,7 +47,7 @@ f 42
                     ref implicit_args, ..
                 } => match (&implicit_args[0].value, &bind[0].name.value) {
                     (&Expr::Ident(ref arg), &Pattern::Ident(ref bind_id)) => {
-                        assert_eq!(arg.name, bind_id.name)
+                        assert_eq!(arg.name, bind_id.name);
                     }
                     _ => panic!(),
                 },

codegen/src/functor.rs

@@ -1,3 +1,5 @@
+extern crate proc_macro;
+
 use proc_macro2::{Ident, Span, TokenStream};
 use syn::{self, Data, DeriveInput, Generics};
 

repl/src/main.rs

@@ -152,6 +152,14 @@ pub struct Opt {
     #[structopt(name = "FILE", help = "Executes each file as a gluon program")]
     input: Vec<String>,
 
+    #[structopt(
+        last = true,
+        name = "ARGS",
+        help = "Extra arguments passed to the gluon program"
+    )]
+    #[allow(dead_code)]
+    args: Vec<String>,
+
     #[structopt(subcommand)]
     subcommand_opt: Option<SubOpt>,
 }

repl/src/repl.rs

@@ -377,7 +377,6 @@ async fn eval_line_(vm: RootedThread, line: &str) -> gluon::Result<()> {
     let mut eval_expr;
     let value = {
         let mut db = vm.get_database();
-        let mut db = gluon::salsa::OwnedDb::<dyn gluon::query::Compilation>::from(&mut db);
         let mut module_compiler = vm.module_compiler(&mut db);
         eval_expr = {
             let eval_expr = {