Remove prerequisite caching in scope

We don't share them often and those that are shared (e.g., cxx{} in
obja/objs{}) are lightweight (SOO).

12 files changed, 166 insertions, 284 deletions

diff --git a/build2/algorithm.cxx b/build2/algorithm.cxx
index 22633bb..f3bb8a0 100644
--- a/build2/algorithm.cxx
+++ b/build2/algorithm.cxx
@@ -277,7 +277,7 @@ namespace build2
   void
   search_and_match_prerequisites (action a, target& t, scope* s)
   {
-    for (prerequisite p: group_prerequisites (t))
+    for (prerequisite& p: group_prerequisites (t))
     {
       target& pt (search (p));
 
diff --git a/build2/cc/link.cxx b/build2/cc/link.cxx
index e1dac16..a8b7dcb 100644
--- a/build2/cc/link.cxx
+++ b/build2/cc/link.cxx
@@ -165,7 +165,7 @@ namespace build2
             // If the prerequisite came from the lib{} group, then also
             // add it to lib's prerequisite_targets.
             //
-            if (!p.prerequisite.belongs (t))
+            if (p.prerequisite.owner != t)
               t.group->prerequisite_targets.push_back (pt);
 
             t.prerequisite_targets.push_back (pt);
@@ -487,7 +487,7 @@ namespace build2
         // @@ Why are we creating the obj{} group if the source came from a
         //    group?
         //
-        bool group (!p.prerequisite.belongs (t)); // Group's prerequisite.
+        bool group (p.prerequisite.owner != t); // Group's prerequisite.
 
         const prerequisite_key& cp (p.key ()); // C-source (X or C) key.
         const target_type& tt (group ? obj::static_type : ott);
@@ -614,7 +614,7 @@ namespace build2
         {
           // Note: add the source to the group, not the member.
           //
-          ot.prerequisites.emplace_back (p.as_prerequisite (trace));
+          ot.prerequisites.push_back (p.as_prerequisite_for (ot));
 
           // Add our lib*{} prerequisites to the object file (see the export.*
           // machinery for details).
@@ -634,7 +634,7 @@ namespace build2
           for (prerequisite& p: group_prerequisites (t))
           {
             if (p.is_a<lib> () || p.is_a<liba> () || p.is_a<libs> ())
-              ot.prerequisites.emplace_back (p);
+              ot.prerequisites.emplace_back (p, ot);
           }
 
           build2::match (a, *pt);
diff --git a/build2/cli/rule.cxx b/build2/cli/rule.cxx
index d457e6d..f5405a5 100644
--- a/build2/cli/rule.cxx
+++ b/build2/cli/rule.cxx
@@ -136,7 +136,7 @@ namespace build2
                 if (g == nullptr)
                   g = &targets.insert<cli_cxx> (t.dir, t.out, t.name, trace);
 
-                g->prerequisites.emplace_back (p.as_prerequisite (trace));
+                g->prerequisites.push_back (p.as_prerequisite_for (*g));
               }
               else
                 l4 ([&]{trace << ".cli file stem '" << p.name () << "' "
diff --git a/build2/install/rule.cxx b/build2/install/rule.cxx
index 036f01f..a727acc 100644
--- a/build2/install/rule.cxx
+++ b/build2/install/rule.cxx
@@ -49,7 +49,7 @@ namespace build2
     {
       tracer trace ("install::alias_rule::apply");
 
-      for (prerequisite p: group_prerequisites (t))
+      for (prerequisite& p: group_prerequisites (t))
       {
         target& pt (search (p));
 
diff --git a/build2/parser.cxx b/build2/parser.cxx
index 9ce916e..7997d10 100644
--- a/build2/parser.cxx
+++ b/build2/parser.cxx
@@ -635,11 +635,28 @@ namespace build2
             else
               attributes_pop ();
 
-            // Prepare the prerequisite list.
+            // First enter all the targets (normally we will have just one).
             //
-            target::prerequisites_type ps;
-            ps.reserve (pns.size ());
+            small_vector<reference_wrapper<target>, 1> tgs;
 
+            for (auto& tn: ns)
+            {
+              if (tn.qualified ())
+                fail (nloc) << "project name in target " << tn;
+
+              // @@ OUT TODO
+              //
+              enter_target tg (*this, move (tn), name (), nloc, trace);
+
+              if (default_target_ == nullptr)
+                default_target_ = target_;
+
+              target_->prerequisites.reserve (pns.size ());
+              tgs.push_back (*target_);
+            }
+
+            // Now enter each prerequisite into each target.
+            //
             for (auto& pn: pns)
             {
               optional<string> e;
@@ -653,8 +670,6 @@ namespace build2
               if (!pn.dir.empty ())
                 pn.dir.normalize (false, true);
 
-              // Find or insert.
-              //
               // @@ OUT: for now we assume the prerequisite's out is
               // undetermined. The only way to specify an src prerequisite
               // will be with the explicit @-syntax.
@@ -665,36 +680,20 @@ namespace build2
               // natually suppress any searches by specifying the absolute
               // path.
               //
-              prerequisite& p (
-                scope_->prerequisites.insert (
-                  pn.proj,
-                  *ti,
-                  move (pn.dir),
-                  dir_path (),
-                  move (pn.value),
-                  move (e),
-                  *scope_,
-                  trace).first);
-
-              ps.emplace_back (p);
-            }
-
-            for (auto& tn: ns)
-            {
-              if (tn.qualified ())
-                fail (nloc) << "project name in target " << tn;
-
-              // @@ OUT TODO
+              prerequisite p (pn.proj,
+                              *ti,
+                              move (pn.dir),
+                              dir_path (),
+                              move (pn.value),
+                              move (e),
+                              tgs.back ());
+
+              // Move last prerequisite (which will normally be the only one).
               //
-              enter_target tg (*this, move (tn), name (), nloc, trace);
-
-              //@@ OPT: move if last/single target (common cases).
-              //
-              target_->prerequisites.insert (
-                target_->prerequisites.end (), ps.begin (), ps.end ());
-
-              if (default_target_ == nullptr)
-                default_target_ = target_;
+              for (target& t: tgs)
+                t.prerequisites.push_back (&t == &p.owner
+                                           ? move (p)
+                                           : prerequisite (p, t));
             }
           }
 
@@ -3559,7 +3558,7 @@ namespace build2
         targets.find (dir::static_type,    // Explicit current dir target.
                       scope_->out_path (),
                       dir_path (),         // Out tree target.
-                      "",
+                      string (),
                       nullopt,
                       trace) != targets.end ())
       return;
@@ -3572,19 +3571,11 @@ namespace build2
       targets.insert (dir::static_type,
                       scope_->out_path (),
                       dir_path (),
-                      "",
+                      string (),
                       nullopt,
                       trace).first);
 
-    prerequisite& p (
-      scope_->prerequisites.insert (
-        nullopt,
-        dt.key (),
-        *scope_,   // Doesn't matter which scope since dir is absolute.
-        trace).first);
-
-    p.target = &dt;
-    ct.prerequisites.emplace_back (p);
+    ct.prerequisites.emplace_back (dt, ct);
   }
 
   void parser::
diff --git a/build2/prerequisite b/build2/prerequisite
index 60970d6..f951e0a 100644
--- a/build2/prerequisite
+++ b/build2/prerequisite
@@ -5,7 +5,6 @@
 #ifndef BUILD2_PREREQUISITE
 #define BUILD2_PREREQUISITE
 
-#include <functional> // hash
 #include <unordered_set>
 
 #include <build2/types>
@@ -22,6 +21,11 @@ namespace build2
   // Light-weight (by being shallow-pointing) prerequisite key, similar
   // to (and based on) target key.
   //
+  // Note that unlike prerequisite, the key is not (necessarily) owned by a
+  // target. So for the key we instead have the base scope of the target that
+  // (would) own it. Note that we assume keys to be ephemeral enough for the
+  // base scope to remain unchanged.
+  //
   class prerequisite_key
   {
   public:
@@ -38,52 +42,14 @@ namespace build2
     bool is_a (const target_type& tt) const {return tk.is_a (tt);}
   };
 
-  inline bool
-  operator== (const prerequisite_key& x, const prerequisite_key& y)
-  {
-    assert (x.scope == y.scope);
-    return x.proj == y.proj && x.tk == y.tk;
-  }
-
-  inline bool
-  operator!= (const prerequisite_key& x, const prerequisite_key& y)
-  {
-    return !(x == y);
-  }
-
   ostream&
   operator<< (ostream&, const prerequisite_key&);
-}
-
-
-namespace std
-{
-  // Note that we ignore the extension when calculating the hash because of
-  // its special "unspecified" logic (see target_key::operator==).
-  //
-  template <>
-  struct hash<build2::prerequisite_key>
-  {
-    using argument_type = build2::prerequisite_key;
-    using result_type = size_t;
-
-    size_t
-    operator() (const build2::prerequisite_key& k) const noexcept
-    {
-      return build2::combine_hash (hash<build2::optional<string>> () (k.proj),
-                                   hash<build2::target_key> () (k.tk));
-    }
-  };
-}
 
-namespace build2
-{
   class prerequisite
   {
   public:
     typedef build2::target target_type;
     typedef build2::target_type target_type_type;
-    typedef build2::scope scope_type;
 
     // Note that unlike targets, for prerequisites an empty out directory
     // means undetermined rather than being definitely in the out tree.
@@ -94,7 +60,9 @@ namespace build2
     const dir_path out;         // Empty, normalized absolute, or relative.
     const string name;
     const optional<string> ext; // Absent if unspecified.
-    scope_type& scope;
+
+    target_type& owner;         // Target to which this prerequisite belongs.
+
     target_type* target;        // NULL if not yet resolved. Note that this
                                 // should always be the "primary target", not
                                 // a member of a target group.
@@ -106,28 +74,40 @@ namespace build2
                   dir_path o,
                   string n,
                   optional<string> e,
-                  scope_type& s)
+                  target_type& w)
         : proj (move (p)),
           type (t),
           dir (move (d)),
           out (move (o)),
           name (move (n)),
           ext (move (e)),
-          scope (s),
+          owner (w),
           target (nullptr) {}
 
+    // Make a copy for a new owner target. Note that both owner targets should
+    // be in the same scope.
+    //
+    prerequisite (const prerequisite&, target_type& owner);
+
+    // Make a prerequisite from a target.
+    //
+    prerequisite (target_type&, target_type& owner);
+
+    prerequisite (const prerequisite&) = delete;
+    prerequisite (prerequisite&&) = default;
+
+    prerequisite& operator= (const prerequisite&) = delete;
+    prerequisite& operator= (prerequisite&&) = default;
+
     // Note that the returned key "tracks" the prerequisite; that is, any
     // updates to the prerequisite's members will be reflected in the key.
     //
     prerequisite_key
-    key () const
-    {
-      return prerequisite_key {proj, {&type, &dir, &out, &name, ext}, &scope};
-    }
+    key () const;
 
-  public:
     // Prerequisite (target) type.
     //
+  public:
     template <typename T>
     bool
     is_a () const {return type.is_a<T> ();}
@@ -136,69 +116,11 @@ namespace build2
     is_a (const target_type_type& tt) const {return type.is_a (tt);}
   };
 
