Fix unused_must_use warnings

LeSeulArtichaut · LeSeulArtichaut · commit 6c98b6ace158 · 2020-10-31T22:48:13.000+01:00
diff --git a/chalk-solve/src/clauses/builtin_traits/unsize.rs b/chalk-solve/src/clauses/builtin_traits/unsize.rs
@@ -63,7 +63,7 @@ fn outer_binder_parameters_used<I: Interner>(
         interner,
         parameters: HashSet::new(),
     };
-    v.visit_with(&mut visitor, DebruijnIndex::INNERMOST);
+    let _ = v.visit_with(&mut visitor, DebruijnIndex::INNERMOST);
     visitor.parameters
 }
 
diff --git a/chalk-solve/src/clauses/env_elaborator.rs b/chalk-solve/src/clauses/env_elaborator.rs
@@ -26,7 +26,7 @@ pub(super) fn elaborate_env_clauses<I: Interner>(
     environment: &Environment<I>,
 ) {
     let mut this_round = vec![];
-    in_clauses.visit_with(
+    let _ = in_clauses.visit_with(
         &mut EnvElaborator::new(db, &mut this_round, environment),
         DebruijnIndex::INNERMOST,
     );
diff --git a/chalk-solve/src/infer/ucanonicalize.rs b/chalk-solve/src/infer/ucanonicalize.rs
@@ -25,7 +25,7 @@ impl<I: Interner> InferenceTable<I> {
             universes.add(*universe.skip_kind());
         }
 
-        value0.value.visit_with(
+        let _ = value0.value.visit_with(
             &mut UCollector {
                 universes: &mut universes,
                 interner,
diff --git a/chalk-solve/src/logging_db/id_collector.rs b/chalk-solve/src/logging_db/id_collector.rs
@@ -31,6 +31,7 @@ use std::collections::BTreeSet;
 /// references parent. IdCollector solves this by collecting all of the directly
 /// related identifiers, allowing those to be rendered as well, ensuring name
 /// resolution is successful.
+#[allow(unused_must_use)] // unused `Result`s from `Visitor`s
 pub fn collect_unrecorded_ids<'i, I: Interner, DB: RustIrDatabase<I>>(
     db: &'i DB,
     identifiers: &'_ BTreeSet<RecordedItemId<I>>,
diff --git a/chalk-solve/src/solve/truncate.rs b/chalk-solve/src/solve/truncate.rs
@@ -13,7 +13,7 @@ pub fn needs_truncation<I: Interner>(
     value: impl Visit<I>,
 ) -> bool {
     let mut visitor = TySizeVisitor::new(interner, infer);
-    value.visit_with(&mut visitor, DebruijnIndex::INNERMOST);
+    let _ = value.visit_with(&mut visitor, DebruijnIndex::INNERMOST);
 
     visitor.max_size > max_size
 }
@@ -45,15 +45,15 @@ impl<'infer, 'i, I: Interner> Visitor<'i, I> for TySizeVisitor<'infer, 'i, I> {
 
     fn visit_ty(&mut self, ty: &Ty<I>, outer_binder: DebruijnIndex) -> ControlFlow<()> {
         if let Some(normalized_ty) = self.infer.normalize_ty_shallow(self.interner, ty) {
-            normalized_ty.visit_with(self, outer_binder);
+            normalized_ty.visit_with(self, outer_binder)?;
             return ControlFlow::Ok(());
         }
 
         self.size += 1;
         self.max_size = max(self.size, self.max_size);
 
         self.depth += 1;
-        ty.super_visit_with(self, outer_binder);
+        ty.super_visit_with(self, outer_binder)?;
         self.depth -= 1;
 
         // When we get back to the first invocation, clear the counters.
@@ -89,7 +89,7 @@ mod tests {
                          (placeholder 1)))));
 
         let mut visitor = TySizeVisitor::new(interner, &mut table);
-        ty0.visit_with(&mut visitor, DebruijnIndex::INNERMOST);
+        let _ = ty0.visit_with(&mut visitor, DebruijnIndex::INNERMOST);
         assert!(visitor.max_size == 5);
     }
 
@@ -113,7 +113,7 @@ mod tests {
                         (placeholder 1))));
 
         let mut visitor = TySizeVisitor::new(interner, &mut table);
