Path 1: 335 calls (0.84)

→ node AssignName (274) AssignAttr (60) AnnAssign (1)

↩ return set (334) {'x'} (1)

4 run 6 not run

1def infer_node(node: nodes.AssignAttr | nodes.AssignName) -> set[InferenceResult]:
2    """Return a set containing the node annotation if it exists
3    otherwise return a set of the inferred types using the NodeNG.infer method.
4    """
5
6    ann = get_annotation(node)
7    try:
8        if ann:
9            if isinstance(ann, nodes.Subscript) or (
10                isinstance(ann, nodes.BinOp) and ann.op == "|"
11            ):
12                return {ann}
13            return set(ann.infer())
14        return set(node.infer())
15    except astroid.InferenceError:
16        return {ann} if ann else set()
            

Path 2: 23 calls (0.06)

→ node AssignAttr (17) AssignName (6)

↩ return set (23)

5 run 5 not run

1def infer_node(node: nodes.AssignAttr | nodes.AssignName) -> set[InferenceResult]:
2    """Return a set containing the node annotation if it exists
3    otherwise return a set of the inferred types using the NodeNG.infer method.
4    """
5
6    ann = get_annotation(node)
7    try:
8        if ann:
9            if isinstance(ann, nodes.Subscript) or (
10                isinstance(ann, nodes.BinOp) and ann.op == "|"
11            ):
12                return {ann}
13            return set(ann.infer())
14        return set(node.infer())
15    except astroid.InferenceError:
16        return {ann} if ann else set()
            

Path 3: 18 calls (0.05)

→ node AssignName (17) AnnAssign (1)

↩ return set() (18)

⚠ exception InferenceError (18)

6 run 4 not run

1def infer_node(node: nodes.AssignAttr | nodes.AssignName) -> set[InferenceResult]:
2    """Return a set containing the node annotation if it exists
3    otherwise return a set of the inferred types using the NodeNG.infer method.
4    """
5
6    ann = get_annotation(node)
7    try:
8        if ann:
9            if isinstance(ann, nodes.Subscript) or (
10                isinstance(ann, nodes.BinOp) and ann.op == "|"
11            ):
12                return {ann}
13            return set(ann.infer())
14        return set(node.infer())
15    except astroid.InferenceError:
16        return {ann} if ann else set()
            

Path 4: 13 calls (0.03)

→ node AssignAttr (10) AssignName (3)

↩ return set (13)

6 run 4 not run

1def infer_node(node: nodes.AssignAttr | nodes.AssignName) -> set[InferenceResult]:
2    """Return a set containing the node annotation if it exists
3    otherwise return a set of the inferred types using the NodeNG.infer method.
4    """
5
6    ann = get_annotation(node)
7    try:
8        if ann:
9            if isinstance(ann, nodes.Subscript) or (
10                isinstance(ann, nodes.BinOp) and ann.op == "|"
11            ):
12                return {ann}
13            return set(ann.infer())
14        return set(node.infer())
15    except astroid.InferenceError:
16        return {ann} if ann else set()
            

Path 5: 4 calls (0.01)

→ node AssignAttr (4)

↩ return set (4)

⚠ exception NameInferenceError (4)

8 run 2 not run

1def infer_node(node: nodes.AssignAttr | nodes.AssignName) -> set[InferenceResult]:
2    """Return a set containing the node annotation if it exists
3    otherwise return a set of the inferred types using the NodeNG.infer method.
4    """
5
6    ann = get_annotation(node)
7    try:
8        if ann:
9            if isinstance(ann, nodes.Subscript) or (
10                isinstance(ann, nodes.BinOp) and ann.op == "|"
11            ):
12                return {ann}
13            return set(ann.infer())
14        return set(node.infer())
15    except astroid.InferenceError:
16        return {ann} if ann else set()
            

Path 6: 4 calls (0.01)

→ node AssignName (2) AssignAttr (2)

↩ return set (4)

6 run 4 not run

1def infer_node(node: nodes.AssignAttr | nodes.AssignName) -> set[InferenceResult]:
2    """Return a set containing the node annotation if it exists
3    otherwise return a set of the inferred types using the NodeNG.infer method.
4    """
5
6    ann = get_annotation(node)
7    try:
8        if ann:
9            if isinstance(ann, nodes.Subscript) or (
10                isinstance(ann, nodes.BinOp) and ann.op == "|"
11            ):
12                return {ann}
13            return set(ann.infer())
14        return set(node.infer())
15    except astroid.InferenceError:
16        return {ann} if ann else set()