Merge branch 'main' into namedtuple

Author: Pierre-Sassoulas

ChangeLog

@@ -27,11 +27,17 @@ Release date: TBA
 
   Closes PyCQA/pylint#5771
 
+* Fixed a crash inferring on a ``NewType`` named with an f-string.
+
+  Closes PyCQA/pylint#5770
+
 * Add support for [attrs v21.3.0](https://github.com/python-attrs/attrs/releases/tag/21.3.0) which
   added a new `attrs` module alongside the existing `attr`.
 
   Closes #1330
 
+* Add ``is_dataclass`` attribute to ``ClassDef`` nodes.
+
 * Use ``sysconfig`` instead of ``distutils`` to determine the location of
   python stdlib files and packages.
 
@@ -44,6 +50,9 @@ Release date: TBA
 
   Closes #1085
 
+* Fix ``ClassDef.fromlineno``. For Python < 3.8 the ``lineno`` attribute includes decorators.
+  ``fromlineno`` should return the line of the ``class`` statement itself.
+
 What's New in astroid 2.9.4?
 ============================
 Release date: TBA

astroid/brain/brain_dataclasses.py

@@ -67,6 +67,7 @@ def is_decorated_with_dataclass(node, decorator_names=DATACLASSES_DECORATORS):
 
 def dataclass_transform(node: ClassDef) -> None:
     """Rewrite a dataclass to be easily understood by pylint"""
+    node.is_dataclass = True
 
     for assign_node in _get_dataclass_attributes(node):
         name = assign_node.target.name

astroid/brain/brain_typing.py

@@ -31,6 +31,7 @@
     Attribute,
     Call,
     Const,
+    JoinedStr,
     Name,
     NodeNG,
     Subscript,
@@ -128,6 +129,9 @@ def infer_typing_typevar_or_newtype(node, context_itton=None):
         raise UseInferenceDefault
     if not node.args:
         raise UseInferenceDefault
+    # Cannot infer from a dynamic class name (f-string)
+    if isinstance(node.args[0], JoinedStr):
+        raise UseInferenceDefault
 
     typename = node.args[0].as_string().strip("'")
     node = extract_node(TYPING_TYPE_TEMPLATE.format(typename))

astroid/const.py

@@ -7,6 +7,7 @@
 else:
     from typing_extensions import Final
 
+PY36 = sys.version_info[:2] == (3, 6)
 PY38 = sys.version_info[:2] == (3, 8)
 PY37_PLUS = sys.version_info >= (3, 7)
 PY38_PLUS = sys.version_info >= (3, 8)

astroid/interpreter/_import/util.py

@@ -3,15 +3,70 @@
 # Copyright (c) 2021 Daniël van Noord <[email protected]>
 # Copyright (c) 2021 Neil Girdhar <[email protected]>
 
-try:
-    import pkg_resources
-except ImportError:
-    pkg_resources = None  # type: ignore[assignment]
 
+from importlib import abc, util
+
+from astroid.const import PY36
+
+
+def _is_old_setuptools_namespace_package(modname: str) -> bool:
+    """Check for old types of setuptools namespace packages.
+
+    See https://setuptools.pypa.io/en/latest/pkg_resources.html and
+    https://packaging.python.org/en/latest/guides/packaging-namespace-packages/
+
+    Because pkg_resources is slow to import we only do so if explicitly necessary.
+    """
+    try:
+        import pkg_resources  # pylint: disable=import-outside-toplevel
+    except ImportError:
+        return False
 
-def is_namespace(modname):
     return (
-        pkg_resources is not None
-        and hasattr(pkg_resources, "_namespace_packages")
-        and modname in pkg_resources._namespace_packages
+        hasattr(pkg_resources, "_namespace_packages")
+        and modname in pkg_resources._namespace_packages  # type: ignore[attr-defined]
+    )
+
+
+def is_namespace(modname: str) -> bool:
+    """Determine whether we encounter a namespace package."""
+    if PY36:
+        # On Python 3.6 an AttributeError is raised when a package
+        # is lacking a __path__ attribute and thus is not a
+        # package.
+        try:
+            spec = util.find_spec(modname)
+        except (AttributeError, ValueError):
+            return _is_old_setuptools_namespace_package(modname)
+    else:
+        try:
+            spec = util.find_spec(modname)
+        except ValueError:
+            return _is_old_setuptools_namespace_package(modname)
+
+    # If there is no spec or origin this is a namespace package
+    # See: https://docs.python.org/3/library/importlib.html#importlib.machinery.ModuleSpec.origin
+    # We assume builtin packages are never namespace
+    if not spec or not spec.origin or spec.origin == "built-in":
+        return False
+
+    # If there is no loader the package is namespace
+    # See https://docs.python.org/3/library/importlib.html#importlib.abc.PathEntryFinder.find_loader
+    if not spec.loader:
+        return True
+    # This checks for _frozen_importlib.FrozenImporter, which does not inherit from InspectLoader
+    if hasattr(spec.loader, "_ORIGIN") and spec.loader._ORIGIN == "frozen":
+        return False
+    # Other loaders are namespace packages
+    if not isinstance(spec.loader, abc.InspectLoader):
+        return True
+
+    # Lastly we check if the package declares itself a namespace package
+    try:
+        source = spec.loader.get_source(spec.origin)
+    # If the loader can't handle the spec, we're dealing with a namespace package
+    except ImportError:
+        return False
+    return bool(
+        source and "pkg_resources" in source and "declare_namespace(__name__)" in source
     )

astroid/nodes/scoped_nodes/scoped_nodes.py

@@ -55,7 +55,7 @@
 from astroid import bases
 from astroid import decorators as decorators_mod
 from astroid import mixins, util
-from astroid.const import NAMEDTUPLE_BASENAMES, PY39_PLUS
+from astroid.const import NAMEDTUPLE_BASENAMES, PY38_PLUS, PY39_PLUS
 from astroid.context import (
     CallContext,
     InferenceContext,
@@ -1369,7 +1369,7 @@ def callable(self):
     def argnames(self) -> List[str]:
         """Get the names of each of the arguments, including that
         of the collections of variable-length arguments ("args", "kwargs",
-        etc.), as well as keyword-only arguments.
+        etc.), as well as positional-only and keyword-only arguments.
 
         :returns: The names of the arguments.
         :rtype: list(str)
@@ -1378,9 +1378,9 @@ def argnames(self) -> List[str]:
             names = _rec_get_names(self.args.arguments)
         else:
             names = []
-        names += [elt.name for elt in self.args.kwonlyargs]
         if self.args.vararg:
             names.append(self.args.vararg)
+        names += [elt.name for elt in self.args.kwonlyargs]
         if self.args.kwarg:
             names.append(self.args.kwarg)
         return names
@@ -1706,13 +1706,10 @@ def type(
         return type_name
 
     @decorators_mod.cachedproperty
-    def fromlineno(self):
-        """The first line that this node appears on in the source code.
-
-        :type: int or None
-        """
+    def fromlineno(self) -> Optional[int]:
+        """The first line that this node appears on in the source code."""
         # lineno is the line number of the first decorator, we want the def
-        # statement lineno
+        # statement lineno. Similar to 'ClassDef.fromlineno'
         lineno = self.lineno
         if self.decorators is not None:
             lineno += sum(
@@ -2134,7 +2131,7 @@ def my_meth(self, arg):
             ":type: str"
         ),
     )
-    _other_fields = ("name", "doc")
+    _other_fields = ("name", "doc", "is_dataclass")
     _other_other_fields = ("locals", "_newstyle")
     _newstyle = None
 
@@ -2212,6 +2209,9 @@ def __init__(
         :type doc: str or None
         """
 
+        self.is_dataclass: bool = False
+        """Whether this class is a dataclass."""
+
         super().__init__(
             lineno=lineno,
             col_offset=col_offset,
@@ -2297,6 +2297,21 @@ def _newstyle_impl(self, context=None):
         doc=("Whether this is a new style class or not\n\n" ":type: bool or None"),
     )
 
+    @decorators_mod.cachedproperty
+    def fromlineno(self) -> Optional[int]:
+        """The first line that this node appears on in the source code."""
+        if not PY38_PLUS:
+            # For Python < 3.8 the lineno is the line number of the first decorator.
+            # We want the class statement lineno. Similar to 'FunctionDef.fromlineno'
+            lineno = self.lineno
+            if self.decorators is not None:
+                lineno += sum(
+                    node.tolineno - node.lineno + 1 for node in self.decorators.nodes
+                )
+
+            return lineno
+        return super().fromlineno
+
     @decorators_mod.cachedproperty
     def blockstart_tolineno(self):
         """The line on which the beginning of this block ends.

astroid/test_utils.py

@@ -48,9 +48,9 @@ def check_require_version(f):
 
         @functools.wraps(f)
         def new_f(*args, **kwargs):
-            if minver != "0.0.0":
+            if current <= min_version:
                 pytest.skip(f"Needs Python > {minver}. Current version is {version}.")
-            elif maxver != "4.0.0":
+            elif current > max_version:
                 pytest.skip(f"Needs Python <= {maxver}. Current version is {version}.")
 
         return new_f

tests/unittest_brain.py

@@ -57,7 +57,11 @@
 from astroid import MANAGER, bases, builder, nodes, objects, test_utils, util
 from astroid.bases import Instance
 from astroid.const import PY37_PLUS
-from astroid.exceptions import AttributeInferenceError, InferenceError
+from astroid.exceptions import (
+    AttributeInferenceError,
+    InferenceError,
+    UseInferenceDefault,
+)
 from astroid.nodes.node_classes import Const
 from astroid.nodes.scoped_nodes import ClassDef
 
@@ -1661,6 +1665,19 @@ def test_typing_types(self) -> None:
             inferred = next(node.infer())
             self.assertIsInstance(inferred, nodes.ClassDef, node.as_string())
 
+    def test_typing_type_without_tip(self):
+        """Regression test for https://github.com/PyCQA/pylint/issues/5770"""
+        node = builder.extract_node(
+            """
+        from typing import NewType
+
+        def make_new_type(t):
+            new_type = NewType(f'IntRange_{t}', t) #@
+        """
+        )
+        with self.assertRaises(UseInferenceDefault):
+            astroid.brain.brain_typing.infer_typing_typevar_or_newtype(node.value)
+
     def test_namedtuple_nested_class(self):
         result = builder.extract_node(
             """

tests/unittest_brain_dataclasses.py

@@ -184,6 +184,7 @@ class A:
     inferred = next(class_def.infer())
     assert isinstance(inferred, nodes.ClassDef)
     assert inferred.instance_attrs == {}
+    assert inferred.is_dataclass
 
     # Both the class and instance can still access the attribute
     for node in (klass, instance):
@@ -216,6 +217,7 @@ class A:
     inferred = next(class_def.infer())
     assert isinstance(inferred, nodes.ClassDef)
     assert inferred.instance_attrs == {}
+    assert inferred.is_dataclass
 
     # Both the class and instance can still access the attribute
     for node in (klass, instance):
@@ -248,6 +250,7 @@ class A:
     inferred = next(class_def.infer())
     assert isinstance(inferred, nodes.ClassDef)
     assert inferred.instance_attrs == {}
+    assert inferred.is_dataclass
 
     # Both the class and instance can still access the attribute
     for node in (klass, instance):
@@ -666,6 +669,7 @@ class A:
     inferred = node.inferred()
     assert len(inferred) == 1 and isinstance(inferred[0], nodes.ClassDef)
     assert "attribute" in inferred[0].instance_attrs
+    assert inferred[0].is_dataclass
 
 
 @parametrize_module
@@ -683,3 +687,30 @@ class A:
     inferred = code.inferred()
     assert len(inferred) == 1
     assert isinstance(inferred[0], nodes.ClassDef)
+    assert inferred[0].is_dataclass
+
+
+def test_non_dataclass_is_not_dataclass() -> None:
+    """Test that something that isn't a dataclass has the correct attribute."""
+    module = astroid.parse(
+        """
+    class A:
+        val: field()
+
+    def dataclass():
+        return
+
+    @dataclass
+    class B:
+        val: field()
+    """
+    )
+    class_a = module.body[0].inferred()
+    assert len(class_a) == 1
+    assert isinstance(class_a[0], nodes.ClassDef)
+    assert not class_a[0].is_dataclass
+
+    class_b = module.body[2].inferred()
+    assert len(class_b) == 1
+    assert isinstance(class_b[0], nodes.ClassDef)
+    assert not class_b[0].is_dataclass