Use match options for runtime/buildtime distinction when installing libraries

Specifically, now, if a library is installed solely as a prerequisite of
an executable (potentially recursively), then only its runtime files are
installed omitting everything buildtime-related (static/import libraries,
non-versioned symlinks for shared libraries, pkg-config files, headers,
etc). If you are familiar with the runtime and -dev/-devel package splits
for libraries in Debian/Fedora, this is an analogous semantics.

3 files changed, 393 insertions, 67 deletions

diff --git a/libbuild2/cc/install-rule.cxx b/libbuild2/cc/install-rule.cxx
index 3eaaa94..7327711 100644
--- a/libbuild2/cc/install-rule.cxx
+++ b/libbuild2/cc/install-rule.cxx
@@ -24,14 +24,58 @@ namespace build2
     install_rule (data&& d, const link_rule& l)
         : common (move (d)), link_ (l) {}
 
-    const target* install_rule::
+    // Wrap the file_rule's recipe into a data-carrying recipe.
+    //
+    struct install_match_data
+    {
+      build2::recipe        recipe;
+      uint64_t              options; // Match options.
+      link_rule::libs_paths libs_paths;
+
+      target_state
+      operator() (action a, const target& t)
+      {
+        return recipe (a, t);
+      }
+    };
+
+    bool install_rule::
+    filter (action a, const target& t, const target& m) const
+    {
+      if (!t.is_a<exe> ())
+      {
+        // If runtime-only, filter out all known buildtime target types.
+        //
+        const auto& md (t.data<install_match_data> (a));
+
+        if ((md.options & lib::option_install_buildtime) == 0)
+        {
+          if (m.is_a<liba> () || // Staic library.
+              m.is_a<pc> ()   || // pkg-config file.
+              m.is_a<libi> ())   // Import library.
+            return false;
+        }
+      }
+
+      return true;
+    }
+
+    pair<const target*, uint64_t> install_rule::
     filter (const scope* is,
-            action a, const target& t, prerequisite_iterator& i) const
+            action a, const target& t, prerequisite_iterator& i,
+            match_extra& me) const
     {
       // NOTE: see libux_install_rule::filter() if changing anything here.
 
       const prerequisite& p (i->prerequisite);
 
+      uint64_t options (match_extra::all_options);
+
+      otype ot (link_type (t).type);
+
+      // @@ TMP: drop eventually.
+      //
+#if 0
       // If this is a shared library prerequisite, install it as long as it is
       // in the installation scope.
       //
@@ -43,7 +87,6 @@ namespace build2
       //
       // Note: we install ad hoc prerequisites by default.
       //
-      otype ot (link_type (t).type);
 
       // Note: at least one must be true since we only register this rule for
       // exe{}, and lib[as]{} (this makes sure the following if-condition will
@@ -64,26 +107,115 @@ namespace build2
         if (const libx* l = pt->is_a<libx> ())
           pt = link_member (*l, a, link_info (t.base_scope (), ot));
 
-        // Note: not redundant since we are returning a member.
+        // Note: not redundant since we could be returning a member.
         //
         if ((st && pt->is_a<libs> ()) || (at && pt->is_a<liba> ()))
-          return is == nullptr || pt->in (*is) ? pt : nullptr;
+        {
+          // Adjust match options.
+          //
+          if (a.operation () != update_id)
+          {
+            if (t.is_a<exe> ())
+              options = lib::option_install_runtime;
+            else
+            {
+              // This is a library prerequisite of a library target and
+              // runtime-only begets runtime-only.
+              //
+              if (me.cur_options == lib::option_install_runtime)
+                options = lib::option_install_runtime;
+            }
+          }
+
+          return make_pair (is == nullptr || pt->in (*is) ? pt : nullptr,
+                            options);
+        }
 
         // See through to libu*{} members. Note that we are always in the same
         // project (and thus amalgamation).
         //
         if (pt->is_a<libux> ())
-          return pt;
+        {
+          // Adjust match options (similar to above).
+          //
+          if (a.operation () != update_id && !pt->is_a<libue> ())
+          {
+            if (t.is_a<exe> ())
+              options = lib::option_install_runtime;
+            else
+            {
+              if (me.cur_options == lib::option_install_runtime)
+                options = lib::option_install_runtime;
+            }
+          }
+
+          return make_pair (pt, options);
+        }
       }
