4 files changed, 61 insertions, 10 deletions

diff --git a/libbuild2/in/init.cxx b/libbuild2/in/init.cxx
index 8bd5909..2fb73e1 100644
--- a/libbuild2/in/init.cxx
+++ b/libbuild2/in/init.cxx
@@ -34,7 +34,10 @@ namespace build2
       // Enter variables.
       //
       {
-        auto& vp (rs.var_pool ());
+        // All the variables we enter are qualified so go straight for the
+        // public variable pool.
+        //
+        auto& vp (rs.var_pool (true /* public */));
 
         // Alternative variable substitution symbol with '$' being the
         // default.
diff --git a/libbuild2/in/rule.cxx b/libbuild2/in/rule.cxx
index d07adfc..31a9d94 100644
--- a/libbuild2/in/rule.cxx
+++ b/libbuild2/in/rule.cxx
@@ -47,6 +47,13 @@ namespace build2
       if (!fi)
         l5 ([&]{trace << "no in file prerequisite for target " << t;});
 
+      // If we match, derive the file name here instead of in apply() to make
+      // it available early for the in{} prerequisite search (see
+      // install::file_rule::apply_impl() for background).
+      //
+      if (fi)
+        t.derive_path ();
+
       return fi;
     }
 
@@ -55,9 +62,9 @@ namespace build2
     {
       file& t (xt.as<file> ());
 
-      // Derive the file name.
+      // Make sure derived rules assign the path in match().
       //
-      t.derive_path ();
+      assert (!t.path ().empty ());
 
       // Inject dependency on the output directory.
       //
@@ -299,7 +306,35 @@ namespace build2
       if (verb >= 2)
         text << program_ << ' ' << ip << " >" << tp;
       else if (verb)
-        text << program_ << ' ' << ip;
+      {
+        // If we straight print the target, in most cases we will end up with
+        // something ugly like in{version...h.in} (due to the in{} target
+        // type search semantics). There is the `...h` part but also the
+        // `.in` part that is redundant given in{}. So let's tidy this up
+        // a bit if the extension could have been derived by in_search().
+        //
+        target_key ik (i.key ());
+
+        if (ik.ext)
+        {
+          string& ie (*ik.ext);
+          const string* te (t.ext ());
+
+          size_t in (ie.size ());
+          size_t tn (te != nullptr ? te->size () : 0);
+
+          if (in == tn + (tn != 0 ? 1 : 0) + 2) // [<te>.]in
+          {
+            if (ie.compare (in - 2, 2, "in") == 0)
+            {
+              if (tn == 0 || (ie.compare (0, tn, *te) == 0 && ie[tn] == '.'))
+                ie.clear ();
+            }
+          }
+        }
+
+        print_diag (program_.c_str (), move (ik), t);
+      }
 
       // Read and process the file, one line at a time, while updating depdb.
       //
diff --git a/libbuild2/in/rule.hxx b/libbuild2/in/rule.hxx
index 369fd93..67c2509 100644
--- a/libbuild2/in/rule.hxx
+++ b/libbuild2/in/rule.hxx
@@ -22,6 +22,11 @@ namespace build2
     // cache data (e.g., in match() or apply()) to be used in substitute() and
     // lookup() calls.
     //
+    // A derived rule is also required to derive the target file name in
+    // match() instead of apply() to make it available early for the in{}
+    // prerequisite search (see install::file_rule::apply_impl() for
+    // background).
+    //
     // Note also that currently this rule ignores the dry-run mode (see
     // perform_update() for the rationale).
     //
diff --git a/libbuild2/in/target.cxx b/libbuild2/in/target.cxx
index d548453..d664e3a 100644
--- a/libbuild2/in/target.cxx
+++ b/libbuild2/in/target.cxx
@@ -10,7 +10,7 @@ namespace build2
   namespace in
   {
     static const target*
-    in_search (const target& xt, const prerequisite_key& cpk)
+    in_search (context& ctx, const target* xt, const prerequisite_key& cpk)
     {
       // If we have no extension then derive it from our target. Then delegate
       // to file_search().
@@ -18,18 +18,26 @@ namespace build2
       prerequisite_key pk (cpk);
       optional<string>& e (pk.tk.ext);
 
-      if (!e)
+      if (!e && xt != nullptr)
       {
-        if (const file* t = xt.is_a<file> ())
+        // Why is the extension, say, .h.in and not .in (with .h being in the
+        // name)? While this is mostly academic (in this case things will work
+        // the same either way), conceptually, it is a header template rather
+        // than some file template. In other words, we are adding the second
+        // level classification.
+        //
+        // See also the low verbosity tidying up code in the rule.
+        //
+        if (const file* t = xt->is_a<file> ())
         {
           const string& te (t->derive_extension ());
           e = te + (te.empty () ? "" : ".") + "in";
         }
         else
-          fail << "prerequisite " << pk << " for a non-file target " << xt;
+          fail << "prerequisite " << pk << " for a non-file target " << *xt;
       }
 
-      return file_search (xt, pk);
+      return file_search (ctx, xt, pk);
     }
 
     static bool
@@ -51,7 +59,7 @@ namespace build2
       &target_extension_none,
       nullptr, /* default_extension */   // Taken care of by search.
       &in_pattern,
-      &target_print_1_ext_verb,          // Same as file.
+      &target_print_1_ext_verb,          // Same as file (but see rule).
       &in_search,
       target_type::flag::none
     };