Fix inference of living container elements (#1663)

Co-authored-by: Pierre Sassoulas <[email protected]>
Co-authored-by: Marc Mueller <[email protected]>

Author: 3 people

ChangeLog

@@ -78,6 +78,9 @@ Release date: TBA
 
   Closes #1403
 
+* Fixed inference of elements of living container objects such as tuples and sets in the
+  ``sys`` and ``ssl`` modules.
+
 * Add ``pathlib`` brain to handle ``pathlib.PurePath.parents`` inference.
 
   Closes PyCQA/pylint#5783

astroid/nodes/node_classes.py

@@ -11,7 +11,7 @@
 import sys
 import typing
 import warnings
-from collections.abc import Generator
+from collections.abc import Generator, Iterable, Mapping
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, TypeVar, Union
 
@@ -5375,6 +5375,32 @@ def postinit(self, *, patterns: list[Pattern]) -> None:
 }
 
 
+def _create_basic_elements(
+    value: Iterable[Any], node: List | Set | Tuple
+) -> list[NodeNG]:
+    """Create a list of nodes to function as the elements of a new node."""
+    elements: list[NodeNG] = []
+    for element in value:
+        element_node = const_factory(element)
+        element_node.parent = node
+        elements.append(element_node)
+    return elements
+
+
+def _create_dict_items(
+    values: Mapping[Any, Any], node: Dict
+) -> list[tuple[SuccessfulInferenceResult, SuccessfulInferenceResult]]:
+    """Create a list of node pairs to function as the items of a new dict node."""
+    elements: list[tuple[SuccessfulInferenceResult, SuccessfulInferenceResult]] = []
+    for key, value in values.items():
+        key_node = const_factory(key)
+        key_node.parent = node
+        value_node = const_factory(value)
+        value_node.parent = node
+        elements.append((key_node, value_node))
+    return elements
+
+
 def const_factory(value: Any) -> List | Set | Tuple | Dict | Const | EmptyNode:
     """Return an astroid node for a python value."""
     assert not isinstance(value, NodeNG)
@@ -5387,13 +5413,14 @@ def const_factory(value: Any) -> List | Set | Tuple | Dict | Const | EmptyNode:
         node.object = value
         return node
 
-    # TODO: We pass an empty list as elements for a sequence
-    # or a mapping, in order to avoid transforming
-    # each element to an AST. This is fixed in 2.0
-    # and this approach is a temporary hack.
+    instance: List | Set | Tuple | Dict
     initializer_cls = CONST_CLS[value.__class__]
-    if issubclass(initializer_cls, (Dict, List, Set, Tuple)):
+    if issubclass(initializer_cls, (List, Set, Tuple)):
+        instance = initializer_cls()
+        instance.postinit(_create_basic_elements(value, instance))
+        return instance
+    if issubclass(initializer_cls, Dict):
         instance = initializer_cls()
-        instance.postinit([])
+        instance.postinit(_create_dict_items(value, instance))
         return instance
     return Const(value)

tests/test_stdlib.py

@@ -0,0 +1,38 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Tests for modules in the stdlib."""
+
+from astroid import nodes
+from astroid.builder import _extract_single_node
+
+
+class TestSys:
+    """Tests for the sys module."""
+
+    def test_sys_builtin_module_names(self) -> None:
+        """Test that we can gather the elements of a living tuple object."""
+        node = _extract_single_node(
+            """
+        import sys
+        sys.builtin_module_names
+        """
+        )
+        inferred = list(node.infer())
+        assert len(inferred) == 1
+        assert isinstance(inferred[0], nodes.Tuple)
+        assert inferred[0].elts
+
+    def test_sys_modules(self) -> None:
+        """Test that we can gather the items of a living dict object."""
+        node = _extract_single_node(
+            """
+        import sys
+        sys.modules
+        """
+        )
+        inferred = list(node.infer())
+        assert len(inferred) == 1
+        assert isinstance(inferred[0], nodes.Dict)
+        assert inferred[0].items