-  inline bool
-  operator== (const prerequisite& x, const prerequisite& y)
-  {
-    return x.key () == y.key ();
-  }
-
-  inline bool
-  operator!= (const prerequisite& x, const prerequisite& y)
-  {
-    return !(x == y);
-  }
-
   inline ostream&
   operator<< (ostream& os, const prerequisite& p)
   {
     return os << p.key ();
   }
-
-}
-
-namespace std
-{
-  template <>
-  struct hash<build2::prerequisite>
-  {
-    using argument_type = build2::prerequisite;
-    using result_type = size_t;
-
-    size_t
-    operator() (const build2::prerequisite& p) const noexcept
-    {
-      return hash<build2::prerequisite_key> () (p.key ());
-    }
-  };
-}
-
-namespace build2
-{
-  // Set of prerequisites in a scope.
-  //
-  // Similar to targets, specified and unspecified extensions are considered
-  // equal and we may update the extension in the existing entry. To make
-  // this work we use a hash set.
-  //
-  struct prerequisite_set: std::unordered_set<prerequisite>
-  {
-    pair<prerequisite&, bool>
-    insert (optional<string> proj,
-            const target_type&,
-            dir_path dir,
-            dir_path out,
-            string name,
-            optional<string> ext,
-            scope&,
-            tracer&);
-
-    pair<prerequisite&, bool>
-    insert (optional<string> proj, const target_key& tk, scope& s, tracer& t)
-    {
-      return insert (
-        move (proj), *tk.type, *tk.dir, *tk.out, *tk.name, tk.ext, s, t);
-    }
-  };
 }
 
 #endif // BUILD2_PREREQUISITE
