Address PR review on prerelease parsing and upper bounds

Accept every prerelease spelling consistently. The parser had separate
branches for the dotted `sys.version_info` form and the compact form, so
word aliases without dots such as `3.14.0alpha1` were rejected even
though the previous PEP 440-based matching accepted them. One alternation
now covers all spellings with optional `.`, `-`, or `_` separators, which
also removes the duplicated level and serial capture groups.

Encode the exclusive upper bound prerelease rule per clause. Prerelease
admission was applied to the specifier as a whole, so `3.14.0rc1`
satisfied `>=3.13.0rc1,<3.14` because another clause named a prerelease.
An exclusive bound now rejects prereleases of its own release, while
`<3.14.0rc2` still admits them.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 6444890d-5c9c-4e8e-82b3-37a157ead632

Author: edvilme

src/common/pythonVersion.ts

@@ -4,11 +4,11 @@ type PythonReleaseLevel = 'alpha' | 'beta' | 'candidate' | 'final';
 const RELEASE_LEVELS: readonly PythonReleaseLevel[] = ['alpha', 'beta', 'candidate', 'final'];
 
 /**
- * Maps the alternative spellings onto the release level they name.
+ * Maps the abbreviated spellings onto the release level they name.
  *
- * Python reports `alpha`, `beta`, and `candidate`, while version strings use
- * the compact `a`, `b`, and `rc`. A specifier may also spell a release
- * candidate `c`, `pre`, or `preview`.
+ * Python reports `alpha`, `beta`, and `candidate`, while version strings
+ * abbreviate them as `a`, `b`, and `rc`. A release candidate may also be
+ * spelled `c`, `pre`, or `preview`.
  */
 const RELEASE_LEVEL_ALIASES: Readonly<Record<string, PythonReleaseLevel>> = {
     a: 'alpha',
@@ -19,8 +19,16 @@ const RELEASE_LEVEL_ALIASES: Readonly<Record<string, PythonReleaseLevel>> = {
     preview: 'candidate',
 };
 
+/**
+ * Matches a release, optionally followed by a prerelease level and serial.
+ *
+ * Every spelling of a level is accepted in one alternation, so the dotted
+ * `sys.version_info` form and the compact and separated forms differ only in
+ * their optional `.`, `-`, or `_` separators. Longer spellings precede the
+ * abbreviations they start with, so `alpha` wins over `a`.
+ */
 const VERSION_PATTERN =
-    /^(?<major>\d+)(?:\.(?<minor>\d+))?(?:\.(?<patch>\d+))?(?:(?:\.(?<longLevel>alpha|beta|candidate|final)\.(?<longSerial>\d+))|(?:(?<shortLevel>preview|pre|rc|a|b|c)[._-]?(?<shortSerial>\d+)))?$/i;
+    /^(?<major>\d+)(?:\.(?<minor>\d+))?(?:\.(?<patch>\d+))?(?:[._-]?(?<level>alpha|beta|candidate|final|preview|pre|rc|a|b|c)[._-]?(?<serial>\d+))?$/i;
 
 /**
  * A Python interpreter release, such as `3.12.4` or `3.14.0rc1`.
@@ -35,9 +43,9 @@ export class PythonVersion {
     /**
      * Creates a normalized Python release version.
      *
-     * Missing minor and patch components are normalized to zero. Python
-     * `sys.version_info` suffixes and compact prerelease suffixes are
-     * normalized, so `3.14.0.beta.1` and `3.14.0b1` are both represented as
+     * Missing minor and patch components are normalized to zero. Every
+     * spelling of a prerelease is normalized, so `3.14.0.beta.1`,
+     * `3.14.0beta1`, `3.14.0-beta-1`, and `3.14.0b1` are all represented as
      * `3.14.0b1`.
      *
      * @param version A Python release version.
@@ -55,8 +63,8 @@ export class PythonVersion {
         this.major = Number(groups.major);
         this.minor = Number(groups.minor ?? 0);
         this.patch = Number(groups.patch ?? 0);
-        this.releaseLevel = toReleaseLevel(groups.longLevel ?? groups.shortLevel);
-        this.releaseSerial = Number(groups.longSerial ?? groups.shortSerial ?? 0);
+        this.releaseLevel = toReleaseLevel(groups.level);
+        this.releaseSerial = Number(groups.serial ?? 0);
         if (
             ![this.major, this.minor, this.patch, this.releaseSerial].every(Number.isSafeInteger) ||
             (this.releaseLevel === 'final' && this.releaseSerial !== 0)

src/common/pythonVersionSpecifier.ts

@@ -8,7 +8,7 @@ import { PythonVersion } from './pythonVersion';
  * specifier as a whole.
  */
 interface VersionClause {
-    /** Tests a version against this clause alone, ignoring prerelease exclusion. */
+    /** Tests a version against this clause alone. */
     readonly matches: (version: PythonVersion) => boolean;
     /** Whether this clause explicitly names a prerelease. */
     readonly allowsPrereleases: boolean;
@@ -86,6 +86,8 @@ export class PythonVersionSpecifier {
      *
      * A prerelease only satisfies a specifier that itself names a prerelease,
      * so `3.14.0rc1` does not satisfy `>=3.11` but does satisfy `>=3.14.0rc1`.
+     * An exclusive upper bound still rejects prereleases of its own release,
+     * so `3.14.0rc1` does not satisfy `>=3.13.0rc1,<3.14`.
      *
      * @param version The version to test.
      */
@@ -147,5 +149,18 @@ function parseClause(clause: string): VersionClause | undefined {
     }
 
     const comparison = COMPARISONS[operator];
-    return comparison ? { matches: (version) => comparison(version.compareTo(bound)), allowsPrereleases } : undefined;
+    if (!comparison) {
+        return undefined;
+    }
+
+    // An exclusive upper bound never admits a prerelease of the bound itself,
+    // so `<3.14` rejects `3.14.0rc1` even when another clause names a
+    // prerelease, while `<3.14.0rc2` still admits it.
+    const excludesBoundPrereleases = operator === '<' && !allowsPrereleases;
+    return {
+        matches: (version) =>
+            comparison(version.compareTo(bound)) &&
+            !(excludesBoundPrereleases && version.releaseLevel !== 'final' && version.matchesReleasePrefix(bound, 3)),
+        allowsPrereleases,
+    };
 }

src/test/common/pythonVersion.unit.test.ts

@@ -19,6 +19,22 @@ suite('PythonVersion', () => {
         assert.strictEqual(new PythonVersion('3.15.0rc1').toString(), '3.15.0rc1');
     });
 
+    test('normalizes every prerelease spelling and separator', () => {
+        assert.strictEqual(new PythonVersion('3.14.0alpha1').toString(), '3.14.0a1');
+        assert.strictEqual(new PythonVersion('3.14.0beta1').toString(), '3.14.0b1');
+        assert.strictEqual(new PythonVersion('3.14.0candidate1').toString(), '3.14.0rc1');
+        assert.strictEqual(new PythonVersion('3.14.0-alpha-1').toString(), '3.14.0a1');
+        assert.strictEqual(new PythonVersion('3.14.0_alpha_1').toString(), '3.14.0a1');
+        assert.strictEqual(new PythonVersion('3.14.0.alpha.1').toString(), '3.14.0a1');
+        assert.strictEqual(new PythonVersion('3.14.0ALPHA1').toString(), '3.14.0a1');
+    });
+
+    test('treats every release-candidate alias as the same level', () => {
+        for (const alias of ['rc1', 'c1', 'pre1', 'preview1', 'candidate1']) {
+            assert.strictEqual(new PythonVersion(`3.14.0${alias}`).toString(), '3.14.0rc1', alias);
+        }
+    });
+
     test('compares each numeric component in order', () => {
         assert.ok(new PythonVersion('3.9').compareTo(new PythonVersion('3.10')) < 0);
         assert.ok(new PythonVersion('3.12.9').compareTo(new PythonVersion('3.12.10')) < 0);

src/test/common/pythonVersionSpecifier.unit.test.ts

@@ -69,6 +69,14 @@ suite('PythonVersionSpecifier', () => {
         assert.strictEqual(matches('3.14.0b1', '==3.14.*'), false);
     });
 
+    test('excludes prereleases of an exclusive upper bound', () => {
+        assert.strictEqual(matches('3.14.0rc1', '>=3.13.0rc1,<3.14'), false);
+        assert.strictEqual(matches('3.13.5rc1', '>=3.13.0rc1,<3.14'), true);
+        assert.strictEqual(matches('3.14.0rc1', '>=3.13.0rc1,<3.14.0rc2'), true);
+        assert.strictEqual(matches('3.14.0rc1', '>=3.13.0rc1,<=3.14'), true);
+        assert.strictEqual(matches('3.13.9', '>=3.13,<3.14'), true);
+    });
+
     test('accepts a leading v on the literal', () => {
         assert.strictEqual(matches('3.12.4', '>=v3.11'), true);
         assert.strictEqual(matches('3.12.4', '==v3.12.*'), true);