Improve vector usages and avoid copies.

Several place built an object before copying it in a vector. This commit
favorise in place construction and use readily available vector size to
reserve memory beforehand.

gcc/rust/ChangeLog:

	* ast/rust-expr.h (struct TupleClobber): Add constructor.
	* backend/rust-compile-context.h (struct fncontext): Likewise.
	* typecheck/rust-hir-dot-operator.h: Likewise.
	* typecheck/rust-tyty-variance-analysis-private.h (struct Constraint):
	Likewise.
	* typecheck/rust-unify.h: Likewise.
	* ast/rust-ast-builder.cc (Builder::new_lifetime_param): Add memory
	reservation and construct in place.
	(Builder::new_generic_args): Likewise.
	* ast/rust-ast-collector.cc (TokenCollector::newline): Likewise.
	(TokenCollector::indentation): Likewise.
	(TokenCollector::comment): Likewise.
	* ast/rust-desugar-apit.cc: Likewise.
	* ast/rust-path.cc (Path::convert_to_simple_path): Likewise.
	(TypePath::as_simple_path): Likewise.
	* ast/rust-path.h: Likewise.
	* backend/rust-compile-type.cc (TyTyResolveCompile::visit): Likewise.
	(TyTyResolveCompile::create_dyn_obj_record): Likewise.
	* checks/errors/rust-hir-pattern-analysis.cc (Matrix::specialize):
	Likewise.
	(WitnessMatrix::apply_constructor): Likewise.
	(check_match_usefulness): Likewise.
	* expand/rust-derive-clone.cc (DeriveClone::clone_fn): Likewise.
	* expand/rust-macro-builtins-asm.cc (parse_clobber_abi): Likewise.
	* expand/rust-macro-expand.cc (MacroExpander::parse_proc_macro_output):
	Likewise.
	* hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_generic_args):
	Likewise.
	(ASTLoweringBase::lower_extern_block): Likewise.
	* hir/rust-ast-lower-enumitem.h: Likewise.
	* hir/rust-ast-lower-expr.cc (ASTLoweringExpr::visit): Likewise.
	* hir/rust-ast-lower-extern.h: Likewise.
	* hir/rust-ast-lower-implitem.cc (ASTLowerImplItem::visit): Likewise.
	(ASTLowerTraitItem::visit): Likewise.
	* hir/rust-ast-lower-item.cc (ASTLoweringItem::visit): Likewise.
	* hir/rust-ast-lower-pattern.cc (ASTLoweringPattern::visit): Likewise.
	* hir/rust-ast-lower.cc (ASTLowering::go): Likewise.
	(ASTLoweringBlock::visit): Likewise.
	(ASTLoweringIfLetBlock::desugar_iflet): Likewise.
	(ASTLoweringExprWithBlock::visit): Likewise.
	(ASTLowerPathInExpression::visit): Likewise.
	(ASTLowerQualPathInExpression::visit): Likewise.
	* hir/tree/rust-hir.cc (PathPattern::convert_to_simple_path): Likewise.
	(TypePath::as_simple_path): Likewise.
	* metadata/rust-export-metadata.cc (ExportContext::emit_function):
	Likewise.
	* parse/rust-parse-impl.h (Parser::parse_decl_macro_def): Likewise.
	(Parser::parse_lifetime_params): Likewise.
	* resolve/rust-ast-resolve-item.cc (ResolveTraitItems::visit):
	Likewise.
	(ResolveItem::visit): Likewise.
	(flatten_list): Likewise.
	* resolve/rust-ast-resolve-pattern.cc (PatternDeclaration::visit):
	Likewise.
	* typecheck/rust-autoderef.cc (AutoderefCycle::try_autoderefed):
	Likewise.
	* typecheck/rust-coercion.cc (TypeCoercionRules::coerce_unsized):
	Likewise.
	* typecheck/rust-hir-dot-operator.cc: Likewise.
	* typecheck/rust-hir-path-probe.cc: Likewise.
	* typecheck/rust-hir-trait-resolve.cc (TraitResolver::resolve_trait):
	Likewise.
	* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit):
	Likewise.
	(TypeCheckExpr::resolve_fn_trait_call): Likewise.
	* typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit):
	Likewise.
	(TypeCheckImplItem::visit): Likewise.
	* typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit):
	Likewise.
	* typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::visit):
	Likewise.
	* typecheck/rust-hir-type-check-struct.cc (TypeCheckStructExpr::resolve):
	Likewise.
	* typecheck/rust-hir-type-check-type.cc (TypeCheckType::visit):
	Likewise.
	* typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn):
	Likewise.
	* typecheck/rust-typecheck-context.cc (TypeCheckContext::push_return_type):
	Likewise.
	(TypeCheckContext::insert_associated_impl_mapping): Likewise.
	* typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): Likewise.
	(TypeBoundsProbe::add_trait_bound): Likewise.
	(TypeBoundPredicate::operator=): Likewise.
	(TypeBoundPredicateItem::get_tyty_for_receiver): Likewise.
	(TypeBoundPredicate::get_associated_type_items): Likewise.
	* typecheck/rust-tyty-call.cc (TypeCheckMethodCallExpr::go): Likewise.
	* typecheck/rust-tyty-subst.cc (SubstitutionRef::clone_substs):
	Likewise.
	(SubstitutionRef::infer_substitions): Likewise.
	(SubstitutionRef::are_mappings_bound): Likewise.
	* typecheck/rust-tyty-variance-analysis.cc (GenericTyPerCrateCtx::query_generic_variance):
	Likewise.
	(GenericTyVisitorCtx::add_constraint): Likewise.
	* typecheck/rust-tyty.cc (FnPtr::clone): Likewise.
	(DynamicObjectType::get_object_items): Likewise.
	* typecheck/rust-unify.cc (UnifyRules::Resolve): Likewise.
	(UnifyRules::go): Likewise.
	(UnifyRules::expect_tuple): Likewise.
	* util/rust-canonical-path.h: Likewise.
	* util/rust-token-converter.cc (convert): Likewise.