diff --git a/build2/prerequisite.cxx b/build2/prerequisite.cxx
index bcd4123..469bdf9 100644
--- a/build2/prerequisite.cxx
+++ b/build2/prerequisite.cxx
@@ -5,7 +5,7 @@
 #include <build2/prerequisite>
 
 #include <build2/scope>
-#include <build2/target> // target_type
+#include <build2/target>
 #include <build2/context>
 #include <build2/diagnostics>
 
@@ -48,53 +48,41 @@ namespace build2
     return os << pk.tk;
   }
 
-  // prerequisite_set
+  // prerequisite
   //
-  auto prerequisite_set::
-  insert (optional<string> proj,
-          const target_type& tt,
-          dir_path dir,
-          dir_path out,
-          string name,
-          optional<string> ext,
-          scope& s,
-          tracer& trace) -> pair<prerequisite&, bool>
+  prerequisite::
+  prerequisite (const prerequisite& p, target_type& w)
+      : proj (p.proj),
+        type (p.type),
+        dir (p.dir),
+        out (p.out),
+        name (p.name),
+        ext (p.ext),
+        owner (w),
+        target (nullptr)
   {
-    //@@ OPT: would be nice to somehow first check if this prerequisite is
-    //   already in the set before allocating a new instance. Something with
-    //   bounds and insert hints?
-
-    // Find or insert.
-    //
-    auto r (emplace (move (proj),
-                     tt,
-                     move (dir),
-                     move (out),
-                     move (name),
-                     ext, // Note: cannot move.
-                     s));
-    prerequisite& p (const_cast<prerequisite&> (*r.first));
-
-    // Update extension if the existing prerequisite has it unspecified.
-    //
-    if (p.ext != ext)
-    {
-      l5 ([&]{
-          diag_record r (trace);
-          r << "assuming prerequisite " << p << " is the same as the "
-            << "one with ";
-          if (!ext)
-            r << "unspecified extension";
-          else if (ext->empty ())
-            r << "no extension";
-          else
-            r << "extension " << *ext;
-        });
+    assert (&w.base_scope () == &p.owner.base_scope ());
+  }
 
-      if (ext)
-        const_cast<optional<string>&> (p.ext) = move (ext);
-    }
+  // Make a prerequisite from a target.
+  //
+  prerequisite::
+  prerequisite (target_type& t, target_type& w)
+      : proj (nullopt),
+        type (t.type ()),
+        dir (t.dir),
+        out (t.out),   // @@ If it's empty, then we treat as undetermined?
+        name (t.name),
+        ext (t.ext),
+        owner (w),
+        target (&t)
+  {
+  }
 
