@@ -20,6 +20,23 @@ Version 2.2.2
   the reporter of `issue #342
   <https://github.com/GrahamDumpleton/wrapt/issues/342>`_.
 
+* When ``@wrapt.lru_cache`` was applied to a method of a class deriving from
+  ``wrapt.ObjectProxy``, the per-instance cache was stored on the wrapped
+  object rather than on the proxy. This is because the proxy ``__setattr__``
+  forwards attribute assignment to the wrapped object for any name that is
+  not a recognised proxy attribute, and the cache attribute name was not one.
+  Storing the cache on the wrapped object had several consequences: the
+  wrapped object was polluted with cache attributes it never defined; the
+  cache held a reference back to the proxy through the bound method it
+  wrapped, so a wrapped object that outlived the proxy kept the proxy alive
+  and prevented its collection; wrapping an object that does not accept
+  arbitrary attributes, such as one using ``__slots__``, caused the first
+  cached call to fail with an ``AttributeError``; and two proxies sharing a
+  single wrapped object shared one cache and could return results computed
+  for the wrong proxy. The cache attribute is now stored on the proxy itself
+  using the proxy ``__self_setattr__`` method when the instance is a wrapt
+  object proxy, falling back to ``setattr`` for ordinary instances.
+
 Version 2.2.1
 -------------
 
 
@@ -71,7 +71,19 @@ def __call__(self, *args, **kwargs):
                         self.__wrapped__
                     )
 
-                    setattr(instance, cache_attr, cache)
+                    # If the instance the method is bound to is a wrapt
+                    # object proxy, a plain setattr() would fall through and
+                    # store the cache on the wrapped object rather than the
+                    # proxy. Proxies expose __self_setattr__() which stores
+                    # the attribute on the proxy itself, so use it when it is
+                    # available and fall back to setattr() otherwise.
+
+                    set_attr = getattr(instance, "__self_setattr__", None)
+
+                    if set_attr is not None:
+                        set_attr(cache_attr, cache)
+                    else:
+                        setattr(instance, cache_attr, cache)
 
         return cache(*args, **kwargs)
 
 
@@ -336,6 +336,92 @@ def test_separate_instances_have_separate_caches(self):
         self.assertEqual(obj2.base_calls, 1)
 
 
+class ProxyWrapped:
+    def __init__(self, a):
+        self.a = a
+
+
+class ProxyCached(wrapt.ObjectProxy):
+    @wrapt.lru_cache
+    def compute(self, x):
+        return self.a + x
+
+
+class ProxyCachedWithState(wrapt.ObjectProxy):
+    def __init__(self, wrapped, factor):
+        super().__init__(wrapped)
+        self._self_factor = factor
+
+    @wrapt.lru_cache
+    def compute(self, x):
+        return self._self_factor * x
+
+
+class SlottedWrapped:
+    __slots__ = ("a",)
+
+    def __init__(self, a):
+        self.a = a
+
+
+class TestObjectProxySubclass(unittest.TestCase):
+    def test_returns_correct_result(self):
+        obj = ProxyCached(ProxyWrapped(1))
+        self.assertEqual(obj.compute(10), 11)
+
+    def test_caching(self):
+        obj = ProxyCached(ProxyWrapped(1))
+        obj.compute(10)
+        obj.compute(10)
+        info = obj.compute.cache_info()
+        self.assertEqual(info.hits, 1)
+        self.assertEqual(info.misses, 1)
+
+    def test_cache_not_stored_on_wrapped_object(self):
+        wrapped = ProxyWrapped(1)
+        obj = ProxyCached(wrapped)
+        obj.compute(10)
+        cache_attrs = [k for k in vars(wrapped) if k.startswith("_lru_cache_")]
+        self.assertEqual(cache_attrs, [])
+
+    def test_per_proxy_state_not_shared_for_same_wrapped_object(self):
+        # Two proxies over the same wrapped object must keep independent
+        # per-instance caches keyed to their own proxy state, not a single
+        # cache stored on the shared wrapped object.
+        wrapped = ProxyWrapped(1)
+        obj1 = ProxyCachedWithState(wrapped, 2)
+        obj2 = ProxyCachedWithState(wrapped, 10)
+        self.assertEqual(obj1.compute(5), 10)
+        self.assertEqual(obj2.compute(5), 50)
+
+    def test_proxy_garbage_collected_with_long_lived_wrapped(self):
+        # The cache must be stored on the proxy, not the wrapped object, so
+        # a proxy is not kept alive by a wrapped object that outlives it.
+        registry = []
+
+        def make_and_use():
+            backing = ProxyWrapped(7)
+            registry.append(backing)
+            proxy = ProxyCached(backing)
+            proxy.compute(4)
+            return weakref.ref(proxy)
+
+        ref = make_and_use()
+        gc.collect()
+        self.assertIsNone(ref())
+
+    def test_wrapped_object_without_dict(self):
+        # A wrapped object that does not accept arbitrary attributes (for
+        # example one using __slots__) must not cause the cache storage to
+        # fail, since the cache is stored on the proxy.
+        obj = ProxyCached(SlottedWrapped(1))
+        self.assertEqual(obj.compute(10), 11)
+        self.assertEqual(obj.compute(10), 11)
+        info = obj.compute.cache_info()
+        self.assertEqual(info.hits, 1)
+        self.assertEqual(info.misses, 1)
+
+
 class TestIntrospection(unittest.TestCase):
     def test_function_name(self):
         self.assertEqual(cached_function.__name__, "cached_function")