Tighten low-verbosity diagnostics name deduction logic

Specifically, don't try to derive low-verbosity name from what looks like an
eval context of a function call.

3 files changed, 61 insertions, 4 deletions

diff --git a/libbuild2/build/script/parser.cxx b/libbuild2/build/script/parser.cxx
index 8759cdf..788a782 100644
--- a/libbuild2/build/script/parser.cxx
+++ b/libbuild2/build/script/parser.cxx
@@ -807,10 +807,48 @@ namespace build2
           //
           // This is also the reason why we add a diag frame.
           //
+          // The problem turned out to be worse than originally thought: we
+          // may call a function (for example, as part of if) with invalid
+          // arguments. And this could happen in the depdb preamble, which
+          // means we cannot fix this by moving the depdb builtin (which must
+          // come after the preamble). So let's peek at what's ahead and omit
+          // the expansion if it's anything iffy, namely, eval context or
+          // function call.
+          //
+          bool skip_diag (false);
           if (pre_parse_ && diag_weight_ != 4)
           {
-            pre_parse_ = false; // Make parse_names() perform expansions.
-            pre_parse_suspended_ = true;
+            // Based on the buildfile expansion parsing logic.
+            //
+            if (tt == type::lparen) // Evaluation context.
+              skip_diag = true;
+            else if (tt == type::dollar)
+            {
+              type ptt (peek (lexer_mode::variable));
+
+              if (!peeked ().separated)
+              {
+                if (ptt == type::lparen)
+                {
+                  // While strictly speaking this can also be a function call,
+                  // this is highly unusual and we will assume it's a variable
+                  // expansion.
+                }
+                else if (ptt == type::word)
+                {
+                  pair<char, bool> r (lexer_->peek_char ());
+
+                  if (r.first == '(' && !r.second) // Function call.
+                    skip_diag = true;
+                }
+              }
+            }
+
+            if (!skip_diag)
+            {
+              pre_parse_ = false; // Make parse_names() perform expansions.
+              pre_parse_suspended_ = true;
+            }
           }
 
           auto df = make_diag_frame (
@@ -838,7 +876,7 @@ namespace build2
             pre_parse_ = true;
           }
 
-          if (pre_parse_ && diag_weight_ == 4)
+          if (pre_parse_ && (diag_weight_ == 4 || skip_diag))
             return nullopt;
         }
 
diff --git a/libbuild2/lexer.cxx b/libbuild2/lexer.cxx
index 992e5d1..76c31be 100644
--- a/libbuild2/lexer.cxx
+++ b/libbuild2/lexer.cxx
@@ -42,6 +42,22 @@ namespace build2
     return make_pair (make_pair (r[0], r[1]), sep_);
   }
 
+  pair<char, bool> lexer::
+  peek_char ()
+  {
+    auto p (skip_spaces ());
+    assert (!p.second);
+    sep_ = p.first;
+
+    char r ('\0');
+
+    xchar c (peek ());
+    if (!eos (c))
+      r = c;
+
+    return make_pair (r, sep_);
+  }
+
   void lexer::
   mode (lexer_mode m, char ps, optional<const char*> esc, uintptr_t data)
   {
diff --git a/libbuild2/lexer.hxx b/libbuild2/lexer.hxx
index 148666e..78d35d7 100644
--- a/libbuild2/lexer.hxx
+++ b/libbuild2/lexer.hxx
@@ -175,7 +175,7 @@ namespace build2
     virtual token
     next ();
 
-    // Peek at the first two characters of the next token(s). Return the
+    // Peek at the first one/two characters of the next token(s). Return the
     // characters or '\0' if either would be eos. Also return an indicator of
     // whether the next token would be separated. Note: cannot be used to peek
     // at the first character of a line.
@@ -184,6 +184,9 @@ namespace build2
     // mode in which these characters will actually be parsed use the same
     // whitespace separation (the sep_space and sep_newline values).
     //
+    pair<char, bool>
+    peek_char ();
+
     pair<pair<char, char>, bool>
     peek_chars ();