libexpr: move ExprConcatStrings data to Exprs::alloc

Author: Radvendii

src/libexpr/eval.cc

@@ -2030,10 +2030,10 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
     ValueType firstType = nString;
 
     // List of returned strings. References to these Values must NOT be persisted.
-    SmallTemporaryValueVector<conservativeStackReservation> values(es.size());
+    SmallTemporaryValueVector<conservativeStackReservation> values(es().size());
     Value * vTmpP = values.data();
 
-    for (auto & [i_pos, i] : es) {
+    for (auto & [i_pos, i] : es()) {
         Value & vTmp = *vTmpP++;
         i->eval(state, env, vTmp);
 
@@ -2077,7 +2077,7 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
                     .debugThrow();
         } else {
             if (strings.empty())
-                strings.reserve(es.size());
+                strings.reserve(es().size());
             /* skip canonization of first path, which would only be not
             canonized in the first place if it's coming from a ./${foo} type
             path */

src/libexpr/include/nix/expr/nixexpr.hh

@@ -760,11 +760,31 @@ struct ExprConcatStrings : Expr
 {
     PosIdx pos;
     bool forceString;
-    std::vector<std::pair<PosIdx, Expr *>> es;
-    ExprConcatStrings(const PosIdx & pos, bool forceString, std::vector<std::pair<PosIdx, Expr *>> && es)
+private:
+    uint16_t nes;
+    std::pair<PosIdx, Expr *> * esStart;
+public:
+
+    std::span<std::pair<PosIdx, Expr *>> es() const {
+        return {esStart, nes};
+    }
+
+    ExprConcatStrings(const PosTable & positions, std::pmr::polymorphic_allocator<char> & alloc, const PosIdx & pos, bool forceString, std::vector<std::pair<PosIdx, Expr *>> && es)
         : pos(pos)
         , forceString(forceString)
-        , es(std::move(es)) {};
+        , nes(es.size())
+        , esStart(alloc.allocate_object<std::pair<PosIdx, Expr *>>(es.size()))
+    {
+        if (es.size() > nes) [[unlikely]] {
+            auto err = Error(
+                "too many string concatentations, implementation supports at most %1%",
+                std::numeric_limits<decltype(nes)>::max());
+            if (pos)
+                err.atPos(positions[pos]);
+            throw err;
+        }
+        std::ranges::copy(es, esStart);
+    };
 
     PosIdx getPos() const override
     {

src/libexpr/include/nix/expr/parser-state.hh

@@ -341,7 +341,7 @@ ParserState::stripIndentation(const PosIdx pos, std::vector<std::pair<PosIdx, st
         auto * const result = (es2)[0].second;
         return result;
     }
-    return new ExprConcatStrings(pos, true, std::move(es2));
+    return new ExprConcatStrings(positions, alloc, pos, true, std::move(es2));
 }
 
 inline PosIdx LexerState::at(const ParserLocation & loc)

src/libexpr/nixexpr.cc

@@ -246,7 +246,7 @@ void ExprConcatStrings::show(const SymbolTable & symbols, std::ostream & str) co
 {
     bool first = true;
     str << "(";
-    for (auto & i : es) {
+    for (auto & i : es()) {
         if (first)
             first = false;
         else
@@ -564,7 +564,7 @@ void ExprConcatStrings::bindVars(EvalState & es, const std::shared_ptr<const Sta
     if (es.debugRepl)
         es.exprEnvs.insert(std::make_pair(this, env));
 
-    for (auto & i : this->es)
+    for (auto & i : this->es())
         i.second->bindVars(es, env);
 }
 

src/libexpr/parser.y

@@ -253,7 +253,7 @@ expr_op
   | expr_op UPDATE expr_op { $$ = new ExprOpUpdate(state->at(@2), $1, $3); }
   | expr_op '?' attrpath { $$ = new ExprOpHasAttr(state->alloc, $1, std::move($3)); }
   | expr_op '+' expr_op
-    { $$ = new ExprConcatStrings(state->at(@2), false, {{state->at(@1), $1}, {state->at(@3), $3}}); }
+    { $$ = new ExprConcatStrings(state->positions, state->alloc, state->at(@2), false, {{state->at(@1), $1}, {state->at(@3), $3}}); }
   | expr_op '-' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.sub), {$1, $3}); }
   | expr_op '*' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.mul), {$1, $3}); }
   | expr_op '/' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.div), {$1, $3}); }
@@ -309,7 +309,7 @@ expr_simple
   | path_start PATH_END
   | path_start string_parts_interpolated PATH_END {
       $2.insert($2.begin(), {state->at(@1), $1});
-      $$ = new ExprConcatStrings(CUR_POS, false, std::move($2));
+      $$ = new ExprConcatStrings(state->positions, state->alloc, CUR_POS, false, std::move($2));
   }
   | SPATH {
       std::string_view path($1.p + 1, $1.l - 2);
@@ -343,7 +343,7 @@ expr_simple
 
 string_parts
   : STR { $$ = $1; }
-  | string_parts_interpolated { $$ = new ExprConcatStrings(CUR_POS, true, std::move($1)); }
+  | string_parts_interpolated { $$ = new ExprConcatStrings(state->positions, state->alloc, CUR_POS, true, std::move($1)); }
   | { $$ = std::string_view(); }
   ;