Add cross-language method suggestions for builtin AttributeError

When Levenshtein-based suggestions find no match for an AttributeError
on list, str, or dict, check a static table of common method names from
JavaScript, Java, C#, and Ruby.

For example, [].push() now suggests .append(), "".toUpperCase() suggests
.upper(), and {}.keySet() suggests .keys().

The list.add() case suggests using a set instead of suggesting .append(),
since .add() is a set method and the user may have passed a list where
a set was expected (per discussion with Serhiy Storchaka, Terry Reedy,
and Paul Moore).

Design: flat (type, attr) -> suggestion text table, no runtime
introspection. Only exact builtin types are matched to avoid false
positives on subclasses.

Discussion: https://discuss.python.org/t/106632

Author: mvanhorn

Lib/test/test_traceback.py

@@ -4564,6 +4564,67 @@ def __init__(self):
         actual = self.get_suggestion(Outer(), 'target')
         self.assertIn("'.normal.target'", actual)
 
+    def test_cross_language_list_push_suggests_append(self):
+        actual = self.get_suggestion([], 'push')
+        self.assertIn("'.append'", actual)
+
+    def test_cross_language_list_concat_suggests_extend(self):
+        actual = self.get_suggestion([], 'concat')
+        self.assertIn("'.extend'", actual)
+
+    def test_cross_language_list_addAll_suggests_extend(self):
+        actual = self.get_suggestion([], 'addAll')
+        self.assertIn("'.extend'", actual)
+
+    def test_cross_language_list_add_suggests_set(self):
+        actual = self.get_suggestion([], 'add')
+        self.assertIn("Did you mean to use a set?", actual)
+
+    def test_cross_language_str_toUpperCase_suggests_upper(self):
+        actual = self.get_suggestion('', 'toUpperCase')
+        self.assertIn("'.upper'", actual)
+
+    def test_cross_language_str_toLowerCase_suggests_lower(self):
+        actual = self.get_suggestion('', 'toLowerCase')
+        self.assertIn("'.lower'", actual)
+
+    def test_cross_language_str_trimStart_suggests_lstrip(self):
+        actual = self.get_suggestion('', 'trimStart')
+        self.assertIn("'.lstrip'", actual)
+
+    def test_cross_language_str_trimEnd_suggests_rstrip(self):
+        actual = self.get_suggestion('', 'trimEnd')
+        self.assertIn("'.rstrip'", actual)
+
+    def test_cross_language_dict_keySet_suggests_keys(self):
+        actual = self.get_suggestion({}, 'keySet')
+        self.assertIn("'.keys'", actual)
+
+    def test_cross_language_dict_entrySet_suggests_items(self):
+        actual = self.get_suggestion({}, 'entrySet')
+        self.assertIn("'.items'", actual)
+
+    def test_cross_language_dict_putAll_suggests_update(self):
+        actual = self.get_suggestion({}, 'putAll')
+        self.assertIn("'.update'", actual)
+
+    def test_cross_language_levenshtein_takes_priority(self):
+        # Levenshtein catches trim->strip and indexOf->index before
+        # the cross-language table is consulted
+        actual = self.get_suggestion('', 'trim')
+        self.assertIn("'.strip'", actual)
+
+    def test_cross_language_no_hint_for_unknown_attr(self):
+        actual = self.get_suggestion([], 'completely_unknown_method')
+        self.assertNotIn("Did you mean", actual)
+
+    def test_cross_language_not_triggered_for_subclasses(self):
+        # Only exact builtin types, not subclasses
+        class MyList(list):
+            pass
+        actual = self.get_suggestion(MyList(), 'push')
+        self.assertNotIn("append", actual)
+
     def make_module(self, code):
         tmpdir = Path(tempfile.mkdtemp())
         self.addCleanup(shutil.rmtree, tmpdir)

Lib/traceback.py

@@ -1153,6 +1153,11 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
                     self._str += f". Did you mean '.{suggestion}' instead of '.{wrong_name}'?"
                 else:
                     self._str += f". Did you mean '.{suggestion}' ({suggestion!a}) instead of '.{wrong_name}' ({wrong_name!a})?"
