Add ability to detect sole expansion in parser::parse_names()

2 files changed, 15 insertions, 7 deletions

diff --git a/libbuild2/parser.cxx b/libbuild2/parser.cxx
index 75c7e2c..d50f86f 100644
--- a/libbuild2/parser.cxx
+++ b/libbuild2/parser.cxx
@@ -5808,6 +5808,7 @@ namespace build2
 
     // Returned value NULL/type and pattern (see below).
     //
+    bool rvalue (false);
     bool vnull (false);
     const value_type* vtype (nullptr);
     optional<const target_type*> rpat;
@@ -5825,8 +5826,9 @@ namespace build2
     bool concat_quoted_first (false);
     name concat_data;
 
-    auto concat_typed = [&vnull, &vtype, &concat, &concat_data, this]
-      (value&& rhs, const location& loc)
+    auto concat_typed = [this, &vnull, &vtype,
+                         &concat, &concat_data] (value&& rhs,
+                                                 const location& loc)
     {
       // If we have no LHS yet, then simply copy value/type.
       //
@@ -6038,7 +6040,11 @@ namespace build2
         //   dir/{$str}
         //   file{$str}
         //
-        vnull = false; // A concatenation cannot produce NULL.
+
+        // A concatenation cannot produce value/NULL.
+        //
+        vnull = false;
+        rvalue = false;
 
         if (vtype != nullptr)
         {
@@ -7052,6 +7058,7 @@ namespace build2
           {
             vnull = result->null;
             vtype = result->type;
+            rvalue = true;
           }
 
           // Nothing else to do here if the result is NULL or empty.
@@ -7181,9 +7188,9 @@ namespace build2
     }
 
     if (pre_parse_)
-      assert (!vnull && vtype == nullptr && !rpat);
+      assert (!rvalue && !vnull && vtype == nullptr && !rpat);
 
-    return parse_names_result {!vnull, vtype, rpat};
+    return parse_names_result {rvalue, !vnull, vtype, rpat};
   }
 
   void parser::
diff --git a/libbuild2/parser.hxx b/libbuild2/parser.hxx
index 4cf52e9..0390e26 100644
--- a/libbuild2/parser.hxx
+++ b/libbuild2/parser.hxx
@@ -433,15 +433,16 @@ namespace build2
     // those places. Still it may make sense to look into redesigning the
     // whole thing one day.
     //
-    // Currently the only way for the result to be NULL or have a type is if
+    // Currently the only way for the result to be NULL or to have type is if
     // it is the result of a sole, unquoted variable expansion, function call,
-    // or context evaluation.
+    // or context evaluation. In these cases value is set to true.
     //
     // In the pre-parse mode no names are appended and the result is always
     // {true, nullptr, nullopt}.
     //
     struct parse_names_result
     {
+      bool value;
       bool not_null;
       const value_type* type;
       optional<const target_type*> pattern;