1 files changed, 43 insertions, 11 deletions

diff --git a/libbuild2/build/script/script.cxx b/libbuild2/build/script/script.cxx
index b230ca5..0d96cc3 100644
--- a/libbuild2/build/script/script.cxx
+++ b/libbuild2/build/script/script.cxx
@@ -7,6 +7,8 @@
 
 #include <libbuild2/target.hxx>
 
+#include <libbuild2/adhoc-rule-buildscript.hxx> // include_unmatch*
+
 #include <libbuild2/script/timeout.hxx>
 
 #include <libbuild2/build/script/parser.hxx>
@@ -28,18 +30,20 @@ namespace build2
       environment::
       environment (action a,
                    const target_type& t,
+                   const scope_type& s,
                    bool temp,
                    const optional<timestamp>& dl)
           : build2::script::environment (
               t.ctx,
-              cast<target_triplet> (t.ctx.global_scope["build.host"]),
+              *t.ctx.build_host,
               dir_name_view (&work, &wd_name),
               temp_dir.path, false /* temp_dir_keep */,
               redirect (redirect_type::none),
               redirect (redirect_type::merge, 2),
               redirect (redirect_type::pass)),
             target (t),
-            vars (context, false /* global */),
+            scope (s),
+            vars (context, false /* shared */), // Note: managed.
             var_ts (var_pool.insert (">")),
             var_ps (var_pool.insert ("<")),
             script_deadline (to_deadline (dl, false /* success */))
@@ -56,11 +60,27 @@ namespace build2
         {
           // $>
           //
+          // What should it contain for an explicit group? While it may seem
+          // that just the members should be enough (and analogous to the ad
+          // hoc case), this won't let us get the group name for diagnostics.
+          // So the group name followed by all the members seems like the
+          // logical choice.
+          //
           names ns;
-          for (const target_type* m (&target);
-               m != nullptr;
-               m = m->adhoc_member)
-            m->as_name (ns);
+
+          if (const group* g = target.is_a<group> ())
+          {
+            g->as_name (ns);
+            for (const target_type* m: g->members)
+              m->as_name (ns);
+          }
+          else
+          {
+            for (const target_type* m (&target);
+                 m != nullptr;
+                 m = m->adhoc_member)
+              m->as_name (ns);
+          }
 
           assign (var_ts) = move (ns);
         }
@@ -73,13 +93,25 @@ namespace build2
           // much sense, they could be handy to exclude certain prerequisites
           // from $< while still treating them as such, especially in rule.
           //
+          // While initially we treated update=unmatch prerequisites as
+          // implicitly ad hoc, this turned out to be not quite correct, so
+          // now we add them unless they are explicitly marked ad hoc.
+          //
           names ns;
-          for (const prerequisite_target& pt: target.prerequisite_targets[a])
+          for (const prerequisite_target& p: target.prerequisite_targets[a])
           {
             // See adhoc_buildscript_rule::execute_update_prerequisites().
             //
-            if (pt.target != nullptr && !pt.adhoc ())
-              pt.target->as_name (ns);
+            if (const target_type* pt =
+                p.target != nullptr ? (p.adhoc () ? nullptr : p.target) :
+                (p.include & adhoc_buildscript_rule::include_unmatch) != 0 &&
+                (p.include & prerequisite_target::include_adhoc) == 0      &&
+                (p.include & adhoc_buildscript_rule::include_unmatch_adhoc) == 0
+                ? reinterpret_cast<target_type*> (p.data)
+                : nullptr)
+            {
+              pt->as_name (ns);
+            }
           }
 
           assign (var_ps) = move (ns);
@@ -154,7 +186,7 @@ namespace build2
       }
 
       void environment::
-      set_variable (string&& nm,
+      set_variable (string nm,
                     names&& val,
                     const string& attrs,
                     const location& ll)
@@ -233,7 +265,7 @@ namespace build2
         // in parallel). Plus, if there is no such variable, then we cannot
         // possibly find any value.
         //
-        const variable* pvar (context.var_pool.find (n));
+        const variable* pvar (scope.var_pool ().find (n));
 
         if (pvar == nullptr)
           return lookup_type ();