Type annotate some misc places with no particular connection

src/_pytest/config/__init__.py

@@ -14,6 +14,7 @@ from types import TracebackType
 from typing import Any
 from typing import Callable
 from typing import Dict
+from typing import IO
 from typing import List
 from typing import Optional
 from typing import Sequence
@@ -295,7 +296,7 @@ class PytestPluginManager(PluginManager):
     * ``conftest.py`` loading during start-up;
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         import _pytest.assertion
 
         super().__init__("pytest")
@@ -315,7 +316,7 @@ class PytestPluginManager(PluginManager):
         self.add_hookspecs(_pytest.hookspec)
         self.register(self)
         if os.environ.get("PYTEST_DEBUG"):
-            err = sys.stderr
+            err = sys.stderr  # type: IO[str]
             encoding = getattr(err, "encoding", "utf8")
             try:
                 err = open(
@@ -377,7 +378,7 @@ class PytestPluginManager(PluginManager):
                 }
         return opts
 
-    def register(self, plugin, name=None):
+    def register(self, plugin: _PluggyPlugin, name: Optional[str] = None):
         if name in _pytest.deprecated.DEPRECATED_EXTERNAL_PLUGINS:
             warnings.warn(
                 PytestConfigWarning(
@@ -552,7 +553,7 @@ class PytestPluginManager(PluginManager):
     #
     #
 
-    def consider_preparse(self, args, *, exclude_only=False):
+    def consider_preparse(self, args, *, exclude_only: bool = False) -> None:
         i = 0
         n = len(args)
         while i < n:
@@ -573,7 +574,7 @@ class PytestPluginManager(PluginManager):
                     continue
                 self.consider_pluginarg(parg)
 
-    def consider_pluginarg(self, arg):
+    def consider_pluginarg(self, arg) -> None:
         if arg.startswith("no:"):
             name = arg[3:]
             if name in essential_plugins:
@@ -598,13 +599,13 @@ class PytestPluginManager(PluginManager):
                     del self._name2plugin["pytest_" + name]
             self.import_plugin(arg, consider_entry_points=True)
 
-    def consider_conftest(self, conftestmodule):
+    def consider_conftest(self, conftestmodule) -> None:
         self.register(conftestmodule, name=conftestmodule.__file__)
 
-    def consider_env(self):
+    def consider_env(self) -> None:
         self._import_plugin_specs(os.environ.get("PYTEST_PLUGINS"))
 
-    def consider_module(self, mod):
+    def consider_module(self, mod: types.ModuleType) -> None:
         self._import_plugin_specs(getattr(mod, "pytest_plugins", []))
 
     def _import_plugin_specs(self, spec):
@@ -612,7 +613,7 @@ class PytestPluginManager(PluginManager):
         for import_spec in plugins:
             self.import_plugin(import_spec)
 
-    def import_plugin(self, modname, consider_entry_points=False):
+    def import_plugin(self, modname: str, consider_entry_points: bool = False) -> None:
         """
         Imports a plugin with ``modname``. If ``consider_entry_points`` is True, entry point
         names are also considered to find a plugin.
@@ -843,19 +844,19 @@ class Config:
         """Backward compatibility"""
         return py.path.local(str(self.invocation_params.dir))
 
-    def add_cleanup(self, func):
+    def add_cleanup(self, func) -> None:
         """ Add a function to be called when the config object gets out of
         use (usually coninciding with pytest_unconfigure)."""
         self._cleanup.append(func)
 
-    def _do_configure(self):
+    def _do_configure(self) -> None:
         assert not self._configured
         self._configured = True
         with warnings.catch_warnings():
             warnings.simplefilter("default")
             self.hook.pytest_configure.call_historic(kwargs=dict(config=self))
 
-    def _ensure_unconfigure(self):
+    def _ensure_unconfigure(self) -> None:
         if self._configured:
             self._configured = False
             self.hook.pytest_unconfigure(config=self)

src/_pytest/mark/__init__.py

@@ -162,7 +162,7 @@ class KeywordMatcher:
         return False
 
 
-def deselect_by_keyword(items, config):
+def deselect_by_keyword(items, config: Config) -> None:
     keywordexpr = config.option.keyword.lstrip()
     if not keywordexpr:
         return
@@ -218,7 +218,7 @@ class MarkMatcher:
         return name in self.own_mark_names
 
 
-def deselect_by_mark(items, config):
+def deselect_by_mark(items, config: Config) -> None:
     matchexpr = config.option.markexpr
     if not matchexpr:
         return
@@ -243,7 +243,7 @@ def deselect_by_mark(items, config):
         items[:] = remaining
 
 
-def pytest_collection_modifyitems(items, config):
+def pytest_collection_modifyitems(items, config: Config) -> None:
     deselect_by_keyword(items, config)
     deselect_by_mark(items, config)
 

src/_pytest/mark/structures.py

@@ -271,7 +271,7 @@ class MarkDecorator:
         return self.with_args(*args, **kwargs)
 
 
-def get_unpacked_marks(obj):
+def get_unpacked_marks(obj) -> List[Mark]:
     """
     obtain the unpacked marks that are stored on an object
     """
@@ -400,8 +400,8 @@ class NodeKeywords(MutableMapping):
             seen.update(self.parent.keywords)
         return seen
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._seen())
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<NodeKeywords for node {}>".format(self.node)

src/_pytest/nodes.py

@@ -2,6 +2,7 @@ import os
 import warnings
 from functools import lru_cache
 from typing import Any
+from typing import Callable
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -312,7 +313,7 @@ class Node(metaclass=NodeMeta):
     def listnames(self):
         return [x.name for x in self.listchain()]
 
-    def addfinalizer(self, fin):
+    def addfinalizer(self, fin: Callable[[], object]) -> None:
         """ register a function to be called when this node is finalized.
 
         This method can only be called when this node is active

src/_pytest/runner.py

@@ -321,9 +321,9 @@ class SetupState:
 
     def __init__(self):
         self.stack = []  # type: List[Node]
-        self._finalizers = {}  # type: Dict[Node, List[Callable[[], None]]]
+        self._finalizers = {}  # type: Dict[Node, List[Callable[[], object]]]
 
-    def addfinalizer(self, finalizer, colitem):
+    def addfinalizer(self, finalizer: Callable[[], object], colitem) -> None:
         """ attach a finalizer to the given colitem. """
         assert colitem and not isinstance(colitem, tuple)
         assert callable(finalizer)
@@ -334,7 +334,7 @@ class SetupState:
         colitem = self.stack.pop()
         self._teardown_with_finalization(colitem)
 
-    def _callfinalizers(self, colitem):
+    def _callfinalizers(self, colitem) -> None:
         finalizers = self._finalizers.pop(colitem, None)
         exc = None
         while finalizers:
@@ -349,24 +349,24 @@ class SetupState:
         if exc:
             raise exc
 
-    def _teardown_with_finalization(self, colitem):
+    def _teardown_with_finalization(self, colitem) -> None:
         self._callfinalizers(colitem)
         colitem.teardown()
         for colitem in self._finalizers:
             assert colitem in self.stack
 
-    def teardown_all(self):
+    def teardown_all(self) -> None:
         while self.stack:
             self._pop_and_teardown()
         for key in list(self._finalizers):
             self._teardown_with_finalization(key)
         assert not self._finalizers
 
-    def teardown_exact(self, item, nextitem):
+    def teardown_exact(self, item, nextitem) -> None:
         needed_collectors = nextitem and nextitem.listchain() or []
         self._teardown_towards(needed_collectors)
 
-    def _teardown_towards(self, needed_collectors):
+    def _teardown_towards(self, needed_collectors) -> None:
         exc = None
         while self.stack:
             if self.stack == needed_collectors[: len(self.stack)]:
@@ -381,7 +381,7 @@ class SetupState:
         if exc:
             raise exc
 
-    def prepare(self, colitem):
+    def prepare(self, colitem) -> None:
         """ setup objects along the collector chain to the test-method
             and teardown previously setup objects."""
         needed_collectors = colitem.listchain()
@@ -390,14 +390,14 @@ class SetupState:
         # check if the last collection node has raised an error
         for col in self.stack:
             if hasattr(col, "_prepare_exc"):
-                exc = col._prepare_exc
+                exc = col._prepare_exc  # type: ignore[attr-defined] # noqa: F821
                 raise exc
         for col in needed_collectors[len(self.stack) :]:
             self.stack.append(col)
             try:
                 col.setup()
             except TEST_OUTCOME as e:
-                col._prepare_exc = e
+                col._prepare_exc = e  # type: ignore[attr-defined] # noqa: F821
                 raise e