def test_infer_node_3() -> None:
"""Return a set containing a nodes.ClassDef object when the attribute
has a type annotation"""
node = astroid.extract_node("""
class Component:
pass
class Composite:
def __init__(self, component: Component):
self.component = component
""")
instance_attr = node.instance_attrs.get("component")[0]
assert isinstance(infer_node(instance_attr), set)
assert isinstance(infer_node(instance_attr).pop(), nodes.ClassDef)
def visit_assignname(self, node: nodes.AssignName) -> None:
"""Visit an astroid.AssignName node.
handle locals_type
"""
# avoid double parsing done by different Linkers.visit
# running over the same project:
if hasattr(node, "_handled"):
return
node._handled = True
if node.name in node.frame(future=True):
frame = node.frame(future=True)
else:
# the name has been defined as 'global' in the frame and belongs
# there.
frame = node.root()
if not hasattr(frame, "locals_type"):
# If the frame doesn't have a locals_type yet,
# it means it wasn't yet visited. Visit it now
# to add what's missing from it.
if isinstance(frame, nodes.ClassDef):
self.visit_classdef(frame)
elif isinstance(frame, nodes.FunctionDef):
self.visit_functiondef(frame)
else:
self.visit_module(frame)
current = frame.locals_type[node.name]
frame.locals_type[node.name] = list(set(current) | utils.infer_node(node))
def handle_assignattr_type(node, parent):
"""handle an astroid.assignattr node
handle instance_attrs_type
"""
current = set(parent.instance_attrs_type[node.attrname])
parent.instance_attrs_type[node.attrname] = list(
current | utils.infer_node(node))
def handle_assignattr_type(node: nodes.AssignAttr,
parent: nodes.ClassDef) -> None:
"""Handle an astroid.assignattr node.
handle instance_attrs_type
"""
current = set(parent.instance_attrs_type[node.attrname])
parent.instance_attrs_type[node.attrname] = list(
current | utils.infer_node(node))
def test_infer_node_2(mock_infer: Any, mock_get_annotation: Any) -> None:
"""Return set(node.infer()) when InferenceError is not raised and an
annotation has not been returned
"""
mock_get_annotation.return_value = None
node = astroid.extract_node("a: str = 'mystr'")
mock_infer.return_value = "x"
assert infer_node(node) == set("x")
assert mock_infer.called
def test_infer_node_4() -> None:
"""Verify the label for an argument with a typehint of the type
nodes.Subscript
"""
node = astroid.extract_node("""
class MyClass:
def __init__(self, my_int: Optional[int] = None):
self.my_test_int = my_int
""")
instance_attr = node.instance_attrs.get("my_test_int")[0]
assert isinstance(instance_attr, nodes.AssignAttr)
inferred = infer_node(instance_attr).pop()
assert isinstance(inferred, nodes.Subscript)
assert inferred.name == "Optional[int]"