+            elif hasattr(exc_value, 'obj'):
+                with suppress(Exception):
+                    hint = _get_cross_language_hint(exc_value.obj, wrong_name)
+                    if hint:
+                        self._str += f". {hint}"
         elif exc_type and issubclass(exc_type, NameError) and \
                 getattr(exc_value, "name", None) is not None:
             wrong_name = getattr(exc_value, "name", None)
@@ -1649,6 +1654,45 @@ def print(self, *, file=None, chain=True, **kwargs):
 _MOVE_COST = 2
 _CASE_COST = 1
 
+# Cross-language method suggestions for builtin types.
+# Consulted as a fallback when Levenshtein-based suggestions find no match.
+#
+# Inclusion criteria:
+#   1. Must have evidence of real cross-language confusion (Stack Overflow
+#      traffic, bug reports in production repos, developer survey data)
+#   2. Must not be catchable by Levenshtein distance (too different from
+#      the correct Python method name)
+#   3. Must be from a top-4 language by Python co-usage: JavaScript, Java,
+#      C#, or Ruby (JetBrains/PSF Developer Survey 2024)
+#
+# Each entry maps (builtin_type, wrong_name) to a suggestion string.
+# If the suggestion is a Python method name, the standard "Did you mean"
+# format is used. If it contains a space, it's rendered as a full hint.
+#
+# See https://discuss.python.org/t/106632 for the design discussion.
+_CROSS_LANGUAGE_HINTS = {
+    # list -- JavaScript/Ruby equivalents
+    (list, "push"):     "append",
+    (list, "concat"):   "extend",
+    # list -- Java/C# equivalents
+    (list, "addAll"):   "extend",
+    # list -- wrong-type suggestion (per Serhiy Storchaka, Terry Reedy,
+    # Paul Moore: list.add() more likely means the user expected a set)
+    (list, "add"):      "Did you mean to use a set? Sets have an .add() method",
+    # str -- JavaScript equivalents
+    (str, "toUpperCase"): "upper",
+    (str, "toLowerCase"): "lower",
+    (str, "trimStart"):   "lstrip",
+    (str, "trimEnd"):     "rstrip",
+    # dict -- Java equivalents
+    (dict, "keySet"):       "keys",
+    (dict, "entrySet"):     "items",
+    (dict, "putAll"):       "update",
+    # Note: indexOf, trim, and getOrDefault are not included because
+    # Levenshtein distance already catches them (indexOf->index,
+    # trim->strip, getOrDefault->setdefault).
+}
+
 
 def _substitution_cost(ch_a, ch_b):
     if ch_a == ch_b:
@@ -1711,6 +1755,23 @@ def _check_for_nested_attribute(obj, wrong_name, attrs):
     return None
 
 
+def _get_cross_language_hint(obj, wrong_name):
+    """Check if wrong_name is a common method name from another language.
+
+    Only checks exact builtin types (list, str, dict) to avoid false
+    positives on subclasses that may intentionally lack these methods.
+    Returns a formatted hint string, or None.
+    """
+    hint = _CROSS_LANGUAGE_HINTS.get((type(obj), wrong_name))
+    if hint is None:
+        return None
+    if ' ' in hint:
+        # Full custom hint (e.g., wrong-type suggestion for list.add)
+        return hint
+    # Direct method equivalent -- format like Levenshtein suggestions
+    return f"Did you mean '.{hint}' instead of '.{wrong_name}'?"
+
+
 def _get_safe___dir__(obj):
     # Use obj.__dir__() to avoid a TypeError when calling dir(obj).
     # See gh-131001 and gh-139933.

Misc/NEWS.d/next/Library/2026-03-25-cross-language-hints.rst

@@ -0,0 +1,5 @@
+Cross-language method suggestions are now shown for :exc:`AttributeError` on
+builtin types when the existing Levenshtein-based suggestions find no match.
+For example, ``[].push()`` now suggests ``append`` (JavaScript), and
+``"".toUpperCase()`` suggests ``upper``. The ``list.add()`` case suggests
+using a set instead, following feedback from the community discussion.