-        vec![&ty0, &ty1].visit_with(&mut visitor, DebruijnIndex::INNERMOST);
+        let _ = vec![&ty0, &ty1].visit_with(&mut visitor, DebruijnIndex::INNERMOST);
         assert!(visitor.max_size == 5);
     }
 }
diff --git a/chalk-solve/src/wf.rs b/chalk-solve/src/wf.rs
@@ -63,7 +63,7 @@ impl<'i, I: Interner> InputTypeCollector<'i, I> {
 
     fn types_in(interner: &'i I, value: impl Visit<I>) -> Vec<Ty<I>> {
         let mut collector = Self::new(interner);
-        value.visit_with(&mut collector, DebruijnIndex::INNERMOST);
+        let _ = value.visit_with(&mut collector, DebruijnIndex::INNERMOST);
         collector.types
     }
 }
@@ -104,12 +104,12 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {
         match ty.kind(interner) {
             TyKind::Adt(id, substitution) => {
                 push_ty();
-                id.visit_with(self, outer_binder);
+                id.visit_with(self, outer_binder)?;
                 substitution.visit_with(self, outer_binder)
             }
             TyKind::AssociatedType(assoc_ty, substitution) => {
                 push_ty();
-                assoc_ty.visit_with(self, outer_binder);
+                assoc_ty.visit_with(self, outer_binder)?;
                 substitution.visit_with(self, outer_binder)
             }
             TyKind::Scalar(scalar) => {
@@ -122,12 +122,12 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {
             }
             TyKind::Tuple(arity, substitution) => {
                 push_ty();
-                arity.visit_with(self, outer_binder);
+                arity.visit_with(self, outer_binder)?;
                 substitution.visit_with(self, outer_binder)
             }
             TyKind::OpaqueType(opaque_ty, substitution) => {
                 push_ty();
-                opaque_ty.visit_with(self, outer_binder);
+                opaque_ty.visit_with(self, outer_binder)?;
                 substitution.visit_with(self, outer_binder)
             }
             TyKind::Slice(substitution) => {
@@ -136,18 +136,18 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {
             }
             TyKind::FnDef(fn_def, substitution) => {
                 push_ty();
-                fn_def.visit_with(self, outer_binder);
+                fn_def.visit_with(self, outer_binder)?;
                 substitution.visit_with(self, outer_binder)
             }
             TyKind::Ref(mutability, lifetime, ty) => {
                 push_ty();
-                mutability.visit_with(self, outer_binder);
-                lifetime.visit_with(self, outer_binder);
+                mutability.visit_with(self, outer_binder)?;
+                lifetime.visit_with(self, outer_binder)?;
                 ty.visit_with(self, outer_binder)
             }
             TyKind::Raw(mutability, substitution) => {
                 push_ty();
-                mutability.visit_with(self, outer_binder);
+                mutability.visit_with(self, outer_binder)?;
                 substitution.visit_with(self, outer_binder)
             }
             TyKind::Never => {
@@ -156,7 +156,7 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {
             }
             TyKind::Array(ty, const_) => {
                 push_ty();
-                ty.visit_with(self, outer_binder);
+                ty.visit_with(self, outer_binder)?;
                 const_.visit_with(self, outer_binder)
             }
             TyKind::Closure(_id, substitution) => {

Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ fn outer_binder_parameters_used<I: Interner>(`
`63`	`63`	`interner,`
`64`	`64`	`parameters: HashSet::new(),`
`65`	`65`	`};`
`66`		`- v.visit_with(&mut visitor, DebruijnIndex::INNERMOST);`
	`66`	`+ let _ = v.visit_with(&mut visitor, DebruijnIndex::INNERMOST);`
`67`	`67`	`visitor.parameters`
`68`	`68`	`}`
`69`	`69`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ impl<I: Interner> InferenceTable<I> {`
`25`	`25`	`universes.add(*universe.skip_kind());`
`26`	`26`	`}`
`27`	`27`
`28`		`- value0.value.visit_with(`
	`28`	`+ let _ = value0.value.visit_with(`
`29`	`29`	`&mut UCollector {`
`30`	`30`	`universes: &mut universes,`
`31`	`31`	`interner,`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ impl<'i, I: Interner> InputTypeCollector<'i, I> {`
`63`	`63`
`64`	`64`	`fn types_in(interner: &'i I, value: impl Visit<I>) -> Vec<Ty<I>> {`
`65`	`65`	`let mut collector = Self::new(interner);`
`66`		`- value.visit_with(&mut collector, DebruijnIndex::INNERMOST);`
	`66`	`+ let _ = value.visit_with(&mut collector, DebruijnIndex::INNERMOST);`
`67`	`67`	`collector.types`
`68`	`68`	`}`
`69`	`69`	`}`
`@@ -104,12 +104,12 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {`
`104`	`104`	`match ty.kind(interner) {`
`105`	`105`	`TyKind::Adt(id, substitution) => {`
`106`	`106`	`push_ty();`
`107`		`- id.visit_with(self, outer_binder);`
	`107`	`+ id.visit_with(self, outer_binder)?;`
`108`	`108`	`substitution.visit_with(self, outer_binder)`
`109`	`109`	`}`
`110`	`110`	`TyKind::AssociatedType(assoc_ty, substitution) => {`
`111`	`111`	`push_ty();`
`112`		`- assoc_ty.visit_with(self, outer_binder);`
	`112`	`+ assoc_ty.visit_with(self, outer_binder)?;`
`113`	`113`	`substitution.visit_with(self, outer_binder)`
`114`	`114`	`}`
`115`	`115`	`TyKind::Scalar(scalar) => {`
`@@ -122,12 +122,12 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {`
`122`	`122`	`}`
`123`	`123`	`TyKind::Tuple(arity, substitution) => {`
`124`	`124`	`push_ty();`
`125`		`- arity.visit_with(self, outer_binder);`
	`125`	`+ arity.visit_with(self, outer_binder)?;`
`126`	`126`	`substitution.visit_with(self, outer_binder)`
`127`	`127`	`}`
`128`	`128`	`TyKind::OpaqueType(opaque_ty, substitution) => {`
`129`	`129`	`push_ty();`
`130`		`- opaque_ty.visit_with(self, outer_binder);`
	`130`	`+ opaque_ty.visit_with(self, outer_binder)?;`
`131`	`131`	`substitution.visit_with(self, outer_binder)`
`132`	`132`	`}`
`133`	`133`	`TyKind::Slice(substitution) => {`
`@@ -136,18 +136,18 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {`
`136`	`136`	`}`
`137`	`137`	`TyKind::FnDef(fn_def, substitution) => {`
`138`	`138`	`push_ty();`
`139`		`- fn_def.visit_with(self, outer_binder);`
	`139`	`+ fn_def.visit_with(self, outer_binder)?;`
`140`	`140`	`substitution.visit_with(self, outer_binder)`
`141`	`141`	`}`
`142`	`142`	`TyKind::Ref(mutability, lifetime, ty) => {`
`143`	`143`	`push_ty();`
`144`		`- mutability.visit_with(self, outer_binder);`
`145`		`- lifetime.visit_with(self, outer_binder);`
	`144`	`+ mutability.visit_with(self, outer_binder)?;`
	`145`	`+ lifetime.visit_with(self, outer_binder)?;`
`146`	`146`	`ty.visit_with(self, outer_binder)`
`147`	`147`	`}`
`148`	`148`	`TyKind::Raw(mutability, substitution) => {`
`149`	`149`	`push_ty();`
`150`		`- mutability.visit_with(self, outer_binder);`
	`150`	`+ mutability.visit_with(self, outer_binder)?;`
`151`	`151`	`substitution.visit_with(self, outer_binder)`
`152`	`152`	`}`
`153`	`153`	`TyKind::Never => {`
`@@ -156,7 +156,7 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> {`
`156`	`156`	`}`
`157`	`157`	`TyKind::Array(ty, const_) => {`
`158`	`158`	`push_ty();`
`159`		`- ty.visit_with(self, outer_binder);`
	`159`	`+ ty.visit_with(self, outer_binder)?;`
`160`	`160`	`const_.visit_with(self, outer_binder)`
`161`	`161`	`}`
`162`	`162`	`TyKind::Closure(_id, substitution) => {`