+#else
+      // Note that at first it may seem like we don't need to install static
+      // library prerequisites of executables. But such libraries may still
+      // have prerequisites that are needed at runtime (say, some data files).
+      // So we install all libraries as long as they are in the installation
+      // scope and deal with runtime vs buildtime distiction using match
+      // options.
+      //
+      // Note: for now we assume these prerequisites never come from see-
+      // through groups.
+      //
+      // Note: we install ad hoc prerequisites by default.
+      //
+      if (p.is_a<libx> () || p.is_a<libs> () || p.is_a<liba> ())
+      {
+        const target* pt (&search (t, p));
+
+        // If this is the lib{}/libu*{} group, pick a member which we would
+        // link. For libu*{} we want the "see through" logic.
+        //
+        if (const libx* l = pt->is_a<libx> ())
+          pt = link_member (*l, a, link_info (t.base_scope (), ot));
+
+        // Adjust match options.
+        //
+        if (a.operation () != update_id)
+        {
+          if (t.is_a<exe> ())
+            options = lib::option_install_runtime;
+          else
+          {
+            // This is a library prerequisite of a library target and
+            // runtime-only begets runtime-only.
+            //
+            if (me.cur_options == lib::option_install_runtime)
+              options = lib::option_install_runtime;
+          }
+        }
+
+        // Note: not redundant since we could be returning a member.
+        //
+        if (pt->is_a<libs> () || pt->is_a<liba> ())
+        {
+          return make_pair (is == nullptr || pt->in (*is) ? pt : nullptr,
+                            options);
+        }
+        else // libua{} or libus{}
+        {
+          // See through to libu*{} members. Note that we are always in the
+          // same project (and thus amalgamation).
+          //
+          return make_pair (pt, options);
+        }
+      }
+#endif
 
       // The rest of the tests only succeed if the base filter() succeeds.
       //
-      const target* pt (file_rule::filter (is, a, t, p));
+      const target* pt (file_rule::filter (is, a, t, p, me).first);
       if (pt == nullptr)
-        return pt;
+        return make_pair (pt, options);
 
-      // Don't install executable's prerequisite headers and module
-      // interfaces.
+      // Don't install executable's or runtime-only library's prerequisite
+      // headers and module interfaces.
       //
       // Note that if they come from a group, then we assume the entire
       // group is not to be installed.
@@ -100,7 +232,9 @@ namespace build2
                 (x_obj != nullptr && p.is_a (*x_obj)));
       };
 
-      if (t.is_a<exe> ())
+      if (t.is_a<exe> () ||
+          (a.operation () != update_id &&
+           me.cur_options == lib::option_install_runtime))
       {
         if (header_source (p))
           pt = nullptr;
@@ -115,7 +249,7 @@ namespace build2
         }
 
         if (pt == nullptr)
-          return pt;
+          return make_pair (pt, options);
       }
 
       // Here is a problem: if the user spells the obj*/bmi*{} targets
@@ -145,16 +279,16 @@ namespace build2
           {
             pt = t.is_a<exe> ()
               ? nullptr
-              : file_rule::filter (is, a, *pt, pm.prerequisite);
+              : file_rule::filter (is, a, *pt, pm.prerequisite, me).first;
             break;
           }
         }
 
         if (pt == nullptr)
-          return pt;
+          return make_pair (pt, options);
       }
 
-      return pt;
+      return make_pair (pt, options);
     }
 
     bool install_rule::
@@ -167,27 +301,34 @@ namespace build2
         file_rule::match (a, t);
     }
 
