add some tests for Perl #71922
[perl.git] / mro.c
1 /*    mro.c
2  *
3  *    Copyright (c) 2007 Brandon L Black
4  *    Copyright (c) 2007, 2008, 2009, 2010, 2011 Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  *
9  */
10
11 /*
12  * 'Which order shall we go in?' said Frodo.  'Eldest first, or quickest first?
13  *  You'll be last either way, Master Peregrin.'
14  *
15  *     [p.101 of _The Lord of the Rings_, I/iii: "A Conspiracy Unmasked"]
16  */
17
18 /*
19 =head1 MRO Functions
20
21 These functions are related to the method resolution order of perl classes
22
23 =cut
24 */
25
26 #include "EXTERN.h"
27 #define PERL_IN_MRO_C
28 #include "perl.h"
29
30 static const struct mro_alg dfs_alg =
31     {S_mro_get_linear_isa_dfs, "dfs", 3, 0, 0};
32
33 SV *
34 Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta,
35                           const struct mro_alg *const which)
36 {
37     SV **data;
38     PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA;
39
40     data = (SV **)Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
41                                  which->name, which->length, which->kflags,
42                                  HV_FETCH_JUST_SV, NULL, which->hash);
43     if (!data)
44         return NULL;
45
46     /* If we've been asked to look up the private data for the current MRO, then
47        cache it.  */
48     if (smeta->mro_which == which)
49         smeta->mro_linear_current = *data;
50
51     return *data;
52 }
53
54 SV *
55 Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta,
56                           const struct mro_alg *const which, SV *const data)
57 {
58     PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA;
59
60     if (!smeta->mro_linear_all) {
61         if (smeta->mro_which == which) {
62             /* If all we need to store is the current MRO's data, then don't use
63                memory on a hash with 1 element - store it direct, and signal
64                this by leaving the would-be-hash NULL.  */
65             smeta->mro_linear_current = data;
66             return data;
67         } else {
68             HV *const hv = newHV();
69             /* Start with 2 buckets. It's unlikely we'll need more. */
70             HvMAX(hv) = 1;      
71             smeta->mro_linear_all = hv;
72
73             if (smeta->mro_linear_current) {
74                 /* If we were storing something directly, put it in the hash
75                    before we lose it. */
76                 Perl_mro_set_private_data(aTHX_ smeta, smeta->mro_which, 
77                                           smeta->mro_linear_current);
78             }
79         }
80     }
81
82     /* We get here if we're storing more than one linearisation for this stash,
83        or the linearisation we are storing is not that if its current MRO.  */
84
85     if (smeta->mro_which == which) {
86         /* If we've been asked to store the private data for the current MRO,
87            then cache it.  */
88         smeta->mro_linear_current = data;
89     }
90
91     if (!Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
92                         which->name, which->length, which->kflags,
93                         HV_FETCH_ISSTORE, data, which->hash)) {
94         Perl_croak(aTHX_ "panic: hv_store() failed in set_mro_private_data() "
95                    "for '%.*s' %d", (int) which->length, which->name,
96                    which->kflags);
97     }
98
99     return data;
100 }
101
102 const struct mro_alg *
103 Perl_mro_get_from_name(pTHX_ SV *name) {
104     SV **data;
105
106     PERL_ARGS_ASSERT_MRO_GET_FROM_NAME;
107
108     data = (SV **)Perl_hv_common(aTHX_ PL_registered_mros, name, NULL, 0, 0,
109                                  HV_FETCH_JUST_SV, NULL, 0);
110     if (!data)
111         return NULL;
112     assert(SvTYPE(*data) == SVt_IV);
113     assert(SvIOK(*data));
114     return INT2PTR(const struct mro_alg *, SvUVX(*data));
115 }
116
117 /*
118 =for apidoc mro_register
119 Registers a custom mro plugin.  See L<perlmroapi> for details.
120
121 =cut
122 */
123
124 void
125 Perl_mro_register(pTHX_ const struct mro_alg *mro) {
126     SV *wrapper = newSVuv(PTR2UV(mro));
127
128     PERL_ARGS_ASSERT_MRO_REGISTER;
129
130     
131     if (!Perl_hv_common(aTHX_ PL_registered_mros, NULL,
132                         mro->name, mro->length, mro->kflags,
133                         HV_FETCH_ISSTORE, wrapper, mro->hash)) {
134         SvREFCNT_dec_NN(wrapper);
135         Perl_croak(aTHX_ "panic: hv_store() failed in mro_register() "
136                    "for '%.*s' %d", (int) mro->length, mro->name, mro->kflags);
137     }
138 }
139
140 struct mro_meta*
141 Perl_mro_meta_init(pTHX_ HV* stash)
142 {
143     struct mro_meta* newmeta;
144
145     PERL_ARGS_ASSERT_MRO_META_INIT;
146     assert(HvAUX(stash));
147     assert(!(HvAUX(stash)->xhv_mro_meta));
148     Newxz(newmeta, 1, struct mro_meta);
149     HvAUX(stash)->xhv_mro_meta = newmeta;
150     newmeta->cache_gen = 1;
151     newmeta->pkg_gen = 1;
152     newmeta->mro_which = &dfs_alg;
153
154     return newmeta;
155 }
156
157 #if defined(USE_ITHREADS)
158
159 /* for sv_dup on new threads */
160 struct mro_meta*
161 Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param)
162 {
163     struct mro_meta* newmeta;
164
165     PERL_ARGS_ASSERT_MRO_META_DUP;
166
167     Newx(newmeta, 1, struct mro_meta);
168     Copy(smeta, newmeta, 1, struct mro_meta);
169
170     if (newmeta->mro_linear_all) {
171         newmeta->mro_linear_all
172             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_linear_all, param));
173         /* This is just acting as a shortcut pointer, and will be automatically
174            updated on the first get.  */
175         newmeta->mro_linear_current = NULL;
176     } else if (newmeta->mro_linear_current) {
177         /* Only the current MRO is stored, so this owns the data.  */
178         newmeta->mro_linear_current
179             = sv_dup_inc((const SV *)newmeta->mro_linear_current, param);
180     }
181
182     if (newmeta->mro_nextmethod)
183         newmeta->mro_nextmethod
184             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_nextmethod, param));
185     if (newmeta->isa)
186         newmeta->isa
187             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->isa, param));
188
189     return newmeta;
190 }
191
192 #endif /* USE_ITHREADS */
193
194 /*
195 =for apidoc mro_get_linear_isa_dfs
196
197 Returns the Depth-First Search linearization of @ISA
198 the given stash.  The return value is a read-only AV*.
199 C<level> should be 0 (it is used internally in this
200 function's recursion).
201
202 You are responsible for C<SvREFCNT_inc()> on the
203 return value if you plan to store it anywhere
204 semi-permanently (otherwise it might be deleted
205 out from under you the next time the cache is
206 invalidated).
207
208 =cut
209 */
210 static AV*
211 S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level)
212 {
213     AV* retval;
214     GV** gvp;
215     GV* gv;
216     AV* av;
217     const HEK* stashhek;
218     struct mro_meta* meta;
219     SV *our_name;
220     HV *stored = NULL;
221
222     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS;
223     assert(HvAUX(stash));
224
225     stashhek
226      = HvAUX(stash)->xhv_name_u.xhvnameu_name && HvENAME_HEK_NN(stash)
227         ? HvENAME_HEK_NN(stash)
228         : HvNAME_HEK(stash);
229
230     if (!stashhek)
231       Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
232
233     if (level > 100)
234         Perl_croak(aTHX_
235                   "Recursive inheritance detected in package '%"HEKf"'",
236                    HEKfARG(stashhek));
237
238     meta = HvMROMETA(stash);
239
240     /* return cache if valid */
241     if((retval = MUTABLE_AV(MRO_GET_PRIVATE_DATA(meta, &dfs_alg)))) {
242         return retval;
243     }
244
245     /* not in cache, make a new one */
246
247     retval = MUTABLE_AV(sv_2mortal(MUTABLE_SV(newAV())));
248     /* We use this later in this function, but don't need a reference to it
249        beyond the end of this function, so reference count is fine.  */
250     our_name = newSVhek(stashhek);
251     av_push(retval, our_name); /* add ourselves at the top */
252
253     /* fetch our @ISA */
254     gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
255     av = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
256
257     /* "stored" is used to keep track of all of the classnames we have added to
258        the MRO so far, so we can do a quick exists check and avoid adding
259        duplicate classnames to the MRO as we go.
260        It's then retained to be re-used as a fast lookup for ->isa(), by adding
261        our own name and "UNIVERSAL" to it.  */
262
263     if(av && AvFILLp(av) >= 0) {
264
265         SV **svp = AvARRAY(av);
266         I32 items = AvFILLp(av) + 1;
267
268         /* foreach(@ISA) */
269         while (items--) {
270             SV* const sv = *svp++;
271             HV* const basestash = gv_stashsv(sv, 0);
272             SV *const *subrv_p;
273             I32 subrv_items;
274
275             if (!basestash) {
276                 /* if no stash exists for this @ISA member,
277                    simply add it to the MRO and move on */
278                 subrv_p = &sv;
279                 subrv_items = 1;
280             }
281             else {
282                 /* otherwise, recurse into ourselves for the MRO
283                    of this @ISA member, and append their MRO to ours.
284                    The recursive call could throw an exception, which
285                    has memory management implications here, hence the use of
286                    the mortal.  */
287                 const AV *const subrv
288                     = mro_get_linear_isa_dfs(basestash, level + 1);
289
290                 subrv_p = AvARRAY(subrv);
291                 subrv_items = AvFILLp(subrv) + 1;
292             }
293             if (stored) {
294                 while(subrv_items--) {
295                     SV *const subsv = *subrv_p++;
296                     /* LVALUE fetch will create a new undefined SV if necessary
297                      */
298                     HE *const he = hv_fetch_ent(stored, subsv, 1, 0);
299                     assert(he);
300                     if(HeVAL(he) != &PL_sv_undef) {
301                         /* It was newly created.  Steal it for our new SV, and
302                            replace it in the hash with the "real" thing.  */
303                         SV *const val = HeVAL(he);
304                         HEK *const key = HeKEY_hek(he);
305
306                         HeVAL(he) = &PL_sv_undef;
307                         /* Save copying by making a shared hash key scalar. We
308                            inline this here rather than calling
309                            Perl_newSVpvn_share because we already have the
310                            scalar, and we already have the hash key.  */
311                         assert(SvTYPE(val) == SVt_NULL);
312                         sv_upgrade(val, SVt_PV);
313                         SvPV_set(val, HEK_KEY(share_hek_hek(key)));
314                         SvCUR_set(val, HEK_LEN(key));
315                         SvIsCOW_on(val);
316                         SvPOK_on(val);
317                         if (HEK_UTF8(key))
318                             SvUTF8_on(val);
319
320                         av_push(retval, val);
321                     }
322                 }
323             } else {
324                 /* We are the first (or only) parent. We can short cut the
325                    complexity above, because our @ISA is simply us prepended
326                    to our parent's @ISA, and our ->isa cache is simply our
327                    parent's, with our name added.  */
328                 /* newSVsv() is slow. This code is only faster if we can avoid
329                    it by ensuring that SVs in the arrays are shared hash key
330                    scalar SVs, because we can "copy" them very efficiently.
331                    Although to be fair, we can't *ensure* this, as a reference
332                    to the internal array is returned by mro::get_linear_isa(),
333                    so we'll have to be defensive just in case someone faffed
334                    with it.  */
335                 if (basestash) {
336                     SV **svp;
337                     stored = MUTABLE_HV(sv_2mortal((SV*)newHVhv(HvMROMETA(basestash)->isa)));
338                     av_extend(retval, subrv_items);
339                     AvFILLp(retval) = subrv_items;
340                     svp = AvARRAY(retval);
341                     while(subrv_items--) {
342                         SV *const val = *subrv_p++;
343                         *++svp = SvIsCOW_shared_hash(val)
344                             ? newSVhek(SvSHARED_HEK_FROM_PV(SvPVX(val)))
345                             : newSVsv(val);
346                     }
347                 } else {
348                     /* They have no stash.  So create ourselves an ->isa cache
349                        as if we'd copied it from what theirs should be.  */
350                     stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
351                     (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
352                     av_push(retval,
353                             newSVhek(HeKEY_hek(hv_store_ent(stored, sv,
354                                                             &PL_sv_undef, 0))));
355                 }
356             }
357         }
358     } else {
359         /* We have no parents.  */
360         stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
361         (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
362     }
363
364     (void) hv_store_ent(stored, our_name, &PL_sv_undef, 0);
365
366     SvREFCNT_inc_simple_void_NN(stored);
367     SvTEMP_off(stored);
368     SvREADONLY_on(stored);
369
370     meta->isa = stored;
371
372     /* now that we're past the exception dangers, grab our own reference to
373        the AV we're about to use for the result. The reference owned by the
374        mortals' stack will be released soon, so everything will balance.  */
375     SvREFCNT_inc_simple_void_NN(retval);
376     SvTEMP_off(retval);
377
378     /* we don't want anyone modifying the cache entry but us,
379        and we do so by replacing it completely */
380     SvREADONLY_on(retval);
381
382     return MUTABLE_AV(Perl_mro_set_private_data(aTHX_ meta, &dfs_alg,
383                                                 MUTABLE_SV(retval)));
384 }
385
386 /*
387 =for apidoc mro_get_linear_isa
388
389 Returns the mro linearisation for the given stash.  By default, this
390 will be whatever C<mro_get_linear_isa_dfs> returns unless some
391 other MRO is in effect for the stash.  The return value is a
392 read-only AV*.
393
394 You are responsible for C<SvREFCNT_inc()> on the
395 return value if you plan to store it anywhere
396 semi-permanently (otherwise it might be deleted
397 out from under you the next time the cache is
398 invalidated).
399
400 =cut
401 */
402 AV*
403 Perl_mro_get_linear_isa(pTHX_ HV *stash)
404 {
405     struct mro_meta* meta;
406     AV *isa;
407
408     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA;
409     if(!SvOOK(stash))
410         Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
411
412     meta = HvMROMETA(stash);
413     if (!meta->mro_which)
414         Perl_croak(aTHX_ "panic: invalid MRO!");
415     isa = meta->mro_which->resolve(aTHX_ stash, 0);
416
417     if (meta->mro_which != &dfs_alg) { /* skip for dfs, for speed */
418         SV * const namesv =
419             (HvENAME(stash)||HvNAME(stash))
420               ? newSVhek(HvENAME_HEK(stash)
421                           ? HvENAME_HEK(stash)
422                           : HvNAME_HEK(stash))
423               : NULL;
424
425         if(namesv && (AvFILLp(isa) == -1 || !sv_eq(*AvARRAY(isa), namesv)))
426         {
427             AV * const old = isa;
428             SV **svp;
429             SV **ovp = AvARRAY(old);
430             SV * const * const oend = ovp + AvFILLp(old) + 1;
431             isa = (AV *)sv_2mortal((SV *)newAV());
432             av_extend(isa, AvFILLp(isa) = AvFILLp(old)+1);
433             *AvARRAY(isa) = namesv;
434             svp = AvARRAY(isa)+1;
435             while (ovp < oend) *svp++ = SvREFCNT_inc(*ovp++);
436         }
437         else SvREFCNT_dec(namesv);
438     }
439
440     if (!meta->isa) {
441             HV *const isa_hash = newHV();
442             /* Linearisation didn't build it for us, so do it here.  */
443             SV *const *svp = AvARRAY(isa);
444             SV *const *const svp_end = svp + AvFILLp(isa) + 1;
445             const HEK *canon_name = HvENAME_HEK(stash);
446             if (!canon_name) canon_name = HvNAME_HEK(stash);
447
448             while (svp < svp_end) {
449                 (void) hv_store_ent(isa_hash, *svp++, &PL_sv_undef, 0);
450             }
451
452             (void) hv_common(isa_hash, NULL, HEK_KEY(canon_name),
453                              HEK_LEN(canon_name), HEK_FLAGS(canon_name),
454                              HV_FETCH_ISSTORE, &PL_sv_undef,
455                              HEK_HASH(canon_name));
456             (void) hv_store(isa_hash, "UNIVERSAL", 9, &PL_sv_undef, 0);
457
458             SvREADONLY_on(isa_hash);
459
460             meta->isa = isa_hash;
461     }
462
463     return isa;
464 }
465
466 /*
467 =for apidoc mro_isa_changed_in
468
469 Takes the necessary steps (cache invalidations, mostly)
470 when the @ISA of the given package has changed.  Invoked
471 by the C<setisa> magic, should not need to invoke directly.
472
473 =cut
474 */
475
476 /* Macro to avoid repeating the code five times. */
477 #define CLEAR_LINEAR(mEta)                                     \
478     if (mEta->mro_linear_all) {                                 \
479         SvREFCNT_dec(MUTABLE_SV(mEta->mro_linear_all));          \
480         mEta->mro_linear_all = NULL;                              \
481         /* This is just acting as a shortcut pointer.  */          \
482         mEta->mro_linear_current = NULL;                            \
483     } else if (mEta->mro_linear_current) {                           \
484         /* Only the current MRO is stored, so this owns the data.  */ \
485         SvREFCNT_dec(mEta->mro_linear_current);                        \
486         mEta->mro_linear_current = NULL;                                \
487     }
488
489 void
490 Perl_mro_isa_changed_in(pTHX_ HV* stash)
491 {
492     dVAR;
493     HV* isarev;
494     AV* linear_mro;
495     HE* iter;
496     SV** svp;
497     I32 items;
498     bool is_universal;
499     struct mro_meta * meta;
500     HV *isa = NULL;
501
502     const char * const stashname = HvENAME_get(stash);
503     const STRLEN stashname_len = HvENAMELEN_get(stash);
504     const bool stashname_utf8  = HvENAMEUTF8(stash) ? 1 : 0;
505
506     PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN;
507
508     if(!stashname)
509         Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
510
511
512     /* wipe out the cached linearizations for this stash */
513     meta = HvMROMETA(stash);
514     CLEAR_LINEAR(meta);
515     if (meta->isa) {
516         /* Steal it for our own purposes. */
517         isa = (HV *)sv_2mortal((SV *)meta->isa);
518         meta->isa = NULL;
519     }
520
521     /* Inc the package generation, since our @ISA changed */
522     meta->pkg_gen++;
523
524     /* Wipe the global method cache if this package
525        is UNIVERSAL or one of its parents */
526
527     svp = hv_fetch(PL_isarev, stashname,
528                         stashname_utf8 ? -(I32)stashname_len : (I32)stashname_len, 0);
529     isarev = svp ? MUTABLE_HV(*svp) : NULL;
530
531     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
532         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
533         PL_sub_generation++;
534         is_universal = TRUE;
535     }
536     else { /* Wipe the local method cache otherwise */
537         meta->cache_gen++;
538         is_universal = FALSE;
539     }
540
541     /* wipe next::method cache too */
542     if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
543
544     /* Changes to @ISA might turn overloading on */
545     HvAMAGIC_on(stash);
546
547     /* DESTROY can be cached in SvSTASH. */
548     if (!SvOBJECT(stash)) SvSTASH(stash) = NULL;
549
550     /* Iterate the isarev (classes that are our children),
551        wiping out their linearization, method and isa caches
552        and upating PL_isarev. */
553     if(isarev) {
554         HV *isa_hashes = NULL;
555
556        /* We have to iterate through isarev twice to avoid a chicken and
557         * egg problem: if A inherits from B and both are in isarev, A might
558         * be processed before B and use B's previous linearisation.
559         */
560
561        /* First iteration: Wipe everything, but stash away the isa hashes
562         * since we still need them for updating PL_isarev.
563         */
564
565         if(hv_iterinit(isarev)) {
566             /* Only create the hash if we need it; i.e., if isarev has
567                any elements. */
568             isa_hashes = (HV *)sv_2mortal((SV *)newHV());
569         }
570         while((iter = hv_iternext(isarev))) {
571             HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0);
572             struct mro_meta* revmeta;
573
574             if(!revstash) continue;
575             revmeta = HvMROMETA(revstash);
576             CLEAR_LINEAR(revmeta);
577             if(!is_universal)
578                 revmeta->cache_gen++;
579             if(revmeta->mro_nextmethod)
580                 hv_clear(revmeta->mro_nextmethod);
581             if (!SvOBJECT(revstash)) SvSTASH(revstash) = NULL;
582
583             (void)
584               hv_store(
585                isa_hashes, (const char*)&revstash, sizeof(HV *),
586                revmeta->isa ? (SV *)revmeta->isa : &PL_sv_undef, 0
587               );
588             revmeta->isa = NULL;
589         }
590
591        /* Second pass: Update PL_isarev. We can just use isa_hashes to
592         * avoid another round of stash lookups. */
593
594        /* isarev might be deleted from PL_isarev during this loop, so hang
595         * on to it. */
596         SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)isarev));
597
598         if(isa_hashes) {
599             hv_iterinit(isa_hashes);
600             while((iter = hv_iternext(isa_hashes))) {
601                 HV* const revstash = *(HV **)HEK_KEY(HeKEY_hek(iter));
602                 HV * const isa = (HV *)HeVAL(iter);
603                 const HEK *namehek;
604
605                 /* We're starting at the 2nd element, skipping revstash */
606                 linear_mro = mro_get_linear_isa(revstash);
607                 svp = AvARRAY(linear_mro) + 1;
608                 items = AvFILLp(linear_mro);
609
610                 namehek = HvENAME_HEK(revstash);
611                 if (!namehek) namehek = HvNAME_HEK(revstash);
612
613                 while (items--) {
614                     SV* const sv = *svp++;
615                     HV* mroisarev;
616
617                     HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
618
619                     /* That fetch should not fail.  But if it had to create
620                        a new SV for us, then will need to upgrade it to an
621                        HV (which sv_upgrade() can now do for us). */
622
623                     mroisarev = MUTABLE_HV(HeVAL(he));
624
625                     SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
626
627                     /* This hash only ever contains PL_sv_yes. Storing it
628                        over itself is almost as cheap as calling hv_exists,
629                        so on aggregate we expect to save time by not making
630                        two calls to the common HV code for the case where
631                        it doesn't exist.  */
632            
633                     (void)
634                       hv_store(
635                        mroisarev, HEK_KEY(namehek),
636                        HEK_UTF8(namehek) ? -HEK_LEN(namehek) : HEK_LEN(namehek),
637                        &PL_sv_yes, 0
638                       );
639                 }
640
641                 if((SV *)isa != &PL_sv_undef)
642                     mro_clean_isarev(
643                      isa, HEK_KEY(namehek), HEK_LEN(namehek),
644                      HvMROMETA(revstash)->isa, (HEK_UTF8(namehek) ? SVf_UTF8 : 0)
645                     );
646             }
647         }
648     }
649
650     /* Now iterate our MRO (parents), adding ourselves and everything from
651        our isarev to their isarev.
652     */
653
654     /* We're starting at the 2nd element, skipping ourselves here */
655     linear_mro = mro_get_linear_isa(stash);
656     svp = AvARRAY(linear_mro) + 1;
657     items = AvFILLp(linear_mro);
658
659     while (items--) {
660         SV* const sv = *svp++;
661         HV* mroisarev;
662
663         HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
664
665         /* That fetch should not fail.  But if it had to create a new SV for
666            us, then will need to upgrade it to an HV (which sv_upgrade() can
667            now do for us. */
668
669         mroisarev = MUTABLE_HV(HeVAL(he));
670
671         SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
672
673         /* This hash only ever contains PL_sv_yes. Storing it over itself is
674            almost as cheap as calling hv_exists, so on aggregate we expect to
675            save time by not making two calls to the common HV code for the
676            case where it doesn't exist.  */
677            
678         (void)hv_store(mroisarev, stashname,
679                 stashname_utf8 ? -(I32)stashname_len : (I32)stashname_len, &PL_sv_yes, 0);
680     }
681
682     /* Delete our name from our former parents' isarevs. */
683     if(isa && HvARRAY(isa))
684         mro_clean_isarev(isa, stashname, stashname_len, meta->isa,
685                                 (stashname_utf8 ? SVf_UTF8 : 0) );
686 }
687
688 /* Deletes name from all the isarev entries listed in isa */
689 STATIC void
690 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
691                          const STRLEN len, HV * const exceptions, U32 flags)
692 {
693     HE* iter;
694
695     PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
696
697     /* Delete our name from our former parents' isarevs. */
698     if(isa && HvARRAY(isa) && hv_iterinit(isa)) {
699         SV **svp;
700         while((iter = hv_iternext(isa))) {
701             I32 klen;
702             const char * const key = hv_iterkey(iter, &klen);
703             if(exceptions && hv_exists(exceptions, key, HeKUTF8(iter) ? -klen : klen))
704                 continue;
705             svp = hv_fetch(PL_isarev, key, HeKUTF8(iter) ? -klen : klen, 0);
706             if(svp) {
707                 HV * const isarev = (HV *)*svp;
708                 (void)hv_delete(isarev, name, (flags & SVf_UTF8) ? -(I32)len : (I32)len, G_DISCARD);
709                 if(!HvARRAY(isarev) || !HvUSEDKEYS(isarev))
710                     (void)hv_delete(PL_isarev, key,
711                                         HeKUTF8(iter) ? -klen : klen, G_DISCARD);
712             }
713         }
714     }
715 }
716
717 /*
718 =for apidoc mro_package_moved
719
720 Call this function to signal to a stash that it has been assigned to
721 another spot in the stash hierarchy.  C<stash> is the stash that has been
722 assigned. C<oldstash> is the stash it replaces, if any.  C<gv> is the glob
723 that is actually being assigned to.
724
725 This can also be called with a null first argument to
726 indicate that C<oldstash> has been deleted.
727
728 This function invalidates isa caches on the old stash, on all subpackages
729 nested inside it, and on the subclasses of all those, including
730 non-existent packages that have corresponding entries in C<stash>.
731
732 It also sets the effective names (C<HvENAME>) on all the stashes as
733 appropriate.
734
735 If the C<gv> is present and is not in the symbol table, then this function
736 simply returns.  This checked will be skipped if C<flags & 1>.
737
738 =cut
739 */
740 void
741 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
742                        const GV * const gv, U32 flags)
743 {
744     SV *namesv;
745     HEK **namep;
746     I32 name_count;
747     HV *stashes;
748     HE* iter;
749
750     PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED;
751     assert(stash || oldstash);
752
753     /* Determine the name(s) of the location that stash was assigned to
754      * or from which oldstash was removed.
755      *
756      * We cannot reliably use the name in oldstash, because it may have
757      * been deleted from the location in the symbol table that its name
758      * suggests, as in this case:
759      *
760      *   $globref = \*foo::bar::;
761      *   Symbol::delete_package("foo");
762      *   *$globref = \%baz::;
763      *   *$globref = *frelp::;
764      *      # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
765      *
766      * So we get it from the gv. But, since the gv may no longer be in the
767      * symbol table, we check that first. The only reliable way to tell is
768      * to see whether its stash has an effective name and whether the gv
769      * resides in that stash under its name. That effective name may be
770      * different from what gv_fullname4 would use.
771      * If flags & 1, the caller has asked us to skip the check.
772      */
773     if(!(flags & 1)) {
774         SV **svp;
775         if(
776          !GvSTASH(gv) || !HvENAME(GvSTASH(gv)) ||
777          !(svp = hv_fetch(GvSTASH(gv), GvNAME(gv),
778                             GvNAMEUTF8(gv) ? -GvNAMELEN(gv) : GvNAMELEN(gv), 0)) ||
779          *svp != (SV *)gv
780         ) return;
781     }
782     assert(SvOOK(GvSTASH(gv)));
783     assert(GvNAMELEN(gv));
784     assert(GvNAME(gv)[GvNAMELEN(gv) - 1] == ':');
785     assert(GvNAMELEN(gv) == 1 || GvNAME(gv)[GvNAMELEN(gv) - 2] == ':');
786     name_count = HvAUX(GvSTASH(gv))->xhv_name_count;
787     if (!name_count) {
788         name_count = 1;
789         namep = &HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_name;
790     }
791     else {
792         namep = HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_names;
793         if (name_count < 0) ++namep, name_count = -name_count - 1;
794     }
795     if (name_count == 1) {
796         if (HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)) {
797             namesv = GvNAMELEN(gv) == 1
798                 ? newSVpvs_flags(":", SVs_TEMP)
799                 : newSVpvs_flags("",  SVs_TEMP);
800         }
801         else {
802             namesv = sv_2mortal(newSVhek(*namep));
803             if (GvNAMELEN(gv) == 1) sv_catpvs(namesv, ":");
804             else                    sv_catpvs(namesv, "::");
805         }
806         if (GvNAMELEN(gv) != 1) {
807             sv_catpvn_flags(
808                 namesv, GvNAME(gv), GvNAMELEN(gv) - 2,
809                                           /* skip trailing :: */
810                 GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES
811             );
812         }
813     }
814     else {
815         SV *aname;
816         namesv = sv_2mortal((SV *)newAV());
817         while (name_count--) {
818             if(HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)){
819                 aname = GvNAMELEN(gv) == 1
820                          ? newSVpvs(":")
821                          : newSVpvs("");
822                 namep++;
823             }
824             else {
825                 aname = newSVhek(*namep++);
826                 if (GvNAMELEN(gv) == 1) sv_catpvs(aname, ":");
827                 else                    sv_catpvs(aname, "::");
828             }
829             if (GvNAMELEN(gv) != 1) {
830                 sv_catpvn_flags(
831                     aname, GvNAME(gv), GvNAMELEN(gv) - 2,
832                                           /* skip trailing :: */
833                     GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES
834                 );
835             }
836             av_push((AV *)namesv, aname);
837         }
838     }
839
840     /* Get a list of all the affected classes. */
841     /* We cannot simply pass them all to mro_isa_changed_in to avoid
842        the list, as that function assumes that only one package has
843        changed. It does not work with:
844
845           @foo::ISA = qw( B B::B );
846           *B:: = delete $::{"A::"};
847
848        as neither B nor B::B can be updated before the other, since they
849        will reset caches on foo, which will see either B or B::B with the
850        wrong name. The names must be set on *all* affected stashes before
851        we do anything else. (And linearisations must be cleared, too.)
852      */
853     stashes = (HV *) sv_2mortal((SV *)newHV());
854     mro_gather_and_rename(
855      stashes, (HV *) sv_2mortal((SV *)newHV()),
856      stash, oldstash, namesv
857     );
858
859     /* Once the caches have been wiped on all the classes, call
860        mro_isa_changed_in on each. */
861     hv_iterinit(stashes);
862     while((iter = hv_iternext(stashes))) {
863         HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
864         if(HvENAME(stash)) {
865             /* We have to restore the original meta->isa (that
866                mro_gather_and_rename set aside for us) this way, in case
867                one class in this list is a superclass of a another class
868                that we have already encountered. In such a case, meta->isa
869                will have been overwritten without old entries being deleted 
870                from PL_isarev. */
871             struct mro_meta * const meta = HvMROMETA(stash);
872             if(meta->isa != (HV *)HeVAL(iter)){
873                 SvREFCNT_dec(meta->isa);
874                 meta->isa
875                  = HeVAL(iter) == &PL_sv_yes
876                     ? NULL
877                     : (HV *)HeVAL(iter);
878                 HeVAL(iter) = NULL; /* We donated our reference count. */
879             }
880             mro_isa_changed_in(stash);
881         }
882     }
883 }
884
885 STATIC void
886 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
887                               HV *stash, HV *oldstash, SV *namesv)
888 {
889     XPVHV* xhv;
890     HE *entry;
891     I32 riter = -1;
892     I32 items = 0;
893     const bool stash_had_name = stash && HvENAME(stash);
894     bool fetched_isarev = FALSE;
895     HV *seen = NULL;
896     HV *isarev = NULL;
897     SV **svp = NULL;
898
899     PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
900
901     /* We use the seen_stashes hash to keep track of which packages have
902        been encountered so far. This must be separate from the main list of
903        stashes, as we need to distinguish between stashes being assigned
904        and stashes being replaced/deleted. (A nested stash can be on both
905        sides of an assignment. We cannot simply skip iterating through a
906        stash on the right if we have seen it on the left, as it will not
907        get its ename assigned to it.)
908
909        To avoid allocating extra SVs, instead of a bitfield we can make
910        bizarre use of immortals:
911
912         &PL_sv_undef:  seen on the left  (oldstash)
913         &PL_sv_no   :  seen on the right (stash)
914         &PL_sv_yes  :  seen on both sides
915
916      */
917
918     if(oldstash) {
919         /* Add to the big list. */
920         struct mro_meta * meta;
921         HE * const entry
922          = (HE *)
923              hv_common(
924               seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
925               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
926              );
927         if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
928             oldstash = NULL;
929             goto check_stash;
930         }
931         HeVAL(entry)
932          = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
933         meta = HvMROMETA(oldstash);
934         (void)
935           hv_store(
936            stashes, (const char *)&oldstash, sizeof(HV *),
937            meta->isa
938             ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
939             : &PL_sv_yes,
940            0
941           );
942         CLEAR_LINEAR(meta);
943
944         /* Update the effective name. */
945         if(HvENAME_get(oldstash)) {
946             const HEK * const enamehek = HvENAME_HEK(oldstash);
947             if(SvTYPE(namesv) == SVt_PVAV) {
948                 items = AvFILLp((AV *)namesv) + 1;
949                 svp = AvARRAY((AV *)namesv);
950             }
951             else {
952                 items = 1;
953                 svp = &namesv;
954             }
955             while (items--) {
956                 const U32 name_utf8 = SvUTF8(*svp);
957                 STRLEN len;
958                 const char *name = SvPVx_const(*svp, len);
959                 if(PL_stashcache) {
960                     DEBUG_o(Perl_deb(aTHX_ "mro_gather_and_rename clearing PL_stashcache for '%"SVf"'\n",
961                                      *svp));
962                    (void)hv_delete(PL_stashcache, name, name_utf8 ? -(I32)len : (I32)len, G_DISCARD);
963                 }
964                 ++svp;
965                 hv_ename_delete(oldstash, name, len, name_utf8);
966
967                 if (!fetched_isarev) {
968                     /* If the name deletion caused a name change, then we
969                      * are not going to call mro_isa_changed_in with this
970                      * name (and not at all if it has become anonymous) so
971                      * we need to delete old isarev entries here, both
972                      * those in the superclasses and this class's own list
973                      * of subclasses. We simply delete the latter from
974                      * PL_isarev, since we still need it. hv_delete morti-
975                      * fies it for us, so sv_2mortal is not necessary. */
976                     if(HvENAME_HEK(oldstash) != enamehek) {
977                         if(meta->isa && HvARRAY(meta->isa))
978                             mro_clean_isarev(meta->isa, name, len, 0, name_utf8);
979                         isarev = (HV *)hv_delete(PL_isarev, name,
980                                                     name_utf8 ? -(I32)len : (I32)len, 0);
981                         fetched_isarev=TRUE;
982                     }
983                 }
984             }
985         }
986     }
987    check_stash:
988     if(stash) {
989         if(SvTYPE(namesv) == SVt_PVAV) {
990             items = AvFILLp((AV *)namesv) + 1;
991             svp = AvARRAY((AV *)namesv);
992         }
993         else {
994             items = 1;
995             svp = &namesv;
996         }
997         while (items--) {
998             const U32 name_utf8 = SvUTF8(*svp);
999             STRLEN len;
1000             const char *name = SvPVx_const(*svp++, len);
1001             hv_ename_add(stash, name, len, name_utf8);
1002         }
1003
1004        /* Add it to the big list if it needs
1005         * mro_isa_changed_in called on it. That happens if it was
1006         * detached from the symbol table (so it had no HvENAME) before
1007         * being assigned to the spot named by the 'name' variable, because
1008         * its cached isa linearisation is now stale (the effective name
1009         * having changed), and subclasses will then use that cache when
1010         * mro_package_moved calls mro_isa_changed_in. (See
1011         * [perl #77358].)
1012         *
1013         * If it did have a name, then its previous name is still
1014         * used in isa caches, and there is no need for
1015         * mro_package_moved to call mro_isa_changed_in.
1016         */
1017
1018         entry
1019          = (HE *)
1020              hv_common(
1021               seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
1022               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
1023              );
1024         if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
1025             stash = NULL;
1026         else {
1027             HeVAL(entry)
1028              = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
1029             if(!stash_had_name)
1030             {
1031                 struct mro_meta * const meta = HvMROMETA(stash);
1032                 (void)
1033                   hv_store(
1034                    stashes, (const char *)&stash, sizeof(HV *),
1035                    meta->isa
1036                     ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
1037                     : &PL_sv_yes,
1038                    0
1039                   );
1040                 CLEAR_LINEAR(meta);
1041             }
1042         }
1043     }
1044
1045     if(!stash && !oldstash)
1046         /* Both stashes have been encountered already. */
1047         return;
1048
1049     /* Add all the subclasses to the big list. */
1050     if(!fetched_isarev) {
1051         /* If oldstash is not null, then we can use its HvENAME to look up
1052            the isarev hash, since all its subclasses will be listed there.
1053            It will always have an HvENAME. It the HvENAME was removed
1054            above, then fetch_isarev will be true, and this code will not be
1055            reached.
1056
1057            If oldstash is null, then this is an empty spot with no stash in
1058            it, so subclasses could be listed in isarev hashes belonging to
1059            any of the names, so we have to check all of them.
1060          */
1061         assert(!oldstash || HvENAME(oldstash));
1062         if (oldstash) {
1063             /* Extra variable to avoid a compiler warning */
1064             char * const hvename = HvENAME(oldstash);
1065             fetched_isarev = TRUE;
1066             svp = hv_fetch(PL_isarev, hvename,
1067                             HvENAMEUTF8(oldstash)
1068                                 ? -HvENAMELEN_get(oldstash)
1069                                 : HvENAMELEN_get(oldstash), 0);
1070             if (svp) isarev = MUTABLE_HV(*svp);
1071         }
1072         else if(SvTYPE(namesv) == SVt_PVAV) {
1073             items = AvFILLp((AV *)namesv) + 1;
1074             svp = AvARRAY((AV *)namesv);
1075         }
1076         else {
1077             items = 1;
1078             svp = &namesv;
1079         }
1080     }
1081     if(
1082         isarev || !fetched_isarev
1083     ) {
1084       while (fetched_isarev || items--) {
1085         HE *iter;
1086
1087         if (!fetched_isarev) {
1088             HE * const he = hv_fetch_ent(PL_isarev, *svp++, 0, 0);
1089             if (!he || !(isarev = MUTABLE_HV(HeVAL(he)))) continue;
1090         }
1091
1092         hv_iterinit(isarev);
1093         while((iter = hv_iternext(isarev))) {
1094             HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0);
1095             struct mro_meta * meta;
1096
1097             if(!revstash) continue;
1098             meta = HvMROMETA(revstash);
1099             (void)
1100               hv_store(
1101                stashes, (const char *)&revstash, sizeof(HV *),
1102                meta->isa
1103                 ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
1104                 : &PL_sv_yes,
1105                0
1106               );
1107             CLEAR_LINEAR(meta);
1108         }
1109
1110         if (fetched_isarev) break;
1111       }
1112     }
1113
1114     /* This is partly based on code in hv_iternext_flags. We are not call-
1115        ing that here, as we want to avoid resetting the hash iterator. */
1116
1117     /* Skip the entire loop if the hash is empty.   */
1118     if(oldstash && HvUSEDKEYS(oldstash)) { 
1119         xhv = (XPVHV*)SvANY(oldstash);
1120         seen = (HV *) sv_2mortal((SV *)newHV());
1121
1122         /* Iterate through entries in the oldstash, adding them to the
1123            list, meanwhile doing the equivalent of $seen{$key} = 1.
1124          */
1125
1126         while (++riter <= (I32)xhv->xhv_max) {
1127             entry = (HvARRAY(oldstash))[riter];
1128
1129             /* Iterate through the entries in this list */
1130             for(; entry; entry = HeNEXT(entry)) {
1131                 const char* key;
1132                 I32 len;
1133
1134                 /* If this entry is not a glob, ignore it.
1135                    Try the next.  */
1136                 if (!isGV(HeVAL(entry))) continue;
1137
1138                 key = hv_iterkey(entry, &len);
1139                 if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
1140                  || (len == 1 && key[0] == ':')) {
1141                     HV * const oldsubstash = GvHV(HeVAL(entry));
1142                     SV ** const stashentry
1143                      = stash ? hv_fetch(stash, key, HeUTF8(entry) ? -(I32)len : (I32)len, 0) : NULL;
1144                     HV *substash = NULL;
1145
1146                     /* Avoid main::main::main::... */
1147                     if(oldsubstash == oldstash) continue;
1148
1149                     if(
1150                         (
1151                             stashentry && *stashentry
1152                          && (substash = GvHV(*stashentry))
1153                         )
1154                      || (oldsubstash && HvENAME_get(oldsubstash))
1155                     )
1156                     {
1157                         /* Add :: and the key (minus the trailing ::)
1158                            to each name. */
1159                         SV *subname;
1160                         if(SvTYPE(namesv) == SVt_PVAV) {
1161                             SV *aname;
1162                             items = AvFILLp((AV *)namesv) + 1;
1163                             svp = AvARRAY((AV *)namesv);
1164                             subname = sv_2mortal((SV *)newAV());
1165                             while (items--) {
1166                                 aname = newSVsv(*svp++);
1167                                 if (len == 1)
1168                                     sv_catpvs(aname, ":");
1169                                 else {
1170                                     sv_catpvs(aname, "::");
1171                                     sv_catpvn_flags(
1172                                         aname, key, len-2,
1173                                         HeUTF8(entry)
1174                                            ? SV_CATUTF8 : SV_CATBYTES
1175                                     );
1176                                 }
1177                                 av_push((AV *)subname, aname);
1178                             }
1179                         }
1180                         else {
1181                             subname = sv_2mortal(newSVsv(namesv));
1182                             if (len == 1) sv_catpvs(subname, ":");
1183                             else {
1184                                 sv_catpvs(subname, "::");
1185                                 sv_catpvn_flags(
1186                                    subname, key, len-2,
1187                                    HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES
1188                                 );
1189                             }
1190                         }
1191                         mro_gather_and_rename(
1192                              stashes, seen_stashes,
1193                              substash, oldsubstash, subname
1194                         );
1195                     }
1196
1197                     (void)hv_store(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len, &PL_sv_yes, 0);
1198                 }
1199             }
1200         }
1201     }
1202
1203     /* Skip the entire loop if the hash is empty.   */
1204     if (stash && HvUSEDKEYS(stash)) {
1205         xhv = (XPVHV*)SvANY(stash);
1206         riter = -1;
1207
1208         /* Iterate through the new stash, skipping $seen{$key} items,
1209            calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
1210         while (++riter <= (I32)xhv->xhv_max) {
1211             entry = (HvARRAY(stash))[riter];
1212
1213             /* Iterate through the entries in this list */
1214             for(; entry; entry = HeNEXT(entry)) {
1215                 const char* key;
1216                 I32 len;
1217
1218                 /* If this entry is not a glob, ignore it.
1219                    Try the next.  */
1220                 if (!isGV(HeVAL(entry))) continue;
1221
1222                 key = hv_iterkey(entry, &len);
1223                 if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
1224                  || (len == 1 && key[0] == ':')) {
1225                     HV *substash;
1226
1227                     /* If this entry was seen when we iterated through the
1228                        oldstash, skip it. */
1229                     if(seen && hv_exists(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len)) continue;
1230
1231                     /* We get here only if this stash has no corresponding
1232                        entry in the stash being replaced. */
1233
1234                     substash = GvHV(HeVAL(entry));
1235                     if(substash) {
1236                         SV *subname;
1237
1238                         /* Avoid checking main::main::main::... */
1239                         if(substash == stash) continue;
1240
1241                         /* Add :: and the key (minus the trailing ::)
1242                            to each name. */
1243                         if(SvTYPE(namesv) == SVt_PVAV) {
1244                             SV *aname;
1245                             items = AvFILLp((AV *)namesv) + 1;
1246                             svp = AvARRAY((AV *)namesv);
1247                             subname = sv_2mortal((SV *)newAV());
1248                             while (items--) {
1249                                 aname = newSVsv(*svp++);
1250                                 if (len == 1)
1251                                     sv_catpvs(aname, ":");
1252                                 else {
1253                                     sv_catpvs(aname, "::");
1254                                     sv_catpvn_flags(
1255                                         aname, key, len-2,
1256                                         HeUTF8(entry)
1257                                            ? SV_CATUTF8 : SV_CATBYTES
1258                                     );
1259                                 }
1260                                 av_push((AV *)subname, aname);
1261                             }
1262                         }
1263                         else {
1264                             subname = sv_2mortal(newSVsv(namesv));
1265                             if (len == 1) sv_catpvs(subname, ":");
1266                             else {
1267                                 sv_catpvs(subname, "::");
1268                                 sv_catpvn_flags(
1269                                    subname, key, len-2,
1270                                    HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES
1271                                 );
1272                             }
1273                         }
1274                         mro_gather_and_rename(
1275                           stashes, seen_stashes,
1276                           substash, NULL, subname
1277                         );
1278                     }
1279                 }
1280             }
1281         }
1282     }
1283 }
1284
1285 /*
1286 =for apidoc mro_method_changed_in
1287
1288 Invalidates method caching on any child classes
1289 of the given stash, so that they might notice
1290 the changes in this one.
1291
1292 Ideally, all instances of C<PL_sub_generation++> in
1293 perl source outside of F<mro.c> should be
1294 replaced by calls to this.
1295
1296 Perl automatically handles most of the common
1297 ways a method might be redefined.  However, there
1298 are a few ways you could change a method in a stash
1299 without the cache code noticing, in which case you
1300 need to call this method afterwards:
1301
1302 1) Directly manipulating the stash HV entries from
1303 XS code.
1304
1305 2) Assigning a reference to a readonly scalar
1306 constant into a stash entry in order to create
1307 a constant subroutine (like constant.pm
1308 does).
1309
1310 This same method is available from pure perl
1311 via, C<mro::method_changed_in(classname)>.
1312
1313 =cut
1314 */
1315 void
1316 Perl_mro_method_changed_in(pTHX_ HV *stash)
1317 {
1318     const char * const stashname = HvENAME_get(stash);
1319     const STRLEN stashname_len = HvENAMELEN_get(stash);
1320     const bool stashname_utf8 = HvENAMEUTF8(stash) ? 1 : 0;
1321
1322     SV ** const svp = hv_fetch(PL_isarev, stashname,
1323                                     stashname_utf8 ? -(I32)stashname_len : (I32)stashname_len, 0);
1324     HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
1325
1326     PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
1327
1328     if(!stashname)
1329         Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
1330
1331     /* Inc the package generation, since a local method changed */
1332     HvMROMETA(stash)->pkg_gen++;
1333
1334     /* DESTROY can be cached in SvSTASH. */
1335     if (!SvOBJECT(stash)) SvSTASH(stash) = NULL;
1336
1337     /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
1338        invalidate all method caches globally */
1339     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
1340         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
1341         PL_sub_generation++;
1342         return;
1343     }
1344
1345     /* else, invalidate the method caches of all child classes,
1346        but not itself */
1347     if(isarev) {
1348         HE* iter;
1349
1350         hv_iterinit(isarev);
1351         while((iter = hv_iternext(isarev))) {
1352             HV* const revstash = gv_stashsv(hv_iterkeysv(iter), 0);
1353             struct mro_meta* mrometa;
1354
1355             if(!revstash) continue;
1356             mrometa = HvMROMETA(revstash);
1357             mrometa->cache_gen++;
1358             if(mrometa->mro_nextmethod)
1359                 hv_clear(mrometa->mro_nextmethod);
1360             if (!SvOBJECT(revstash)) SvSTASH(revstash) = NULL;
1361         }
1362     }
1363
1364     /* The method change may be due to *{$package . "::()"} = \&nil; in
1365        overload.pm. */
1366     HvAMAGIC_on(stash);
1367 }
1368
1369 void
1370 Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
1371 {
1372     const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
1373  
1374     PERL_ARGS_ASSERT_MRO_SET_MRO;
1375
1376     if (!which)
1377         Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
1378
1379     if(meta->mro_which != which) {
1380         if (meta->mro_linear_current && !meta->mro_linear_all) {
1381             /* If we were storing something directly, put it in the hash before
1382                we lose it. */
1383             Perl_mro_set_private_data(aTHX_ meta, meta->mro_which, 
1384                                       MUTABLE_SV(meta->mro_linear_current));
1385         }
1386         meta->mro_which = which;
1387         /* Scrub our cached pointer to the private data.  */
1388         meta->mro_linear_current = NULL;
1389         /* Only affects local method cache, not
1390            even child classes */
1391         meta->cache_gen++;
1392         if(meta->mro_nextmethod)
1393             hv_clear(meta->mro_nextmethod);
1394     }
1395 }
1396
1397 #include "XSUB.h"
1398
1399 XS(XS_mro_method_changed_in);
1400
1401 void
1402 Perl_boot_core_mro(pTHX)
1403 {
1404     dVAR;
1405     static const char file[] = __FILE__;
1406
1407     Perl_mro_register(aTHX_ &dfs_alg);
1408
1409     newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
1410 }
1411
1412 XS(XS_mro_method_changed_in)
1413 {
1414     dVAR;
1415     dXSARGS;
1416     SV* classname;
1417     HV* class_stash;
1418
1419     if(items != 1)
1420         croak_xs_usage(cv, "classname");
1421     
1422     classname = ST(0);
1423
1424     class_stash = gv_stashsv(classname, 0);
1425     if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
1426
1427     mro_method_changed_in(class_stash);
1428
1429     XSRETURN_EMPTY;
1430 }
1431
1432 /*
1433  * Local variables:
1434  * c-indentation-style: bsd
1435  * c-basic-offset: 4
1436  * indent-tabs-mode: nil
1437  * End:
1438  *
1439  * ex: set ts=8 sts=4 sw=4 et:
1440  */