Defer tick materialization during Axes init/clear

eendebakpt · claude · eendebakpt · commit d0bb8ff8b7a5 · 2026-04-18T13:23:17.000+02:00
Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py
@@ -1435,6 +1435,20 @@ def __clear(self):
         self.xaxis.set_clip_path(self.patch)
         self.yaxis.set_clip_path(self.patch)
 
+        # Ensure spines have the correct transform before any subsequent
+        # layout or draw. Spine.__init__ installs ``self.axes.transData`` as
+        # a placeholder; the real blended transform is set by
+        # Spine.set_position (via ``_ensure_position_is_set``).  Historically
+        # this fired as a side effect of tick materialization during clear;
+        # with lazy tick lists that cascade no longer runs, so nudge it here
+        # for spines that still carry the placeholder (projections like
+        # polar or secondary axes install custom transforms and are
+        # skipped).
+        for spine in self.spines.values():
+            if spine._position is None and spine._transform is self.transData:
+                spine._position = ('outward', 0.0)
+                spine.set_transform(spine.get_spine_transform())
+
         if self._sharex is not None:
             self.xaxis.set_visible(xaxis_visible)
             self.patch.set_visible(patch_visible)
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -561,11 +561,23 @@ def __get__(self, instance, owner):
             if self._major:
                 instance.majorTicks = []
                 tick = instance._get_tick(major=True)
+                tick.clipbox = instance.clipbox
+                tick._clippath = instance._clippath
+                tick._clipon = instance._clipon
+                tick.gridline.clipbox = instance.clipbox
+                tick.gridline._clippath = instance._clippath
+                tick.gridline._clipon = instance._clipon
                 instance.majorTicks = [tick]
                 return instance.majorTicks
             else:
                 instance.minorTicks = []
                 tick = instance._get_tick(major=False)
+                tick.clipbox = instance.clipbox
+                tick._clippath = instance._clippath
+                tick._clipon = instance._clipon
+                tick.gridline.clipbox = instance.clipbox
+                tick.gridline._clippath = instance._clippath
+                tick.gridline._clipon = instance._clipon
                 instance.minorTicks = [tick]
                 return instance.minorTicks
 
@@ -908,18 +920,45 @@ def reset_ticks(self):
         Each list starts with a single fresh Tick.
         """
         # Restore the lazy tick lists.
-        try:
-            del self.majorTicks
-        except AttributeError:
-            pass
-        try:
-            del self.minorTicks
-        except AttributeError:
-            pass
-        try:
-            self.set_clip_path(self.axes.patch)
-        except AttributeError:
-            pass
+        had_major = bool(self.__dict__.pop('majorTicks', None))
+        had_minor = bool(self.__dict__.pop('minorTicks', None))
+        if had_major or had_minor:
+            try:
+                self.set_clip_path(self.axes.patch)
+            except AttributeError:
+                pass
+
+    def _existing_ticks(self, major=None):
+        """
+        Yield already-materialized ticks without triggering the lazy descriptor.
+
+        `majorTicks` and `minorTicks` are `_LazyTickList` descriptors that
+        create a fresh `.Tick` on first access. Several internal methods
+        (`set_clip_path`, `set_tick_params`) need to touch every
+        *already-materialized* tick without forcing materialization, because
+        doing so would
+
+        (a) create throwaway Tick objects during ``Axes.__init__`` and
+            ``Axes.__clear`` -- defeating the whole point of the lazy lists --
+            and
+
+        (b) risk re-entering the
+            ``Spine.set_position -> Axis.reset_ticks -> Axis.set_clip_path
+            -> _LazyTickList.__get__ -> Tick.__init__ -> Spine.set_position``
+            cascade.
+
+        Reading the instance ``__dict__`` directly bypasses the descriptor.
+
+        Parameters
+        ----------
+        major : bool, optional
+            If True, yield only major ticks; if False, only minor ticks;
+            if None (default), yield major followed by minor.
+        """
+        if major is None or major:
+            yield from self.__dict__.get('majorTicks', ())
+        if major is None or not major:
+            yield from self.__dict__.get('minorTicks', ())
 
     def minorticks_on(self):
         """
@@ -988,11 +1027,11 @@ def set_tick_params(self, which='major', reset=False, **kwargs):
         else:
             if which in ['major', 'both']:
                 self._major_tick_kw.update(kwtrans)
-                for tick in self.majorTicks:
+                for tick in self._existing_ticks(major=True):
                     tick._apply_params(**kwtrans)
             if which in ['minor', 'both']:
                 self._minor_tick_kw.update(kwtrans)
-                for tick in self.minorTicks:
+                for tick in self._existing_ticks(major=False):
                     tick._apply_params(**kwtrans)
             # labelOn and labelcolor also apply to the offset text.
             if 'label1On' in kwtrans or 'label2On' in kwtrans:
@@ -1131,7 +1170,7 @@ def _translate_tick_params(cls, kw, reverse=False):
 
     def set_clip_path(self, path, transform=None):
         super().set_clip_path(path, transform)
-        for child in self.majorTicks + self.minorTicks:
+        for child in self._existing_ticks():
             child.set_clip_path(path, transform)
         self.stale = True
 
