Smoe more minor optimizations

Really just one batched allocation, and the rest are style changes

Author: JulianKnodt

compiler/rustc_expand/src/base.rs

@@ -1071,26 +1071,25 @@ impl<'a> ExtCtxt<'a> {
     ) -> Result<PathBuf, DiagnosticBuilder<'a>> {
         let path = path.into();
 
+        if path.is_absolute() {
+            return Ok(path);
+        }
         // Relative paths are resolved relative to the file in which they are found
         // after macro expansion (that is, they are unhygienic).
-        if !path.is_absolute() {
-            let callsite = span.source_callsite();
-            let mut result = match self.source_map().span_to_unmapped_path(callsite) {
-                FileName::Real(name) => name.into_local_path(),
-                FileName::DocTest(path, _) => path,
-                other => {
-                    return Err(self.struct_span_err(
-                        span,
-                        &format!("cannot resolve relative path in non-file source `{}`", other),
-                    ));
-                }
-            };
-            result.pop();
-            result.push(path);
-            Ok(result)
-        } else {
-            Ok(path)
-        }
+        let callsite = span.source_callsite();
+        let mut result = match self.source_map().span_to_unmapped_path(callsite) {
+            FileName::Real(name) => name.into_local_path(),
+            FileName::DocTest(path, _) => path,
+            other => {
+                return Err(self.struct_span_err(
+                    span,
+                    &format!("cannot resolve relative path in non-file source `{}`", other),
+                ));
+            }
+        };
+        result.pop();
+        result.push(path);
+        Ok(result)
     }
 }
 

compiler/rustc_resolve/src/macros.rs

@@ -263,10 +263,10 @@ impl<'a> ResolverExpand for Resolver<'a> {
                 //   than by individual derives.
                 // - Derives in the container need to know whether one of them is a built-in `Copy`.
                 // FIXME: Try to avoid repeated resolutions for derives here and in expansion.
-                let mut exts = Vec::new();
                 let mut helper_attrs = Vec::new();
-                for path in derives {
-                    exts.push(
+                let exts = derives
+                    .iter()
+                    .map(|path| {
                         match self.resolve_macro_path(
                             path,
                             Some(MacroKind::Derive),
@@ -288,15 +288,15 @@ impl<'a> ResolverExpand for Resolver<'a> {
                                 if ext.is_derive_copy {
                                     self.containers_deriving_copy.insert(invoc_id);
                                 }
-                                ext
+                                Ok(ext)
                             }
                             Ok(_) | Err(Determinacy::Determined) => {
-                                self.dummy_ext(MacroKind::Derive)
+                                Ok(self.dummy_ext(MacroKind::Derive))
                             }
-                            Err(Determinacy::Undetermined) => return Err(Indeterminate),
-                        },
-                    )
-                }
+                            Err(Determinacy::Undetermined) => Err(Indeterminate),
+                        }
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
                 self.helper_attrs.insert(invoc_id, helper_attrs);
                 return Ok(InvocationRes::DeriveContainer(exts));
             }

compiler/rustc_typeck/src/astconv/generics.rs

@@ -347,13 +347,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         seg: &hir::PathSegment<'_>,
         is_method_call: bool,
     ) -> GenericArgCountResult {
-        let empty_args = hir::GenericArgs::none();
         let suppress_mismatch = Self::check_impl_trait(tcx, seg, &def);
         Self::check_generic_arg_count(
             tcx,
             span,
             def,
-            if let Some(ref args) = seg.args { args } else { &empty_args },
+            seg.args.unwrap_or(&hir::GenericArgs::none()),
             if is_method_call { GenericArgPosition::MethodCall } else { GenericArgPosition::Value },
             def.parent.is_none() && def.has_self, // `has_self`
             seg.infer_args || suppress_mismatch,  // `infer_args`