@@ -981,33 +981,17 @@ def impl(obj, name):
     return impl
 
 
-def _get_py_repr_and_warn(obj):
-    # Gets the repr of an object at runtime whilst issuing a performance
-    # warning
-    from numba import typeof
-    msg = ("There is no '__repr__' specialisation defined for the type "
-           f"'{typeof(obj)}', as a result the Python interpreter has been "
-           "called to fetch a repr(), this has a performance penalty. To avoid "
-           "this penalty either define a '__repr__' for the type or remove the "
-           "call to str()/repr()!")
-    warnings.warn(NumbaPerformanceWarning(msg))
-    return repr(obj)
-
-
 @overload(repr)
 def ol_repr_generic(obj):
-    from numba import objmode
+    missing_repr_format = f"<object type:{obj}>"
     def impl(obj):
         attr = '__repr__'
         if hasattr(obj, attr) == True:
             return getattr(obj, attr)()
         else:
-            # There's no __str__ or __repr__ defined for this object, go via
-            # the interpreter.
-            pyrepr = ""
-            with objmode(pyrepr='unicode_type'):
-                pyrepr = _get_py_repr_and_warn(obj)
-            return pyrepr
+            # There's no __str__ or __repr__ defined for this object, return
+            # something generic
+            return missing_repr_format
     return impl
 
 
 
@@ -1615,38 +1615,26 @@ def foo(x):
             self.assertEqual(foo(x), foo.py_func(x))
 
     def test_repr_fallback(self):
-        # checks objmode str/repr call fallback, there's no overloaded
-        # __str__ or __repr__ for the dummy type so it has to use the objmode
-        # `repr` call.
+        # checks str/repr fallback, there's no overloaded __str__ or __repr__
+        # for the dummy type so it has to use generic '<object type:(type)>'
+        # string for the `repr` call.
 
         Dummy, DummyType = self.make_dummy_type()
-        string_repr = "this is the dummy object Python side repr"
-        Dummy.__repr__= lambda inst: string_repr
         dummy = Dummy()
+        string_repr = f"<object type:{typeof(dummy)}>"
+        Dummy.__repr__= lambda inst: string_repr
 
         @box(DummyType)
         def box_dummy(typ, obj, c):
             clazobj = c.pyapi.unserialize(c.pyapi.serialize_object(Dummy))
             return c.pyapi.call_function_objargs(clazobj, ())
 
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('always', errors.NumbaPerformanceWarning)
-            ignore_internal_warnings()
-
-            @njit
-            def foo(x):
-                return str(x)
-
-            self.assertEqual(foo(dummy), foo.py_func(dummy))
-
-            self.assertEqual(len(w), 1)
+        @njit
+        def foo(x):
+            return str(x)
 
-            self.assertEqual(w[0].category,
-                             errors.NumbaPerformanceWarning)
+        self.assertEqual(foo(dummy), foo.py_func(dummy))
 
-            msg = ("There is no '__repr__' specialisation defined for the "
-                   f"type '{typeof(dummy)}'")
-            self.assertIn(msg, str(w[0].message))
 
 
 if __name__ == '__main__':