-    return pair<prerequisite&, bool> (p, r.second);
+  prerequisite_key prerequisite::
+  key () const
+  {
+    return prerequisite_key {
+      proj, {&type, &dir, &out, &name, ext}, &owner.base_scope ()};
   }
 }
diff --git a/build2/scope b/build2/scope
index f22383a..eff60b0 100644
--- a/build2/scope
+++ b/build2/scope
@@ -15,7 +15,7 @@
 
 #include <build2/module>
 #include <build2/variable>
-#include <build2/prerequisite>
+#include <build2/target-key>
 #include <build2/target-type>
 #include <build2/rule-map>
 #include <build2/operation>
@@ -184,18 +184,14 @@ namespace build2
     //
     variable_type_map target_vars;
 
-    // Prerequisite cache.
-    //
-  public:
-    prerequisite_set prerequisites;
-
     // Meta/operations supported by this project (set on the root
     // scope only).
     //
+  public:
     build2::meta_operations meta_operations;
     build2::operations operations;
 
-    typedef build2::path path_type;
+    using path_type = build2::path;
 
     // Set of buildfiles already loaded for this scope. The included
     // buildfiles are checked against the project's root scope while
@@ -261,13 +257,13 @@ namespace build2
                               // NULL means no strong amalgamtion.
   };
 