-    // Wrap the file_rule's recipe into a data-carrying recipe.
-    //
-    struct install_match_data
+    recipe install_rule::
+    apply (action a, target& t, match_extra& me) const
     {
-      build2::recipe        recipe;
-      link_rule::libs_paths libs_paths;
-
-      target_state
-      operator() (action a, const target& t)
+      // Handle match options.
+      //
+      // Do it before calling apply_impl() since we need this information
+      // in the filter() callbacks.
+      //
+      if (a.operation () != update_id)
       {
-        return recipe (a, t);
+        if (!t.is_a<exe> ())
+        {
+          if (me.new_options == 0)
+            me.new_options = lib::option_install_runtime; // Minimum we can do.
+
+          me.cur_options = me.new_options;
+        }
       }
-    };
 
-    recipe install_rule::
-    apply (action a, target& t) const
-    {
-      recipe r (file_rule::apply_impl (a, t));
+      recipe r (file_rule::apply_impl (
+                  a, t, me,
+                  me.cur_options != match_extra::all_options /* reapply */));
 
       if (r == nullptr)
+      {
+        me.cur_options = match_extra::all_options; // Noop for all options.
         return noop_recipe;
+      }
 
       if (a.operation () == update_id)
       {
@@ -209,29 +350,72 @@ namespace build2
       }
       else // install or uninstall
       {
-        // Derive shared library paths and cache them in the target's aux
-        // storage if we are un/installing (used in the *_extra() functions
-        // below).
-        //
-        if (file* f = t.is_a<libs> ())
+        file* ls;
+        if ((ls = t.is_a<libs> ()) || t.is_a<liba> ())
         {
-          if (!f->path ().empty ()) // Not binless.
+          // Derive shared library paths and cache them in the target's aux
+          // storage if we are un/installing (used in the *_extra() functions
+          // below).
+          //
+          link_rule::libs_paths lsp;
+          if (ls != nullptr && !ls->path ().empty ()) // Not binless.
           {
             const string* p (cast_null<string> (t["bin.lib.prefix"]));
             const string* s (cast_null<string> (t["bin.lib.suffix"]));
 
-            return install_match_data {
-              move (r),
-              link_.derive_libs_paths (*f,
-                                       p != nullptr ? p->c_str (): nullptr,
-                                       s != nullptr ? s->c_str (): nullptr)};
+            lsp = link_.derive_libs_paths (*ls,
+                                           p != nullptr ? p->c_str (): nullptr,
+                                           s != nullptr ? s->c_str (): nullptr);
           }
+
+          return install_match_data {move (r), me.cur_options, move (lsp)};
         }
       }
 
       return r;
     }
 
