Fixed bytecode-clash edge case

line_profiler/_line_profiler.pyx::LineProfiler.add_function()
    Now stripping padded code objects and re-padding when appropriate,
    so that no two profiled code objects can end up with the same
    bytecode

tests/test_line_profiler.py
    test_multiple_profilers_identical_bytecode()
        - Updated comments and docstring
        - Added check against duplicate bytecodes

Author: TTsangSC

line_profiler/_line_profiler.pyx

@@ -378,27 +378,36 @@ cdef class LineProfiler:
         co_code: bytes = code.co_code
         code_hashes = []
         if any(co_code):  # Normal Python functions
+            base_co_code: bytes = co_code
+            # Figure out how much padding we need and strip the bytecode
+            # TODO: is there a way to do this faster? `.rstrip()` doesn't
+            # work (reliably) since `NOP_BYTES` should be 2-byte wide
+            npad_code: int = 0
+            nop_len: int = -len(NOP_BYTES)
+            while base_co_code.endswith(NOP_BYTES):
+                base_co_code = base_co_code[:nop_len]
+                npad_code += 1
             try:
-                npad = self._all_paddings[co_code]
-                self._all_paddings[co_code] = npad + 1
+                npad = self._all_paddings[base_co_code]
             except KeyError:
                 npad = 0
-                self._all_paddings[co_code] = 1
+            self._all_paddings[base_co_code] = max(npad, npad_code) + 1
             try:
                 neighbors = self._all_instances_by_funcs[func_id]
                 neighbors.add(self)
             except KeyError:
-                neighbors = self._all_instances_by_funcs[func_id] = WeakSet({self})
+                neighbors = self._all_instances_by_funcs[func_id] = WeakSet(
+                    {self})
             # Maintain `.dupes_map` (legacy)
             try:
-                self.dupes_map[co_code].append(code)
+                self.dupes_map[base_co_code].append(code)
             except KeyError:
-                self.dupes_map[co_code] = [code]
-            if npad:
+                self.dupes_map[base_co_code] = [code]
+            if npad > npad_code:
                 # Code hash already exists, so there must be a duplicate
                 # function (on some instance);
-                # add no-op
-                co_code += NOP_BYTES * npad
+                # (re-)pad with no-op
+                co_code = base_co_code + NOP_BYTES * npad
                 code = _code_replace(func, co_code=co_code)
                 try:
                     func.__code__ = code

tests/test_line_profiler.py

@@ -845,14 +845,12 @@ def func(n):
         '-func3:p3:p4:p1'
         '-func4:p2:p1:p4',
         # Misc. edge cases
-        # - Note: while the following results in `func1()` and `func2()`
-        #   sharing the same bytecodes, the profiler `p3` is nonetheless
-        #   able to distinguish between the two (when the functions have
-        #   distinct line numbers), because they are defined on
-        #   different lines and thus hashed to different line hashes
-        'func1:p1:p2'  # `func1()` padded once
-        '-func2:p3'  # `func2()` padded twice
-        '-func1:p4:p3',  # `func1()` padded once (again)
+        # - Naive padding of the following case would cause `func1()`
+        #   and `func2()` to end up with the same bytecode, so guard
+        #   against it
+        'func1:p1:p2'  # `func1()` padded once?
+        '-func2:p3'  # `func2()` padded twice?
+        '-func1:p4:p3',  # `func1()` padded once (again)?
     ])
 def test_multiple_profilers_identical_bytecode(
         tmp_path, ops, force_same_line_numbers):
@@ -862,10 +860,12 @@ def test_multiple_profilers_identical_bytecode(
 
     Notes
     -----
-    `ops` should consist of chunks joined by hyphens, where each chunk
-    has the format `<func_id>:<prof_name>[:<prof_name>[...]]`,
-    indicating that the profilers are to be used in order to decorate
-    the specified function.
+    - `ops` should consist of chunks joined by hyphens, where each chunk
+      has the format `<func_id>:<prof_name>[:<prof_name>[...]]`,
+      indicating that the profilers are to be used in order to decorate
+      the specified function.
+    - `force_same_line_numbers` is used to coerce all functions to
+      compile down to code objects with the same line numbers.
     """
     def check_seen(name, output, func_id, expected):
         lines = [line for line in output.splitlines()
@@ -941,11 +941,11 @@ def func4():
                  'func3': func3, 'func4': func4}
 
     # Apply the decorators in order
-    all_dec_names = {}
+    all_dec_names = {f'func{i}': set() for i in [1, 2, 3, 4]}
     all_profs = {}
     for op in ops.split('-'):
         func_id, *profs = op.split(':')
-        all_dec_names.setdefault(func_id, set()).update(profs)
+        all_dec_names[func_id].update(profs)
         for name in profs:
             try:
                 prof = all_profs[name]
@@ -957,6 +957,11 @@ def func4():
     assert funcs['func2']() == [2, 2]
     assert funcs['func3']() == [3, 3, 3]
     assert funcs['func4']() == [4, 4, 4, 4]
+    # Check that the bytecodes of the profiled functions are distinct
+    profiled_funcs = {funcs[name].__line_profiler_id__.func
+                      for name, decs in all_dec_names.items() if decs}
+    assert len({func.__code__.co_code
+                for func in profiled_funcs}) == len(profiled_funcs)
     # Check the profiling results
     for name, prof in sorted(all_profs.items()):
         with io.StringIO() as sio: