cleanups

Author: ZuseZ4

compiler/rustc_ast/src/expand/autodiff_attrs.rs

@@ -6,7 +6,6 @@
 use std::fmt::{self, Display, Formatter};
 use std::str::FromStr;
 
-//use crate::expand::typetree::TypeTree;
 use crate::expand::{Decodable, Encodable, HashStable_Generic};
 use crate::ptr::P;
 use crate::{Ty, TyKind};
@@ -79,10 +78,6 @@ pub struct AutoDiffItem {
     /// The name of the function being generated
     pub target: String,
     pub attrs: AutoDiffAttrs,
-    ///// Describe the memory layout of input types
-    //pub inputs: Vec<TypeTree>,
-    ///// Describe the memory layout of the output type
-    //pub output: TypeTree,
 }
 #[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
 pub struct AutoDiffAttrs {
@@ -266,19 +261,14 @@ impl AutoDiffAttrs {
         self,
         source: String,
         target: String,
-        //inputs: Vec<TypeTree>,
-        //output: TypeTree,
     ) -> AutoDiffItem {
         AutoDiffItem { source, target, attrs: self }
-        //AutoDiffItem { source, target, inputs, output, attrs: self }
     }
 }
 
 impl fmt::Display for AutoDiffItem {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Differentiating {} -> {}", self.source, self.target)?;
         write!(f, " with attributes: {:?}", self.attrs)
-        //write!(f, " with inputs: {:?}", self.inputs)?;
-        //write!(f, " with output: {:?}", self.output)
     }
 }

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1090,7 +1090,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memcpy not supported");
         let size = self.intcast(size, self.type_isize(), false);
         let is_volatile = flags.contains(MemFlags::VOLATILE);
-        let val = unsafe {
+        unsafe {
             llvm::LLVMRustBuildMemCpy(
                 self.llbuilder,
                 dst,
@@ -1099,8 +1099,8 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 src_align.bytes() as c_uint,
                 size,
                 is_volatile,
-            )
-        };
+            );
+        }
     }
 
     fn memmove(
@@ -1115,7 +1115,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memmove not supported");
         let size = self.intcast(size, self.type_isize(), false);
         let is_volatile = flags.contains(MemFlags::VOLATILE);
-        let val = unsafe {
+        unsafe {
             llvm::LLVMRustBuildMemMove(
                 self.llbuilder,
                 dst,
@@ -1124,8 +1124,8 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 src_align.bytes() as c_uint,
                 size,
                 is_volatile,
-            )
-        };
+            );
+        }
     }
 
     fn memset(
@@ -1138,16 +1138,16 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     ) {
         assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memset not supported");
         let is_volatile = flags.contains(MemFlags::VOLATILE);
-        let val = unsafe {
+        unsafe {
             llvm::LLVMRustBuildMemSet(
                 self.llbuilder,
                 ptr,
                 align.bytes() as c_uint,
                 fill_byte,
                 size,
                 is_volatile,
-            )
-        };
+            );
+        }
     }
 
     fn select(