+    void install_rule::
+    reapply (action a, target& t, match_extra& me) const
+    {
+      tracer trace ("cc::install_rule::reapply");
+
+      assert (a.operation () != update_id && !t.is_a<exe> ());
+
+      l6 ([&]{trace << "rematching " << t
+                    << ", current options " << me.cur_options
+                    << ", new options " << me.new_options;});
+
+      me.cur_options |= me.new_options;
+
+      // We also need to update options in install_match_data.
+      //
+      t.data<install_match_data> (a).options = me.cur_options;
+
+      if ((me.new_options & lib::option_install_buildtime) != 0)
+      {
+        // If we are rematched with the buildtime option, propagate it to our
+        // prerequisite libraries.
+        //
+        for (const target* pt: t.prerequisite_targets[a])
+        {
+          if (pt != nullptr && (pt->is_a<liba> ()  || pt->is_a<libs> () ||
+                                pt->is_a<libua> () || pt->is_a<libus> ()))
+          {
+            // Go for all options instead of just install_buildtime to avoid
+            // any further relocking/reapply (we only support runtime-only or
+            // everything).
+            //
+            rematch_sync (a, *pt, match_extra::all_options);
+          }
+        }
+
+        // Also match any additional prerequisites (e.g., headers).
+        //
+        file_rule::reapply_impl (a, t, me);
+      }
+    }
+
     bool install_rule::
     install_extra (const file& t, const install_dir& id) const
     {
@@ -239,10 +423,15 @@ namespace build2
 
       if (t.is_a<libs> ())
       {
+        const auto& md (t.data<install_match_data> (perform_install_id));
+
         // Here we may have a bunch of symlinks that we need to install.
         //
+        // Note that for runtime-only install we only omit the name that is
+        // used for linking (e.g., libfoo.so).
+        //
         const scope& rs (t.root_scope ());
-        auto& lp (t.data<install_match_data> (perform_install_id).libs_paths);
+        const link_rule::libs_paths& lp (md.libs_paths);
 
         auto ln = [&t, &rs, &id] (const path& f, const path& l)
         {
@@ -260,7 +449,10 @@ namespace build2
         if (!in.empty ()) {r = ln (*f, in) || r; f = &in;}
         if (!so.empty ()) {r = ln (*f, so) || r; f = &so;}
         if (!ld.empty ()) {r = ln (*f, ld) || r; f = &ld;}
-        if (!lk.empty ()) {r = ln (*f, lk) || r;         }
+        if ((md.options & lib::option_install_buildtime) != 0)
+        {
+          if (!lk.empty ()) {r = ln (*f, lk) || r;}
+        }
       }
 
       return r;
@@ -273,10 +465,12 @@ namespace build2
 
       if (t.is_a<libs> ())
       {
+        const auto& md (t.data<install_match_data> (perform_uninstall_id));
+
         // Here we may have a bunch of symlinks that we need to uninstall.
         //
         const scope& rs (t.root_scope ());
-        auto& lp (t.data<install_match_data> (perform_uninstall_id).libs_paths);
+        const link_rule::libs_paths& lp (md.libs_paths);
 
         auto rm = [&rs, &id] (const path& f, const path& l)
         {
@@ -293,7 +487,10 @@ namespace build2
         if (!in.empty ()) {r = rm (*f, in) || r; f = &in;}
         if (!so.empty ()) {r = rm (*f, so) || r; f = &so;}
         if (!ld.empty ()) {r = rm (*f, ld) || r; f = &ld;}
-        if (!lk.empty ()) {r = rm (*f, lk) || r;         }
+        if ((md.options & lib::option_install_buildtime) != 0)
+        {
+          if (!lk.empty ()) {r = rm (*f, lk) || r;}
+        }
       }
 
       return r;
@@ -305,20 +502,27 @@ namespace build2
     libux_install_rule (data&& d, const link_rule& l)
         : common (move (d)), link_ (l) {}
 
-    const target* libux_install_rule::
+    pair<const target*, uint64_t> libux_install_rule::
     filter (const scope* is,
-            action a, const target& t, prerequisite_iterator& i) const
+            action a, const target& t, prerequisite_iterator& i,
+            match_extra& me) const
     {
       using file_rule = install::file_rule;
 
       const prerequisite& p (i->prerequisite);
 
+      uint64_t options (match_extra::all_options);
+
+      otype ot (link_type (t).type);
+
       // The "see through" semantics that should be parallel to install_rule
       // above. In particular, here we use libue/libua/libus{} as proxies for
       // exe/liba/libs{} there.
       //
-      otype ot (link_type (t).type);
 
+      // @@ TMP: drop eventually.
+      //
+#if 0
       bool st (t.is_a<libue> () || t.is_a<libus> ()); // Target needs shared.
       bool at (t.is_a<libua> () || t.is_a<libus> ()); // Target needs static.
       assert (st || at);
@@ -332,15 +536,70 @@ namespace build2
           pt = link_member (*l, a, link_info (t.base_scope (), ot));
 
         if ((st && pt->is_a<libs> ()) || (at && pt->is_a<liba> ()))
-          return is == nullptr || pt->in (*is) ? pt : nullptr;
+        {
+          if (a.operation () != update_id)
+          {
+            if (t.is_a<libue> ())
+              options = lib::option_install_runtime;
+            else
+            {
+              if (me.cur_options == lib::option_install_runtime)
+                options = lib::option_install_runtime;
+            }
+          }
+
+          return make_pair (is == nullptr || pt->in (*is) ? pt : nullptr,
+                            options);
+        }
 
         if (pt->is_a<libux> ())
-          return pt;
+        {
+          if (a.operation () != update_id && !pt->is_a<libue> ())
+          {
+            if (t.is_a<libue> ())
+              options = lib::option_install_runtime;
+            else
+            {
+              if (me.cur_options == lib::option_install_runtime)
+                options = lib::option_install_runtime;
+            }
+          }
+
+          return make_pair (pt, options);
+        }
+      }
+#else
+      if (p.is_a<libx> () || p.is_a<libs> () || p.is_a<liba> ())
+      {
+        const target* pt (&search (t, p));
+
+        if (const libx* l = pt->is_a<libx> ())
+          pt = link_member (*l, a, link_info (t.base_scope (), ot));
+
+        if (a.operation () != update_id)
+        {
+          if (t.is_a<libue> ())
+            options = lib::option_install_runtime;
+          else
+          {
+            if (me.cur_options == lib::option_install_runtime)
+              options = lib::option_install_runtime;
+          }
+        }
+
+        if (pt->is_a<libs> () || pt->is_a<liba> ())
+        {
+          return make_pair (is == nullptr || pt->in (*is) ? pt : nullptr,
+                            options);
+        }
+        else
+          return make_pair (pt, options);
       }
+#endif
 
-      const target* pt (file_rule::instance.filter (is, a, t, p));
+      const target* pt (file_rule::instance.filter (is, a, t, p, me).first);
       if (pt == nullptr)
-        return pt;
+        return make_pair (pt, options);
 
       auto header_source = [this] (const auto& p)
       {
@@ -351,7 +610,9 @@ namespace build2
                 (x_obj != nullptr && p.is_a (*x_obj)));
       };
 
-      if (t.is_a<libue> ())
+      if (t.is_a<libue> () ||
+          (a.operation () != update_id &&
+           me.cur_options == lib::option_install_runtime))
       {
         if (header_source (p))
           pt = nullptr;
@@ -366,7 +627,7 @@ namespace build2
         }
 
         if (pt == nullptr)
-          return pt;
+          return make_pair (pt, options);
       }
 
       bool g (false);
@@ -382,16 +643,17 @@ namespace build2
           {
             pt = t.is_a<libue> ()
               ? nullptr
-              : file_rule::instance.filter (is, a, *pt, pm.prerequisite);
+              : file_rule::instance.filter (
+                  is, a, *pt, pm.prerequisite, me).first;
             break;
           }
         }
 
         if (pt == nullptr)
-          return pt;
+          return make_pair (pt, options);
       }
 
-      return pt;
+      return make_pair (pt, options);
     }
 
     bool libux_install_rule::
@@ -403,5 +665,49 @@ namespace build2
       return link_.sub_match (x_link, update_id, a, t, me) &&
         alias_rule::match (a, t);
     }
+
+    recipe libux_install_rule::
+    apply (action a, target& t, match_extra& me) const
+    {
+      if (a.operation () != update_id)
+      {
+        if (!t.is_a<libue> ())
+        {
+          if (me.new_options == 0)
+            me.new_options = lib::option_install_runtime;
+
+          me.cur_options = me.new_options;
+        }
+      }
+
+      return alias_rule::apply_impl (
+        a, t, me, me.cur_options != match_extra::all_options /* reapply */);
+    }
+
+    void libux_install_rule::
+    reapply (action a, target& t, match_extra& me) const
+    {
+      tracer trace ("cc::linux_install_rule::reapply");
+
+      assert (a.operation () != update_id && !t.is_a<libue> ());
+
+      l6 ([&]{trace << "rematching " << t
+                    << ", current options " << me.cur_options
+                    << ", new options " << me.new_options;});
+
+      me.cur_options |= me.new_options;
+
+      if ((me.new_options & lib::option_install_buildtime) != 0)
+      {
+        for (const target* pt: t.prerequisite_targets[a])
+        {
+          if (pt != nullptr && (pt->is_a<liba> ()  || pt->is_a<libs> () ||
+                                pt->is_a<libua> () || pt->is_a<libus> ()))
+            rematch_sync (a, *pt, match_extra::all_options);
+        }
+
+        alias_rule::reapply_impl (a, t, me);
+      }
+    }
   }
 }
