main: put parametrization in a separate field on CollectionArgument

This is for the benefit of the next commit. That commit wants to check
whether a CollectionArgument is subsumed by another. According to pytest
semantics:
    `test_it.py::TestIt::test_it[a]` subsumed by `test_it.py::TestIt::test_it`
However the `parts` are
    ["TestIt", test_it[a]"]                       ["TestIt", test_it"]
which means a simple list prefix cannot be used. By splitting the
parametrization `"[a]"` part to its own attribute, it can be handled
cleanly.

I also think this is a reasonable change regardless. We'd probably want
something like this when the "collection structure contains
parametrization" TODO is tackled.

Author: bluetech

src/_pytest/main.py

@@ -859,6 +859,7 @@ def collect(self) -> Iterator[nodes.Item | nodes.Collector]:
 
             argpath = collection_argument.path
             names = collection_argument.parts
+            parametrization = collection_argument.parametrization
             module_name = collection_argument.module_name
 
             # resolve_collection_argument() ensures this.
@@ -943,12 +944,18 @@ def collect(self) -> Iterator[nodes.Item | nodes.Collector]:
 
                     # Name part e.g. `TestIt` in `/a/b/test_file.py::TestIt::test_it`.
                     else:
-                        # TODO: Remove parametrized workaround once collection structure contains
-                        # parametrization.
-                        is_match = (
-                            node.name == matchparts[0]
-                            or node.name.split("[")[0] == matchparts[0]
-                        )
+                        if len(matchparts) == 1:
+                            # This the last part, one parametrization goes.
+                            if parametrization is not None:
+                                # A parametrized arg must match exactly.
+                                is_match = node.name == matchparts[0] + parametrization
+                            else:
+                                # A non-parameterized arg matches all parametrizations (if any).
+                                # TODO: Remove the hacky split once the collection structure
+                                # contains parametrization.
+                                is_match = node.name.split("[")[0] == matchparts[0]
+                        else:
+                            is_match = node.name == matchparts[0]
                     if is_match:
                         work.append((node, matchparts[1:]))
                         any_matched_in_collector = True
@@ -1024,6 +1031,7 @@ class CollectionArgument:
 
     path: Path
     parts: Sequence[str]
+    parametrization: str | None
     module_name: str | None
 
 
@@ -1052,14 +1060,15 @@ def resolve_collection_argument(
     When as_pypath is True, expects that the command-line argument actually contains
     module paths instead of file-system paths:
 
-        "pkg.tests.test_foo::TestClass::test_foo"
+        "pkg.tests.test_foo::TestClass::test_foo[a,b]"
 
     In which case we search sys.path for a matching module, and then return the *path* to the
     found module, which may look like this:
 
         CollectionArgument(
             path=Path("/home/u/myvenv/lib/site-packages/pkg/tests/test_foo.py"),
             parts=["TestClass", "test_foo"],
+            parametrization="[a,b]",
             module_name="pkg.tests.test_foo",
         )
 
@@ -1068,10 +1077,9 @@ def resolve_collection_argument(
     """
     base, squacket, rest = arg.partition("[")
     strpath, *parts = base.split("::")
-    if squacket:
-        if not parts:
-            raise UsageError(f"path cannot contain [] parametrization: {arg}")
-        parts[-1] = f"{parts[-1]}{squacket}{rest}"
+    if squacket and not parts:
+        raise UsageError(f"path cannot contain [] parametrization: {arg}")
+    parametrization = f"{squacket}{rest}" if squacket else None
     module_name = None
     if as_pypath:
         pyarg_strpath = search_pypath(
@@ -1099,5 +1107,6 @@ def resolve_collection_argument(
     return CollectionArgument(
         path=fspath,
         parts=parts,
+        parametrization=parametrization,
         module_name=module_name,
     )

testing/test_main.py

@@ -125,27 +125,39 @@ def test_file(self, invocation_path: Path) -> None:
         ) == CollectionArgument(
             path=invocation_path / "src/pkg/test.py",
             parts=[],
+            parametrization=None,
             module_name=None,
         )
         assert resolve_collection_argument(
             invocation_path, "src/pkg/test.py::"
         ) == CollectionArgument(
             path=invocation_path / "src/pkg/test.py",
             parts=[""],
+            parametrization=None,
             module_name=None,
         )
         assert resolve_collection_argument(
             invocation_path, "src/pkg/test.py::foo::bar"
         ) == CollectionArgument(
             path=invocation_path / "src/pkg/test.py",
             parts=["foo", "bar"],
+            parametrization=None,
             module_name=None,
         )
         assert resolve_collection_argument(
             invocation_path, "src/pkg/test.py::foo::bar::"
         ) == CollectionArgument(
             path=invocation_path / "src/pkg/test.py",
             parts=["foo", "bar", ""],
+            parametrization=None,
+            module_name=None,
+        )
+        assert resolve_collection_argument(
+            invocation_path, "src/pkg/test.py::foo::bar[a,b,c]"
+        ) == CollectionArgument(
+            path=invocation_path / "src/pkg/test.py",
+            parts=["foo", "bar"],
+            parametrization="[a,b,c]",
             module_name=None,
         )
 
@@ -156,6 +168,7 @@ def test_dir(self, invocation_path: Path) -> None:
         ) == CollectionArgument(
             path=invocation_path / "src/pkg",
             parts=[],
+            parametrization=None,
             module_name=None,
         )
 
@@ -181,13 +194,15 @@ def test_pypath(self, namespace_package: bool, invocation_path: Path) -> None:
         ) == CollectionArgument(
             path=invocation_path / "src/pkg/test.py",
             parts=[],
+            parametrization=None,
             module_name="pkg.test",
         )
         assert resolve_collection_argument(
             invocation_path, "pkg.test::foo::bar", as_pypath=True
         ) == CollectionArgument(
             path=invocation_path / "src/pkg/test.py",
             parts=["foo", "bar"],
+            parametrization=None,
             module_name="pkg.test",
         )
         assert resolve_collection_argument(
@@ -198,6 +213,7 @@ def test_pypath(self, namespace_package: bool, invocation_path: Path) -> None:
         ) == CollectionArgument(
             path=invocation_path / "src/pkg",
             parts=[],
+            parametrization=None,
             module_name="pkg",
         )
 
@@ -216,7 +232,8 @@ def test_parametrized_name_with_colons(self, invocation_path: Path) -> None:
             invocation_path, "src/pkg/test.py::test[a::b]"
         ) == CollectionArgument(
             path=invocation_path / "src/pkg/test.py",
-            parts=["test[a::b]"],
+            parts=["test"],
+            parametrization="[a::b]",
             module_name=None,
         )
 
@@ -257,6 +274,7 @@ def test_absolute_paths_are_resolved_correctly(self, invocation_path: Path) -> N
         ) == CollectionArgument(
             path=Path(os.path.abspath("src")),
             parts=[],
+            parametrization=None,
             module_name=None,
         )
 
@@ -268,6 +286,7 @@ def test_absolute_paths_are_resolved_correctly(self, invocation_path: Path) -> N
         ) == CollectionArgument(
             path=Path(os.path.abspath("src")),
             parts=[],
+            parametrization=None,
             module_name=None,
         )