-  // Temporary scope. The idea is to be able to create a temporary
-  // scope in order not to change the variables in the current scope.
-  // Such a scope is not entered in to the scope map. As a result it
-  // can only be used as a temporary set of variables. In particular,
-  // defining targets/prerequisites directly in such a scope will surely
-  // end up badly. Defining any nested scopes will be as if defining
-  // such a scope in the parent (since path() returns parent's path).
+  // Temporary scope. The idea is to be able to create a temporary scope in
+  // order not to change the variables in the current scope.  Such a scope is
+  // not entered in to the scope map. As a result it can only be used as a
+  // temporary set of variables. In particular, defining targetsdirectly in
+  // such a scope will surely end up badly. Defining any nested scopes will be
+  // as if defining such a scope in the parent (since path() returns parent's
+  // path).
   //
   class temp_scope: public scope
   {
diff --git a/build2/target b/build2/target
index 421c20a..a41c5b9 100644
--- a/build2/target
+++ b/build2/target
@@ -95,26 +95,6 @@ namespace build2
   target_state
   group_action (action, target&); // Defined in <build2/algorithm>.
 
-  // Prerequisite references as used in the target::prerequisites list
-  // below.
-  //
-  struct prerequisite_ref: reference_wrapper<prerequisite>
-  {
-    typedef reference_wrapper<prerequisite> base;
-
-    using base::base;
-
-    // Return true if this reference belongs to the target's prerequisite
-    // list. Note that this test only works if you use references to
-    // the container elements and the container hasn't been resized
-    // since such a reference was obtained. Normally this function is
-    // used when iterating over a combined prerequisites range (see
-    // group_prerequisites below).
-    //
-    bool
-    belongs (const target&) const;
-  };
-
   // A view of target group members.
   //
   struct group_view
@@ -253,15 +233,6 @@ namespace build2
     }
 
   public:
-    virtual
-    ~target ();
-
-    target (const target&) = delete;
-    target& operator= (const target&) = delete;
-
-    target (dir_path d, dir_path o, string n, optional<string> e)
-        : dir (move (d)), out (move (o)), name (move (n)), ext (move (e)) {}
-
     // Reset the target before matching it to a rule. The default
     // implementation clears the auxilary data and prerequisite_targets.
     //
@@ -317,7 +288,7 @@ namespace build2
     // Prerequisites.
     //
   public:
-    typedef vector<prerequisite_ref> prerequisites_type;
+    using prerequisites_type = small_vector<prerequisite, 4>;
     prerequisites_type prerequisites;
 
     // Targets to which prerequisites resolve for this recipe. Note
