Defer entry point syntax check to execution time

This way, we can use `pkgutil.resolve_name(..., strict=True)` and not have to
duplicate regex patterns or checking logic, nor do we have to resolve the
objects at parse time.

Author: warsaw

Lib/site.py

@@ -252,13 +252,9 @@ def _read_start_file(sitedir, name):
         line = line.strip()
         if len(line) == 0 or line.startswith("#"):
             continue
-
-        # Validate mandatory colon-form: pkg.mod:callable.
-        if ':' not in line:
-            _trace(f"In {filename!r}, line {n:d}: "
-                   f"skipping invalid entry point: {line}")
-            continue
-
+        # Syntax validation is deferred to entry-point execution time,
+        # where pkgutil.resolve_name(strict=True) enforces the
+        # pkg.mod:callable form.
         entrypoints.append(line)
 
 
@@ -312,15 +308,25 @@ def _execute_start_entrypoints():
 
     Called after all site-packages directories have been processed so that
     sys.path is fully populated before any entry point code runs.  Uses
-    pkgutil.resolve_name() for resolution.  While that function accepts a
-    looser constraint on the input string, we enforce the :callable syntax
-    when the .start file is parsed.
+    pkgutil.resolve_name(strict=True) which both validates the strict
+    pkg.mod:callable form and resolves the entry point in one step.
     """
     for filename, entrypoints in _pending_entrypoints.items():
         for entrypoint in entrypoints:
             try:
                 _trace(f"Executing entry point: {entrypoint} from {filename}")
-                callable_ = pkgutil.resolve_name(entrypoint)
+                callable_ = pkgutil.resolve_name(entrypoint, strict=True)
+            except ValueError as exc:
+                _print_error(
+                    f"Invalid entry point syntax in {filename}: "
+                    f"{entrypoint!r}", exc)
+                continue
+            except Exception as exc:
+                _print_error(
+                    f"Error resolving entry point {entrypoint} "
+                    f"from {filename}", exc)
+                continue
+            try:
                 callable_()
             except Exception as exc:
                 _print_error(

Lib/test/test_site.py

@@ -986,12 +986,28 @@ def test_read_start_file_comments_and_blanks(self):
         fullname = os.path.join(self.sitedir, 'foo.start')
         self.assertEqual(site._pending_entrypoints[fullname], ['os.path:join'])
 
-    def test_read_start_file_missing_colon_skipped(self):
-        # Entry points without the mandatory colon are skipped.
-        self._make_start("os.path\nos.path:join\n", name='foo')
+    def test_read_start_file_accepts_all_non_blank_lines(self):
+        # Syntax validation is deferred to entry-point execution time
+        # (where pkgutil.resolve_name(strict=True) enforces the strict
+        # pkg.mod:callable form), so parsing accepts every non-blank,
+        # non-comment line, including syntactically invalid ones.
+        content = (
+            "os.path\n"                 # no colon
+            "pkg.mod:\n"                # empty callable
+            ":callable\n"               # empty module
+            "pkg.mod:callable:extra\n"  # multiple colons
+            "os.path:join\n"            # valid
+        )
+        self._make_start(content, name='foo')
         site._read_start_file(self.sitedir, 'foo.start')
         fullname = os.path.join(self.sitedir, 'foo.start')
-        self.assertEqual(site._pending_entrypoints[fullname], ['os.path:join'])
+        self.assertEqual(site._pending_entrypoints[fullname], [
+            'os.path',
+            'pkg.mod:',
+            ':callable',
+            'pkg.mod:callable:extra',
+            'os.path:join',
+        ])
 
     def test_read_start_file_empty(self):
         # PEP 829: an empty .start file is still registered as present
@@ -1118,6 +1134,26 @@ def test_execute_entrypoints_import_error(self):
         self.assertIn('nosuchmodule_xyz', err.getvalue())
         # os.path:join should still have been called (no exception for it)
 
+    def test_execute_entrypoints_strict_syntax_rejection(self):
+        # PEP 829: only the strict pkg.mod:callable form is valid.
+        # At entry-point execution, pkgutil.resolve_name(strict=True)
+        # raises ValueError for invalid syntax; the invalid entry is
+        # reported and execution continues with the next one.
+        fullname = os.path.join(self.sitedir, 'bad.start')
+        site._pending_entrypoints[fullname] = [
+            'os.path',                  # no colon
+            'pkg.mod:',                 # empty callable
+            ':callable',                # empty module
+            'pkg.mod:callable:extra',   # multiple colons
+        ]
+        with captured_stderr() as err:
+            site._execute_start_entrypoints()
+        out = err.getvalue()
+        self.assertIn('Invalid entry point syntax', out)
+        for bad in ('os.path', 'pkg.mod:', ':callable',
+                    'pkg.mod:callable:extra'):
+            self.assertIn(bad, out)
+
     def test_execute_entrypoints_callable_error(self):
         # Callable that raises prints traceback but continues.
         mod_dir = os.path.join(self.sitedir, 'badmod')