Signed-off-by: Pierre-Emmanuel Patry <[email protected]>

Author: P-E-P

gcc/rust/ast/rust-ast-builder.cc

@@ -554,12 +554,12 @@ std::unique_ptr<GenericParam>
 Builder::new_lifetime_param (LifetimeParam &param)
 {
   Lifetime l = new_lifetime (param.get_lifetime ());
+
   std::vector<Lifetime> lifetime_bounds;
+  lifetime_bounds.reserve (param.get_lifetime_bounds ().size ());
+
   for (auto b : param.get_lifetime_bounds ())
-    {
-      Lifetime bl = new_lifetime (b);
-      lifetime_bounds.push_back (bl);
-    }
+    lifetime_bounds.emplace_back (new_lifetime (b));
 
   auto p = new LifetimeParam (l, std::move (lifetime_bounds),
 			      param.get_outer_attrs (), param.get_locus ());
@@ -605,11 +605,11 @@ Builder::new_type_param (
 	    for (const auto &lifetime : tb.get_for_lifetimes ())
 	      {
 		std::vector<Lifetime> lifetime_bounds;
+		lifetime_bounds.reserve (
+		  lifetime.get_lifetime_bounds ().size ());
+
 		for (const auto &b : lifetime.get_lifetime_bounds ())
-		  {
-		    Lifetime bl = new_lifetime (b);
-		    lifetime_bounds.push_back (std::move (bl));
-		  }
+		  lifetime_bounds.emplace_back (new_lifetime (b));
 
 		Lifetime nl = new_lifetime (lifetime.get_lifetime ());
 		LifetimeParam p (std::move (nl), std::move (lifetime_bounds),
@@ -626,12 +626,11 @@ Builder::new_type_param (
 		    {
 		      const TypePathSegment &segment
 			= (const TypePathSegment &) (*seg.get ());
-		      TypePathSegment *s = new TypePathSegment (
+
+		      segments.emplace_back (new TypePathSegment (
 			segment.get_ident_segment (),
 			segment.get_separating_scope_resolution (),
-			segment.get_locus ());
-		      std::unique_ptr<TypePathSegment> sg (s);
-		      segments.push_back (std::move (sg));
+			segment.get_locus ()));
 		    }
 		    break;
 
@@ -642,11 +641,10 @@ Builder::new_type_param (
 
 		      GenericArgs args
 			= new_generic_args (generic.get_generic_args ());
-		      TypePathSegmentGeneric *s = new TypePathSegmentGeneric (
+
+		      segments.emplace_back (new TypePathSegmentGeneric (
 			generic.get_ident_segment (), false, std::move (args),
-			generic.get_locus ());
-		      std::unique_ptr<TypePathSegment> sg (s);
-		      segments.push_back (std::move (sg));
+			generic.get_locus ()));
 		    }
 		    break;
 
@@ -664,23 +662,19 @@ Builder::new_type_param (
 	    TypePath p (std::move (segments), path.get_locus (),
 			path.has_opening_scope_resolution_op ());
 
-	    TraitBound *b = new TraitBound (std::move (p), tb.get_locus (),
-					    tb.is_in_parens (),
-					    tb.has_opening_question_mark (),
-					    std::move (for_lifetimes));
-	    std::unique_ptr<TypeParamBound> bound (b);
-	    type_param_bounds.push_back (std::move (bound));
+	    type_param_bounds.emplace_back (new TraitBound (
+	      std::move (p), tb.get_locus (), tb.is_in_parens (),
+	      tb.has_opening_question_mark (), std::move (for_lifetimes)));
 	  }
 	  break;
 
 	case TypeParamBound::TypeParamBoundType::LIFETIME:
 	  {
 	    const Lifetime &l = (const Lifetime &) *b.get ();
 
-	    auto bl = new Lifetime (l.get_lifetime_type (),
-				    l.get_lifetime_name (), l.get_locus ());
-	    std::unique_ptr<TypeParamBound> bound (bl);
-	    type_param_bounds.push_back (std::move (bound));
+	    type_param_bounds.emplace_back (
+	      new Lifetime (l.get_lifetime_type (), l.get_lifetime_name (),
+			    l.get_locus ()));
 	  }
 	  break;
 	}
@@ -709,18 +703,14 @@ Builder::new_generic_args (GenericArgs &args)
   location_t locus = args.get_locus ();
 
   for (const auto &lifetime : args.get_lifetime_args ())
-    {
-      Lifetime l = new_lifetime (lifetime);
-      lifetime_args.push_back (std::move (l));
-    }
+    lifetime_args.push_back (new_lifetime (lifetime));
 
   for (auto &binding : args.get_binding_args ())
     {
       Type &t = *binding.get_type_ptr ().get ();
       std::unique_ptr<Type> ty = t.reconstruct ();
-      GenericArgsBinding b (binding.get_identifier (), std::move (ty),
-			    binding.get_locus ());
-      binding_args.push_back (std::move (b));
+      binding_args.emplace_back (binding.get_identifier (), std::move (ty),
+				 binding.get_locus ());
     }
 
   for (auto &arg : args.get_generic_args ())

gcc/rust/ast/rust-ast-collector.cc

@@ -76,13 +76,13 @@ TokenCollector::trailing_comma ()
 void
 TokenCollector::newline ()
 {
-  tokens.push_back ({CollectItem::Kind::Newline});
+  tokens.emplace_back (CollectItem::Kind::Newline);
 }
 
 void
 TokenCollector::indentation ()
 {
-  tokens.push_back ({indent_level});
+  tokens.emplace_back (indent_level);
 }
 
 void
@@ -101,7 +101,7 @@ TokenCollector::decrement_indentation ()
 void
 TokenCollector::comment (std::string comment)
 {
-  tokens.push_back ({comment});
+  tokens.emplace_back (comment);
 }
 
 void

gcc/rust/ast/rust-desugar-apit.cc

@@ -188,16 +188,19 @@ class DesugarApitType : public DefaultASTVisitor
 
     // Convert to TypePath by creating path segments
     std::vector<std::unique_ptr<TypePathSegment>> segments;
-    segments.push_back (std::unique_ptr<TypePathSegment> (new TypePathSegment (
-      PathIdentSegment (ident.as_string (), type.get_locus ()), false,
-      type.get_locus ())));
+    segments.emplace_back (
+      new TypePathSegment (PathIdentSegment (ident.as_string (),
+					     type.get_locus ()),
+			   false, type.get_locus ()));
 
     // Create TypePath from segments
     auto type_path
       = new TypePath (std::move (segments), type.get_locus (), false);
 
     // Convert bounds from impl trait to generic parameter bounds
     std::vector<std::unique_ptr<TypeParamBound>> bounds;
+    bounds.reserve (type.get_type_param_bounds ().size ());
+
     for (auto &bound : type.get_type_param_bounds ())
       bounds.push_back (bound->clone_type_param_bound ());
 
@@ -228,9 +231,10 @@ class DesugarApitType : public DefaultASTVisitor
 
     // Convert to TypePath by creating path segments
     std::vector<std::unique_ptr<TypePathSegment>> segments;
-    segments.push_back (std::unique_ptr<TypePathSegment> (new TypePathSegment (
-      PathIdentSegment (ident.as_string (), type.get_locus ()), false,
-      type.get_locus ())));
+    segments.emplace_back (
+      new TypePathSegment (PathIdentSegment (ident.as_string (),
+					     type.get_locus ()),
+			   false, type.get_locus ()));
 
     // Create TypePath from segments
     auto type_path
@@ -407,6 +411,9 @@ class ApitBoundProcessor
 
 		  std::vector<std::unique_ptr<TypeParamBound>>
 		    type_param_bounds;
+		  type_param_bounds.reserve (
+		    tp.get_type_param_bounds ().size ());
+
 		  for (auto &b : tp.get_type_param_bounds ())
 		    type_param_bounds.push_back (std::move (b));
 		  tp.get_type_param_bounds ().clear ();
@@ -459,9 +466,10 @@ class ApitBoundProcessor
     std::vector<SimplePathSegment> simple_segs = {simple_seg};
     auto simple_path = SimplePath (simple_segs, false, ident.get_locus ());
     std::vector<std::unique_ptr<TypePathSegment>> segments;
-    segments.push_back (std::unique_ptr<TypePathSegment> (new TypePathSegment (
-      PathIdentSegment (ident.as_string (), ident.get_locus ()), false,
-      ident.get_locus ())));
+    segments.emplace_back (
+      new TypePathSegment (PathIdentSegment (ident.as_string (),
+					     ident.get_locus ()),
+			   false, ident.get_locus ()));
     auto type_path = new TypePath (std::move (segments), ident.get_locus ());
     return std::unique_ptr<Type> (type_path);
   }

gcc/rust/ast/rust-expr.h

@@ -5494,6 +5494,8 @@ struct InlineAsmTemplatePiece
 
 struct TupleClobber
 {
+  TupleClobber (std::string symbol, location_t loc) : symbol (symbol), loc (loc)
+  {}
   // as gccrs still doesn't contain a symbol class I have put them as strings
   std::string symbol;
   location_t loc;

gcc/rust/ast/rust-path.cc

@@ -173,8 +173,8 @@ Path::convert_to_simple_path (bool with_opening_scope_resolution) const
 
       // create segment and add to vector
       std::string segment_str = segment.as_string ();
-      simple_segments.push_back (
-	SimplePathSegment (std::move (segment_str), segment.get_locus ()));
+      simple_segments.emplace_back (std::move (segment_str),
+				    segment.get_locus ());
     }
 
   // kind of a HACK to get locus depending on opening scope resolution
@@ -258,8 +258,8 @@ TypePath::as_simple_path () const
 
       // create segment and add to vector
       std::string segment_str = segment->as_string ();
-      simple_segments.push_back (
-	SimplePathSegment (std::move (segment_str), segment->get_locus ()));
+      simple_segments.emplace_back (std::move (segment_str),
+				    segment->get_locus ());
     }
 
   return SimplePath (std::move (simple_segments), has_opening_scope_resolution,

gcc/rust/ast/rust-path.h

@@ -448,9 +448,7 @@ struct GenericArgs
     generic_args.clear ();
     generic_args.reserve (other.generic_args.size ());
     for (const auto &arg : other.generic_args)
-      {
-	generic_args.push_back (GenericArg (arg));
-      }
+      generic_args.emplace_back (arg);
   }
 
   ~GenericArgs () = default;
@@ -465,9 +463,7 @@ struct GenericArgs
     generic_args.clear ();
     generic_args.reserve (other.generic_args.size ());
     for (const auto &arg : other.generic_args)
-      {
-	generic_args.push_back (GenericArg (arg));
-      }
+      generic_args.emplace_back (arg);
 
     return *this;
   }

gcc/rust/backend/rust-compile-context.h

@@ -34,6 +34,10 @@ namespace Compile {
 
 struct fncontext
 {
+  fncontext (tree fndecl, ::Bvariable *ret_addr, TyTy::BaseType *retty)
+    : fndecl (fndecl), ret_addr (ret_addr), retty (retty)
+  {}
+
   tree fndecl;
   ::Bvariable *ret_addr;
   TyTy::BaseType *retty;
@@ -154,7 +158,7 @@ class Context
     if (it == mono_fns.end ())
       mono_fns[dId] = {};
 
-    mono_fns[dId].push_back ({ref, fn});
+    mono_fns[dId].emplace_back (ref, fn);
   }
 
   void insert_closure_decl (const TyTy::ClosureType *ref, tree fn)
@@ -164,7 +168,7 @@ class Context
     if (it == mono_closure_fns.end ())
       mono_closure_fns[dId] = {};
 
-    mono_closure_fns[dId].push_back ({ref, fn});
+    mono_closure_fns[dId].emplace_back (ref, fn);
   }
 
   tree lookup_closure_decl (const TyTy::ClosureType *ref)
@@ -279,7 +283,7 @@ class Context
 
   void push_fn (tree fn, ::Bvariable *ret_addr, TyTy::BaseType *retty)
   {
-    fn_stack.push_back (fncontext{fn, ret_addr, retty});
+    fn_stack.emplace_back (fn, ret_addr, retty);
   }
   void pop_fn () { fn_stack.pop_back (); }