Clippy fixes

analysis/src/data.rs

@@ -37,7 +37,6 @@ pub struct Datas {
     // TODO: Don't use `Result`
     name_lut: HashMap<Ident, (Span, Result<DataId, AliasId>, GenScopeId)>,
     cons_lut: HashMap<Ident, (Span, DataId)>,
-    alias_lut: HashMap<Ident, Alias>,
     datas: Vec<(Span, Option<Data>, GenScopeId, Ident)>,
     aliases: Vec<(Span, Option<Alias>, GenScopeId)>,
     pub lang: Lang,
@@ -49,7 +48,7 @@ impl Datas {
     }
 
     pub fn iter_aliases(&self) -> impl Iterator<Item = AliasId> {
-        (0..self.aliases.len()).map(|i| AliasId(i))
+        (0..self.aliases.len()).map(AliasId)
     }
 
     pub fn data_gen_scope(&self, data: DataId) -> GenScopeId {
@@ -94,27 +93,41 @@ impl Datas {
     }
 
     pub fn get_alias(&self, alias: AliasId) -> Option<&Alias> {
-        self.aliases[alias.0]
-            .1
-            .as_ref()
+        self.aliases[alias.0].1.as_ref()
     }
 
     pub fn get_alias_span(&self, alias: AliasId) -> Span {
         self.aliases[alias.0].0
     }
 
-    pub fn declare_data(&mut self, name: SrcNode<Ident>, gen_scope: GenScopeId, attr: &[SrcNode<ast::Attr>]) -> Result<DataId, Error> {
+    pub fn declare_data(
+        &mut self,
+        name: SrcNode<Ident>,
+        gen_scope: GenScopeId,
+        attr: &[SrcNode<ast::Attr>],
+    ) -> Result<DataId, Error> {
         let id = DataId(self.datas.len(), *name);
-        if let Err(old) = self.name_lut.try_insert(*name, (name.span(), Ok(id), gen_scope)) {
-            Err(Error::DuplicateTypeName(*name, old.entry.get().0, name.span()))
+        if let Err(old) = self
+            .name_lut
+            .try_insert(*name, (name.span(), Ok(id), gen_scope))
+        {
+            Err(Error::DuplicateTypeName(
+                *name,
+                old.entry.get().0,
+                name.span(),
+            ))
         } else {
             if let Some(lang) = attr
                 .iter()
                 .find(|a| &**a.name == "lang")
                 .and_then(|a| a.args.as_ref())
             {
-                if lang.iter().find(|a| &**a.name == "go").is_some() { self.lang.go = Some(id); }
-                if lang.iter().find(|a| &**a.name == "bool").is_some() { self.lang.r#bool = Some(id); }
+                if lang.iter().any(|a| &**a.name == "go") {
+                    self.lang.go = Some(id);
+                }
+                if lang.iter().any(|a| &**a.name == "bool") {
+                    self.lang.r#bool = Some(id);
+                }
             }
 
             self.datas.push((name.span(), None, gen_scope, *name));
@@ -125,13 +138,22 @@ impl Datas {
     pub fn check_lang_items(&self) -> Vec<Error> {
         let mut errors = Vec::new();
 
-        if self.lang.go.is_none() { errors.push(Error::MissingLangItem("go")); }
-        if self.lang.r#bool.is_none() { errors.push(Error::MissingLangItem("bool")); }
+        if self.lang.go.is_none() {
+            errors.push(Error::MissingLangItem("go"));
+        }
+        if self.lang.r#bool.is_none() {
+            errors.push(Error::MissingLangItem("bool"));
+        }
 
         errors
     }
 
-    pub fn declare_alias(&mut self, name: Ident, span: Span, gen_scope: GenScopeId) -> Result<AliasId, Error> {
+    pub fn declare_alias(
+        &mut self,
+        name: Ident,
+        span: Span,
+        gen_scope: GenScopeId,
+    ) -> Result<AliasId, Error> {
         let id = AliasId(self.aliases.len());
         if let Err(old) = self.name_lut.try_insert(name, (span, Err(id), gen_scope)) {
             Err(Error::DuplicateTypeName(name, old.entry.get().0, span))
@@ -141,15 +163,19 @@ impl Datas {
         }
     }
 
-    pub fn define_data(&mut self, id: DataId, span: Span, data: Data) -> Result<(), Vec<Error>> {
+    pub fn define_data(&mut self, id: DataId, _span: Span, data: Data) -> Result<(), Vec<Error>> {
         let mut errors = Vec::new();
         for (cons, _) in &data.cons {
             if let Err(old) = self.cons_lut.try_insert(**cons, (cons.span(), id)) {
-                errors.push(Error::DuplicateConsName(**cons, old.entry.get().0, cons.span()));
+                errors.push(Error::DuplicateConsName(
+                    **cons,
+                    old.entry.get().0,
+                    cons.span(),
+                ));
             }
         }
         self.datas[id.0].1 = Some(data);
-        if errors.len() == 0 {
+        if errors.is_empty() {
             Ok(())
         } else {
             Err(errors)

analysis/src/debug.rs

@@ -37,24 +37,24 @@ impl<'hir, 'a> dot::Labeller<'a, Node, Edge> for CallGraph<'hir> {
 
 impl<'hir, 'a> dot::GraphWalk<'a, Node, Edge> for CallGraph<'hir> {
     fn nodes(&'a self) -> dot::Nodes<'a, Node> {
-        self.ctx.defs
+        self.ctx
+            .defs
             .iter()
-            .filter_map(|(id, def)| if def.attr.iter().find(|a| &**a.name == "util").is_none() {
-                Some((id, *def.name))
-            } else {
-                None
+            .filter_map(|(id, def)| {
+                if !def.attr.iter().any(|a| &**a.name == "util") {
+                    Some((id, *def.name))
+                } else {
+                    None
+                }
             })
             .collect()
     }
     fn edges(&'a self) -> dot::Edges<'a, Edge> {
         fn fetch_edge(ctx: &Context, parent: Node, expr: &TyExpr, edges: &mut HashSet<Edge>) {
             if let hir::Expr::Global(global) = &**expr {
                 let def = ctx.defs.get(global.0);
-                if def.attr.iter().find(|a| &**a.name == "util").is_none() {
-                    edges.insert((
-                        parent,
-                        (global.0, *def.name),
-                    ));
+                if !def.attr.iter().any(|a| &**a.name == "util") {
+                    edges.insert((parent, (global.0, *def.name)));
                 }
             }
 
@@ -63,13 +63,17 @@ impl<'hir, 'a> dot::GraphWalk<'a, Node, Edge> for CallGraph<'hir> {
 
         let mut edges = HashSet::new();
         for (id, def) in self.ctx.defs.iter() {
-            if def.attr.iter().find(|a| &**a.name == "util").is_none() {
+            if !def.attr.iter().any(|a| &**a.name == "util") {
                 let parent = (id, *def.name);
                 fetch_edge(self.ctx, parent, def.body.as_ref().unwrap(), &mut edges);
             }
         }
         edges.into_iter().collect()
     }
-    fn source(&self, e: &Edge) -> Node { e.0 }
-    fn target(&self, e: &Edge) -> Node { e.1 }
+    fn source(&self, e: &Edge) -> Node {
+        e.0
+    }
+    fn target(&self, e: &Edge) -> Node {
+        e.1
+    }
 }

analysis/src/def.rs

@@ -52,7 +52,8 @@ impl Defs {
         if let Err(old) = self.lut.try_insert(name, (span, id)) {
             Err(Error::DuplicateDefName(name, old.entry.get().0, span))
         } else {
-            if let Some(lang) = def.attr
+            if let Some(_lang) = def
+                .attr
                 .iter()
                 .find(|a| &**a.name == "lang")
                 .and_then(|a| a.args.as_ref())
@@ -68,11 +69,7 @@ impl Defs {
     }
 
     pub fn check_lang_items(&self) -> Vec<Error> {
-        let mut errors = Vec::new();
-
-        // if self.lang.io_unit.is_none() { errors.push(Error::MissingLangItem("io_unit")); }
-
-        errors
+        Vec::new()
     }
 
     pub fn define_body(&mut self, id: DefId, expr: TyExpr) {

analysis/src/effect.rs

@@ -50,7 +50,10 @@ impl Effects {
     }
 
     pub fn iter(&self) -> impl Iterator<Item = (EffectDeclId, &EffectDecl)> {
-        self.effect_decls.iter().enumerate().map(|(i, eff)| (EffectDeclId(i, *eff.name), eff))
+        self.effect_decls
+            .iter()
+            .enumerate()
+            .map(|(i, eff)| (EffectDeclId(i, *eff.name), eff))
     }
 
     // pub fn iter(&self) -> impl Iterator<Item = (EffectDeclId, &EffectDecl)> {
@@ -65,9 +68,14 @@ impl Effects {
         let id = EffectDeclId(self.effect_decls.len(), *eff.name);
         let span = eff.name.span();
         if let Err(old) = self.lut.try_insert(*eff.name, (span, Ok(id))) {
-            Err(Error::DuplicateEffectDecl(*eff.name, old.entry.get().0, span))
+            Err(Error::DuplicateEffectDecl(
+                *eff.name,
+                old.entry.get().0,
+                span,
+            ))
         } else {
-            if let Some(lang) = eff.attr
+            if let Some(_lang) = eff
+                .attr
                 .iter()
                 .find(|a| &**a.name == "lang")
                 .and_then(|a| a.args.as_ref())
@@ -86,27 +94,31 @@ impl Effects {
         let id = EffectAliasId(self.effect_aliases.len());
         let span = alias.name.span();
         if let Err(old) = self.lut.try_insert(*alias.name, (span, Err(id))) {
-            Err(Error::DuplicateEffectDecl(*alias.name, old.entry.get().0, span))
+            Err(Error::DuplicateEffectDecl(
+                *alias.name,
+                old.entry.get().0,
+                span,
+            ))
         } else {
             self.effect_aliases.push(alias);
             Ok(id)
         }
     }
 
     pub fn check_lang_items(&self) -> Vec<Error> {
-        let mut errors = Vec::new();
-
-        // if self.lang.not.is_none() { errors.push(Error::MissingLangItem("not")); }
-
-        errors
+        Vec::new()
     }
 
     pub fn define_send_recv(&mut self, id: EffectDeclId, send: TyId, recv: TyId) {
         self.effect_decls[id.0].send = Some(send);
         self.effect_decls[id.0].recv = Some(recv);
     }
 
-    pub fn define_alias_effects(&mut self, id: EffectAliasId, effs: Vec<(SrcNode<EffectDeclId>, Vec<TyId>)>) {
+    pub fn define_alias_effects(
+        &mut self,
+        id: EffectAliasId,
+        effs: Vec<(SrcNode<EffectDeclId>, Vec<TyId>)>,
+    ) {
         self.effect_aliases[id.0].effects = Some(effs);
     }
 }