+=for apidoc mro_package_moved
+
+Call this function to signal to a stash that it has been assigned to
+another spot in the stash hierarchy. C<stash> is the stash that has been
+assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob
+that is actually being assigned to. C<newname> and C<newname_len> are the
+full name of the GV. If these last two arguments are omitted, they can be
+inferred from C<gv>. C<gv> can be omitted if C<newname> is given.
+
+This can also be called with a null first argument to
+indicate that C<oldstash> has been deleted.
+
+This function invalidates isa caches on the old stash, on all subpackages
+nested inside it, and on the subclasses of all those, including
+non-existent packages that have corresponding entries in C<stash>.
+
+It also sets the effective names (C<HvENAME>) on all the stashes as
+appropriate.
+
+=cut
+*/
+void
+Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
+ const GV *gv, const char *newname,
+ I32 newname_len)
+{
+ HV *stashes;
+ HE* iter;
+
+ assert(stash || oldstash);
+ assert(gv || newname);
+
+ /* Determine the name of the location that stash was assigned to
+ * or from which oldstash was removed.
+ *
+ * We cannot reliably use the name in oldstash, because it may have
+ * been deleted from the location in the symbol table that its name
+ * suggests, as in this case:
+ *
+ * $globref = \*foo::bar::;
+ * Symbol::delete_package("foo");
+ * *$globref = \%baz::;
+ * *$globref = *frelp::;
+ * # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
+ *
+ * If newname is not null, then we trust that the caller gave us the
+ * right name. Otherwise, we get it from the gv. But if the gv is not
+ * in the symbol table, then we just return.
+ */
+ if(!newname && gv) {
+ SV * const namesv = sv_newmortal();
+ STRLEN len;
+ gv_fullname4(namesv, gv, NULL, 0);
+ if(gv_fetchsv(namesv, GV_NOADD_NOINIT, SVt_PVGV) != gv) return;
+ newname = SvPV_const(namesv, len);
+ newname_len = len - 2; /* skip trailing :: */
+ }
+ if(newname_len < 0) newname_len = -newname_len;
+
+ /* Get a list of all the affected classes. */
+ /* We cannot simply pass them all to mro_isa_changed_in to avoid
+ the list, as that function assumes that only one package has
+ changed. It does not work with:
+
+ @foo::ISA = qw( B B::B );
+ *B:: = delete $::{"A::"};
+
+ as neither B nor B::B can be updated before the other, since they
+ will reset caches on foo, which will see either B or B::B with the
+ wrong name. The names must be set on *all* affected stashes before
+ we do anything else.
+ */
+ stashes = (HV *) sv_2mortal((SV *)newHV());
+ mro_gather_and_rename(
+ stashes, (HV *) sv_2mortal((SV *)newHV()),
+ stash, oldstash, newname, newname_len
+ );
+
+ /* Iterate through the stashes, wiping isa linearisations, but leaving
+ the isa hash (which mro_isa_changed_in needs for adjusting the
+ isarev hashes belonging to parent classes). */
+ hv_iterinit(stashes);
+ while((iter = hv_iternext(stashes))) {
+ HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
+ if(HvENAME(stash)) {
+ struct mro_meta* meta;
+ meta = HvMROMETA(stash);
+ if (meta->mro_linear_all) {
+ SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
+ meta->mro_linear_all = NULL;
+ /* This is just acting as a shortcut pointer. */
+ meta->mro_linear_current = NULL;
+ } else if (meta->mro_linear_current) {
+ /* Only the current MRO is stored, so this owns the data. */
+ SvREFCNT_dec(meta->mro_linear_current);
+ meta->mro_linear_current = NULL;
+ }
+ }
+ }
+
+ /* Once the caches have been wiped on all the classes, call
+ mro_isa_changed_in on each. */
+ hv_iterinit(stashes);
+ while((iter = hv_iternext(stashes))) {
+ HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
+ if(HvENAME(stash)) {
+ /* We have to restore the original meta->isa (that
+ mro_gather_and_rename set aside for us) this way, in case
+ one class in this list is a superclass of a another class
+ that we have already encountered. In such a case, meta->isa
+ will have been overwritten without old entries being deleted
+ from PL_isarev. */
+ struct mro_meta * const meta = HvMROMETA(stash);
+ if(meta->isa != (HV *)HeVAL(iter)){
+ SvREFCNT_dec(meta->isa);
+ meta->isa
+ = HeVAL(iter) == &PL_sv_yes
+ ? NULL
+ : (HV *)HeVAL(iter);
+ HeVAL(iter) = NULL; /* We donated our reference count. */
+ }
+ mro_isa_changed_in(stash);
+ }
+ }
+}
+
+void
+S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
+ HV *stash, HV *oldstash, const char *name,
+ I32 namlen)
+{
+ register XPVHV* xhv;
+ register HE *entry;
+ I32 riter = -1;
+ const bool stash_had_name = stash && HvENAME(stash);
+ HV *seen = NULL;
+ HV *isarev = NULL;
+ SV **svp;
+
+ PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
+
+ /* We use the seen_stashes hash to keep track of which packages have
+ been encountered so far. This must be separate from the main list of
+ stashes, as we need to distinguish between stashes being assigned
+ and stashes being replaced/deleted. (A nested stash can be on both
+ sides of an assignment. We cannot simply skip iterating through a
+ stash on the right if we have seen it on the left, as it will not
+ get its ename assigned to it.)
+
+ To avoid allocating extra SVs, instead of a bitfield we can make
+ bizarre use of immortals:
+
+ &PL_sv_undef: seen on the left (oldstash)
+ &PL_sv_no : seen on the right (stash)
+ &PL_sv_yes : seen on both sides
+
+ */
+
+ if(oldstash) {
+ /* Add to the big list. */
+ struct mro_meta * meta;
+ HE * const entry
+ = (HE *)
+ hv_common(
+ seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
+ HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
+ );
+ if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
+ oldstash = NULL;
+ goto check_stash;
+ }
+ HeVAL(entry)
+ = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
+ meta = HvMROMETA(oldstash);
+ (void)
+ hv_store(
+ stashes, (const char *)&oldstash, sizeof(HV *),
+ meta->isa
+ ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
+ : &PL_sv_yes,
+ 0
+ );
+
+ /* Update the effective name. */
+ if(HvENAME_get(oldstash)) {
+ const HEK * const enamehek = HvENAME_HEK(oldstash);
+ if(PL_stashcache)
+ (void)
+ hv_delete(PL_stashcache, name, namlen, G_DISCARD);
+ hv_ename_delete(oldstash, name, namlen);
+
+ /* If the name deletion caused a name change, then we are not
+ * going to call mro_isa_changed_in with this name (and not at all
+ * if it has become anonymous) so we need to delete old isarev
+ * entries here, both those in the superclasses and this class’s
+ * own list of subclasses. We simply delete the latter from
+ * from PL_isarev, since we still need it. hv_delete mortifies it
+ * for us, so sv_2mortal is not necessary. */
+ if(HvENAME_HEK(oldstash) != enamehek) {
+ if(meta->isa && HvARRAY(meta->isa))
+ mro_clean_isarev(meta->isa, name, namlen, NULL);
+ isarev = (HV *)hv_delete(PL_isarev, name, namlen, 0);
+ }
+ }
+ }
+ check_stash:
+ if(stash) {
+ hv_ename_add(stash, name, namlen);
+
+ /* Add it to the big list if it needs
+ * mro_isa_changed_in called on it. That happens if it was
+ * detached from the symbol table (so it had no HvENAME) before
+ * being assigned to the spot named by the ‘name’ variable, because
+ * its cached isa linerisation is now stale (the effective name
+ * having changed), and subclasses will then use that cache when
+ * mro_package_moved calls mro_isa_changed_in. (See
+ * [perl #77358].)
+ *
+ * If it did have a name, then its previous name is still
+ * used in isa caches, and there is no need for
+ * mro_package_moved to call mro_isa_changed_in.
+ */
+
+ entry
+ = (HE *)
+ hv_common(
+ seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
+ HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
+ );
+ if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
+ stash = NULL;
+ else {
+ HeVAL(entry)
+ = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
+ if(!stash_had_name)
+ {
+ struct mro_meta * const meta = HvMROMETA(stash);
+ (void)
+ hv_store(
+ stashes, (const char *)&stash, sizeof(HV *),
+ meta->isa
+ ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
+ : &PL_sv_yes,
+ 0
+ );
+ }
+ }
+ }
+
+ if(!stash && !oldstash)
+ /* Both stashes have been encountered already. */
+ return;
+
+ /* Add all the subclasses to the big list. */
+ if(
+ isarev
+ || (
+ (svp = hv_fetch(PL_isarev, name, namlen, 0))
+ && (isarev = MUTABLE_HV(*svp))
+ )
+ ) {
+ HE *iter;
+ hv_iterinit(isarev);
+ while((iter = hv_iternext(isarev))) {
+ I32 len;
+ const char* const revkey = hv_iterkey(iter, &len);
+ HV* revstash = gv_stashpvn(revkey, len, 0);
+ struct mro_meta * meta;
+
+ if(!revstash) continue;
+ meta = HvMROMETA(revstash);
+ (void)
+ hv_store(
+ stashes, (const char *)&revstash, sizeof(HV *),
+ meta->isa
+ ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
+ : &PL_sv_yes,
+ 0
+ );
+ }
+ }
+
+ if(
+ (!stash || !HvARRAY(stash)) && (!oldstash || !HvARRAY(oldstash))
+ ) return;
+
+ /* This is partly based on code in hv_iternext_flags. We are not call-
+ ing that here, as we want to avoid resetting the hash iterator. */
+
+ /* Skip the entire loop if the hash is empty. */
+ if(oldstash && HvUSEDKEYS(oldstash)) {
+ xhv = (XPVHV*)SvANY(oldstash);
+ seen = (HV *) sv_2mortal((SV *)newHV());
+
+ /* Iterate through entries in the oldstash, adding them to the
+ list, meanwhile doing the equivalent of $seen{$key} = 1.
+ */
+
+ while (++riter <= (I32)xhv->xhv_max) {
+ entry = (HvARRAY(oldstash))[riter];
+
+ /* Iterate through the entries in this list */
+ for(; entry; entry = HeNEXT(entry)) {
+ const char* key;
+ I32 len;
+
+ /* If this entry is not a glob, ignore it.
+ Try the next. */
+ if (!isGV(HeVAL(entry))) continue;
+
+ key = hv_iterkey(entry, &len);
+ if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
+ HV * const oldsubstash = GvHV(HeVAL(entry));
+ SV ** const stashentry
+ = stash ? hv_fetch(stash, key, len, 0) : NULL;
+ HV *substash = NULL;
+
+ /* Avoid main::main::main::... */
+ if(oldsubstash == oldstash) continue;
+
+ if(
+ (
+ stashentry && *stashentry
+ && (substash = GvHV(*stashentry))
+ )
+ || (oldsubstash && HvENAME_get(oldsubstash))
+ )
+ {
+ /* Add :: and the key (minus the trailing ::)
+ to newname. */
+ SV *namesv
+ = newSVpvn_flags(name, namlen, SVs_TEMP);
+ {
+ const char *name;
+ STRLEN namlen;
+ sv_catpvs(namesv, "::");
+ sv_catpvn(namesv, key, len-2);
+ name = SvPV_const(namesv, namlen);
+ mro_gather_and_rename(
+ stashes, seen_stashes,
+ substash, oldsubstash, name, namlen
+ );
+ }
+ }
+
+ (void)hv_store(seen, key, len, &PL_sv_yes, 0);
+ }
+ }
+ }
+ }
+
+ /* Skip the entire loop if the hash is empty. */
+ if (stash && HvUSEDKEYS(stash)) {
+ xhv = (XPVHV*)SvANY(stash);
+ riter = -1;
+
+ /* Iterate through the new stash, skipping $seen{$key} items,
+ calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
+ while (++riter <= (I32)xhv->xhv_max) {
+ entry = (HvARRAY(stash))[riter];
+
+ /* Iterate through the entries in this list */
+ for(; entry; entry = HeNEXT(entry)) {
+ const char* key;
+ I32 len;
+
+ /* If this entry is not a glob, ignore it.
+ Try the next. */
+ if (!isGV(HeVAL(entry))) continue;
+
+ key = hv_iterkey(entry, &len);
+ if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
+ HV *substash;
+
+ /* If this entry was seen when we iterated through the
+ oldstash, skip it. */
+ if(seen && hv_exists(seen, key, len)) continue;
+
+ /* We get here only if this stash has no corresponding
+ entry in the stash being replaced. */
+
+ substash = GvHV(HeVAL(entry));
+ if(substash) {
+ SV *namesv;
+ const char *subname;
+ STRLEN subnamlen;
+
+ /* Avoid checking main::main::main::... */
+ if(substash == stash) continue;
+
+ /* Add :: and the key (minus the trailing ::)
+ to newname. */
+ namesv
+ = newSVpvn_flags(name, namlen, SVs_TEMP);
+ sv_catpvs(namesv, "::");
+ sv_catpvn(namesv, key, len-2);
+ subname = SvPV_const(namesv, subnamlen);
+ mro_gather_and_rename(
+ stashes, seen_stashes,
+ substash, NULL, subname, subnamlen
+ );
+ }
+ }
+ }
+ }
+ }
+}
+
+/*