Path 1: 105 calls (0.7)

→ original UnboundMethod (97) BoundMethod (4) FunctionDef (4)

→ overridden UnboundMethod (95) BoundMethod (5) FunctionDef (5)

→ dummy_parameter_regex Pattern (105)

↩ return [] (105)

18 run 16 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 2: 12 calls (0.08)

→ original UnboundMethod (10) BoundMethod (1) FunctionDef (1)

→ overridden UnboundMethod (11) FunctionDef (1)

→ dummy_parameter_regex Pattern (12)

↩ return ['Number of parameters '] (6) ["Parameter 'fruit_name' has been renamed to 'orange_name' in"] (3) ["Parameter 'arg' has been renamed to 'arg1' in"] (1...

19 run 15 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 3: 10 calls (0.07)

→ original UnboundMethod (10)

→ overridden UnboundMethod (10)

→ dummy_parameter_regex Pattern (10)

↩ return [] (10)

19 run 15 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 4: 6 calls (0.04)

→ original UnboundMethod (5) FunctionDef (1)

→ overridden UnboundMethod (5) FunctionDef (1)

→ dummy_parameter_regex Pattern (6)

↩ return [] (6)

24 run 10 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 5: 5 calls (0.03)

→ original UnboundMethod (4) BoundMethod (1)

→ overridden UnboundMethod (4) BoundMethod (1)

→ dummy_parameter_regex Pattern (5)

↩ return [] (5)

20 run 14 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 6: 4 calls (0.03)

→ original UnboundMethod (4)

→ overridden UnboundMethod (4)

→ dummy_parameter_regex Pattern (4)

↩ return ['Number of parameters '] (4)

19 run 15 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 7: 3 calls (0.02)

→ original UnboundMethod (3)

→ overridden UnboundMethod (3)

→ dummy_parameter_regex Pattern (3)

↩ return ['Number of parameters '] (3)

20 run 14 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 8: 2 calls (0.01)

→ original UnboundMethod (2)

→ overridden UnboundMethod (2)

→ dummy_parameter_regex Pattern (2)

↩ return ['Variadics removed in'] (2)

19 run 15 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 9: 1 calls (0.01)

→ original UnboundMethod (1)

→ overridden UnboundMethod (1)

→ dummy_parameter_regex Pattern (1)

↩ return ["Parameter 'args' has been renamed to 'arg' in"] (1)

22 run 12 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 10: 1 calls (0.01)

→ original UnboundMethod (1)

→ overridden UnboundMethod (1)

→ dummy_parameter_regex Pattern (1)

↩ return ['Number of parameters '] (1)

22 run 12 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 11: 1 calls (0.01)

→ original UnboundMethod (1)

→ overridden UnboundMethod (1)

→ dummy_parameter_regex Pattern (1)

↩ return [] (1)

21 run 13 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages
            

Path 12: 1 calls (0.01)

→ original BoundMethod (1)

→ overridden BoundMethod (1)

→ dummy_parameter_regex Pattern (1)

↩ return [] (1)

23 run 11 not run

1def _different_parameters(
2    original: nodes.FunctionDef,
3    overridden: nodes.FunctionDef,
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    """Determine if the two methods have different parameters.
7
8    They are considered to have different parameters if:
9
10       * they have different positional parameters, including different names
11
12       * one of the methods is having variadics, while the other is not
13
14       * they have different keyword only parameters.
15    """
16    output_messages = []
17    original_parameters = _positional_parameters(original)
18    overridden_parameters = _positional_parameters(overridden)
19
20    # Copy kwonlyargs list so that we don't affect later function linting
21    original_kwonlyargs = original.args.kwonlyargs
22
23    # Allow positional/keyword variadic in overridden to match against any
24    # positional/keyword argument in original.
25    # Keep any arguments that are found separately in overridden to satisfy
26    # later tests
27    if overridden.args.vararg:
28        overridden_names = [v.name for v in overridden_parameters]
29        original_parameters = [
30            v for v in original_parameters if v.name in overridden_names
31        ]
32
33    if overridden.args.kwarg:
34        overridden_names = [v.name for v in overridden.args.kwonlyargs]
35        original_kwonlyargs = [
36            v for v in original.args.kwonlyargs if v.name in overridden_names
37        ]
38
39    different_positional = _has_different_parameters(
40        original_parameters, overridden_parameters, dummy_parameter_regex
41    )
42    different_kwonly = _has_different_keyword_only_parameters(
43        original_kwonlyargs, overridden.args.kwonlyargs
44    )
45    if different_kwonly and different_positional:
46        if "Number " in different_positional[0] and "Number " in different_kwonly[0]:
47            output_messages.append("Number of parameters ")
48            output_messages += different_positional[1:]
49            output_messages += different_kwonly[1:]
50        else:
51            output_messages += different_positional
52            output_messages += different_kwonly
53    else:
54        if different_positional:
55            output_messages += different_positional
56        if different_kwonly:
57            output_messages += different_kwonly
58
59    if original.name in PYMETHODS:
60        # Ignore the difference for special methods. If the parameter
61        # numbers are different, then that is going to be caught by
62        # unexpected-special-method-signature.
63        # If the names are different, it doesn't matter, since they can't
64        # be used as keyword arguments anyway.
65        output_messages.clear()
66
67    # Arguments will only violate LSP if there are variadics in the original
68    # that are then removed from the overridden
69    kwarg_lost = original.args.kwarg and not overridden.args.kwarg
70    vararg_lost = original.args.vararg and not overridden.args.vararg
71
72    if kwarg_lost or vararg_lost:
73        output_messages += ["Variadics removed in"]
74
75    return output_messages