diff --git a/libbuild2/cc/install-rule.hxx b/libbuild2/cc/install-rule.hxx
index 6998d63..9d9211b 100644
--- a/libbuild2/cc/install-rule.hxx
+++ b/libbuild2/cc/install-rule.hxx
@@ -20,7 +20,7 @@ namespace build2
   {
     class link_rule;
 
-    // Installation rule for exe{} and lib*{}. Here we do:
+    // Installation rule for exe{} and lib[as]{}. Here we do:
     //
     // 1. Signal to the link rule that this is update for install.
     //
@@ -28,17 +28,23 @@ namespace build2
     //
     // 3. Extra un/installation (e.g., libs{} symlinks).
     //
+    // 4. Handling runtime/buildtime match options for lib[as]{}.
+    //
     class LIBBUILD2_CC_SYMEXPORT install_rule: public install::file_rule,
                                                virtual common
     {
     public:
       install_rule (data&&, const link_rule&);
 
-      virtual const target*
+      virtual bool
+      filter (action, const target&, const target&) const override;
+
+      virtual pair<const target*, uint64_t>
       filter (const scope*,
-              action, const target&, prerequisite_iterator&) const override;
+              action, const target&, prerequisite_iterator&,
+              match_extra&) const override;
 
-      // Note: rule::match() override.
+      // Note: rule::match() override (with hint and match_extra).
       //
       virtual bool
       match (action, target&, const string&, match_extra&) const override;
@@ -46,7 +52,10 @@ namespace build2
       using file_rule::match; // Make Clang happy.
 
       virtual recipe
-      apply (action, target&) const override;
+      apply (action, target&, match_extra&) const override;
+
+      virtual void
+      reapply (action, target&, match_extra&) const override;
 
       virtual bool
       install_extra (const file&, const install_dir&) const override;
@@ -58,22 +67,24 @@ namespace build2
       const link_rule& link_;
     };
 
-    // Installation rule for libu*{}.
+    // Installation rule for libu[eas]{}.
     //
     // While libu*{} members themselves are not installable, we need to see
     // through them in case they depend on stuff that we need to install
     // (e.g., headers). Note that we use the alias_rule as a base.
     //
-    class LIBBUILD2_CC_SYMEXPORT libux_install_rule:
-      public install::alias_rule,
-      virtual common
+    class LIBBUILD2_CC_SYMEXPORT libux_install_rule: public install::alias_rule,
+                                                     virtual common
     {
     public:
       libux_install_rule (data&&, const link_rule&);
 
-      virtual const target*
+      // Note: utility libraries currently have no ad hoc members.
+
+      virtual pair<const target*, uint64_t>
       filter (const scope*,
-              action, const target&, prerequisite_iterator&) const override;
+              action, const target&, prerequisite_iterator&,
+              match_extra&) const override;
 
       // Note: rule::match() override.
       //
@@ -82,6 +93,12 @@ namespace build2
 
       using alias_rule::match; // Make Clang happy.
 
+      virtual recipe
+      apply (action, target&, match_extra&) const override;
+
+      virtual void
+      reapply (action, target&, match_extra&) const override;
+
     private:
       const link_rule& link_;
     };
diff --git a/libbuild2/cc/module.cxx b/libbuild2/cc/module.cxx
index 40857d7..eed7db1 100644
--- a/libbuild2/cc/module.cxx
+++ b/libbuild2/cc/module.cxx
@@ -1125,6 +1125,9 @@ namespace build2
         //
         if (install_loaded)
         {
+          // Note: we rely quite heavily in these rule implementations that
+          // these are the only target types they are registered for.
+
           const install_rule&  ir (*this);
 
           r.insert<exe>  (perform_install_id,   x_install, ir);