@@ -566,10 +537,33 @@ namespace build2
     virtual const target_type& dynamic_type () const = 0;
     static const target_type static_type;
 
+  public:
+    virtual
+    ~target ();
+
+    target (const target&) = delete;
+    target& operator= (const target&) = delete;
+
+    // The only way to create a target should be via the targets set below.
+    //
+  public:
+    friend class target_set;
+
+    target (dir_path d, dir_path o, string n, optional<string> e)
+        : dir (move (d)), out (move (o)), name (move (n)), ext (move (e)) {}
+
   private:
     recipe_type recipe_;
   };
 
+  // All targets are from the targets set below.
+  //
+  inline bool
+  operator== (const target& x, const target& y) {return &x == &y;}
+
+  inline bool
+  operator!= (const target& x, const target& y) {return !(x == y);}
+
   inline ostream&
   operator<< (ostream& os, const target& t) {return os << t.key ();}
 
@@ -580,9 +574,9 @@ namespace build2
   // come first followed by the member's. If you need to see them
   // in the other direction, iterate in reverse, for example:
   //
-  // for (prerequisite_ref& pr: group_prerequisites (t))
+  // for (prerequisite& p: group_prerequisites (t))
   //
-  // for (prerequisite_ref& pr: reverse_iterate (group_prerequisites (t))
+  // for (prerequisite& p: reverse_iterate (group_prerequisites (t))
   //
   // Note that in this case the individual elements of each list will
   // also be traversed in reverse, but that's what you usually want,
@@ -708,7 +702,7 @@ namespace build2
     using prerequisite_type = build2::prerequisite;
     using target_type_type = build2::target_type;
 
-    prerequisite_ref& prerequisite;
+    prerequisite_type& prerequisite;
     target_type* target;
 
     template <typename T>
@@ -717,35 +711,33 @@ namespace build2
     {
       return target != nullptr
         ? target->is_a<T> () != nullptr
-        : prerequisite.get ().is_a<T> ();
+        : prerequisite.is_a<T> ();
     }
 
     bool
     is_a (const target_type_type& tt) const
     {
-      return target != nullptr
-        ? target->is_a (tt)
-        : prerequisite.get ().is_a (tt);
+      return target != nullptr ? target->is_a (tt) : prerequisite.is_a (tt);
     }
 
     prerequisite_key
     key () const
     {
       return target != nullptr
-        ? prerequisite_key {prerequisite.get ().proj, target->key (), nullptr}
-        : prerequisite.get ().key ();
+        ? prerequisite_key {prerequisite.proj, target->key (), nullptr}
+        : prerequisite.key ();
     }
 
     const target_type_type&
     type () const
     {
-      return target != nullptr ? target->type () : prerequisite.get ().type;
+      return target != nullptr ? target->type () : prerequisite.type;
     }
 
     const string&
     name () const
     {
-      return target != nullptr ? target->name : prerequisite.get ().name;
+      return target != nullptr ? target->name : prerequisite.name;
     }
 
     const optional<string>&
@@ -755,7 +747,7 @@ namespace build2
       //
       return target != nullptr
         ? prerequisite_key::nullproj
-        : prerequisite.get ().proj;
+        : prerequisite.proj;
     }
 
     target_type&
@@ -764,8 +756,13 @@ namespace build2
       return target != nullptr ? *target : build2::search (prerequisite);
     }
 
-    prerequisite_type&
-    as_prerequisite (tracer&) const;
+    // Return as a new prerequisite instance for the specified owner target.
+    // Note that if this is a prerequisite, then both owners should be in the
+    // same scope (not a requirement if this is a target because then its path
+    // will be absolute).
+    //
+    prerequisite_type
+    as_prerequisite_for (target_type& owner) const;
   };
 
   // It is often stored as the target's auxiliary data so make sure there is
@@ -835,7 +832,7 @@ namespace build2
       iterator (const prerequisite_members_range* r, const base_iterator& i)
           : r_ (r), i_ (i), g_ {nullptr, 0}, k_ (nullptr)
       {
-        if (r_->members_ && i_ != r_->e_ && i_->get ().type.see_through)
+        if (r_->members_ && i_ != r_->e_ && i_->type.see_through)
           switch_mode ();
       }
 
diff --git a/build2/target.ixx b/build2/target.ixx
index 2d4fff8..9c2c838 100644
--- a/build2/target.ixx
+++ b/build2/target.ixx
@@ -4,32 +4,20 @@
 
 namespace build2
 {
-  // prerequisite_ref
-  //
-  inline bool prerequisite_ref::
-  belongs (const target& t) const
-  {
-    const auto& p (t.prerequisites);
-    return !(p.empty () || this < &p.front () || this > &p.back ());
-  }
-
   // prerequisite_member
   //
-  inline prerequisite& prerequisite_member::
-  as_prerequisite (tracer& trace) const
+  inline prerequisite prerequisite_member::
+  as_prerequisite_for (target_type& owner) const
   {
     if (target == nullptr)
-      return prerequisite;
+      return prerequisite_type (prerequisite, owner);
 
     // An ad hoc group member cannot be used as a prerequisite (use the whole
     // group instead).
     //
     assert (!target->adhoc_member ());
 
-    // The use of the group's prerequisite scope is debatable.
-    //
-    scope& s (prerequisite.get ().scope);
-    return s.prerequisites.insert (nullopt, key ().tk, s, trace).first;
+    return prerequisite_type (*target, owner);
   }
 
   // prerequisite_members
@@ -50,7 +38,7 @@ namespace build2
       //
       target* t (g_.count != 0
                  ? j_ != 0 ? g_.members[j_ - 1] : nullptr // enter_group()
-                 : i_->get ().target);
+                 : i_->target);
       if (t != nullptr && t->member != nullptr)
         k_ = t->member;
     }
@@ -66,7 +54,7 @@ namespace build2
     {
       ++i_;
 
-      if (r_->members_ && i_ != r_->e_ && i_->get ().type.see_through)
+      if (r_->members_ && i_ != r_->e_ && i_->type.see_through)
         switch_mode ();
     }
 
@@ -82,7 +70,7 @@ namespace build2
     //
     target* t (g_.count != 0
                ? j_ != 0 ? g_.members[j_ - 1] : nullptr
-               : i_->get ().target);
+               : i_->target);
 
     if (t != nullptr && t->member != nullptr)
       k_ = t->member;
@@ -117,7 +105,7 @@ namespace build2
     {
       target* t (g_.count != 0
                  ? j_ != 0 ? g_.members[j_ - 1] : nullptr
-                 : i_->get ().target);
+                 : i_->target);
       if (t != nullptr && t->member != nullptr)
         k_ = t->member;
     }
diff --git a/build2/target.txx b/build2/target.txx
index 66acfb8..b72af7d 100644
--- a/build2/target.txx
+++ b/build2/target.txx
@@ -27,7 +27,7 @@ namespace build2
         break;
       }
     }
-    while (++i_ != r_->e_ && i_->get ().type.see_through);
+    while (++i_ != r_->e_ && i_->type.see_through);
   }
 
   //
diff --git a/build2/test/common.cxx b/build2/test/common.cxx
index afd52e6..66be9d8 100644
--- a/build2/test/common.cxx
+++ b/build2/test/common.cxx
@@ -143,7 +143,7 @@ namespace build2
               t.name == n->value &&       // Name matches.
               tt.name == n->type &&       // Target type matches.
               d == n->dir &&              // Directory matches.
-              &search (*n, *root_) == &t;
+              search (*n, *root_) == t;
 
           if (r)
             break;
@@ -190,7 +190,7 @@ namespace build2
                 t.name == n->value &&
                 tt.name == n->type &&
                 d == n->dir &&
-                &search (*n, *root_) == &t;
+                search (*n, *root_) == t;
 
             if (!r)
               continue; // Not our target.