Remove jsTypings/semver.ts, add unit tests and logging

Author: rbuckton

src/compiler/diagnosticMessages.json

@@ -3671,6 +3671,14 @@
         "category": "Error",
         "code": 6205
     },
+    "'package.json' has invalid version '{0}' in 'typesVersions' field.": {
+        "category": "Message",
+        "code": 6206
+    },
+    "'package.json' does not have a 'typesVersions' entry that matches version '{0}'.": {
+        "category": "Message",
+        "code": 6207
+    },
 
     "Projects to reference": {
         "category": "Message",

src/compiler/moduleNameResolver.ts

@@ -127,20 +127,30 @@ namespace ts {
 
     /* @internal */
     export function getPackageJsonTypesVersionsOverride(typesVersions: MapLike<string>) {
-        const typeScriptVersion = Version.parse(versionMajorMinor);
+        return getPackageJsonTypesVersionsOverrideWithTrace(typesVersions, /*state*/ undefined);
+    }
+
+    let typeScriptVersion: Version | undefined;
+
+    function getPackageJsonTypesVersionsOverrideWithTrace(typesVersions: MapLike<string>, state: ModuleResolutionState | undefined) {
+        if (!typeScriptVersion) typeScriptVersion = new Version(versionMajorMinor);
+
         let bestVersion: Version | undefined;
         let bestVersionKey: string | undefined;
         for (const key in typesVersions) {
             if (!hasProperty(typesVersions, key)) continue;
 
             const keyVersion = Version.tryParse(key);
             if (keyVersion === undefined) {
+                if (state && state.traceEnabled) {
+                    trace(state.host, Diagnostics.package_json_has_invalid_version_0_in_typesVersions_field, key);
+                }
                 continue;
             }
 
             // match the greatest version less than the current TypeScript version
-            if (keyVersion.compareTo(typeScriptVersion) <= 0
-                && (bestVersion === undefined || keyVersion.compareTo(bestVersion) > 0)) {
+            if (keyVersion.compareTo(bestVersion) > 0 &&
+                keyVersion.compareTo(typeScriptVersion) <= 0) {
                 bestVersion = keyVersion;
                 bestVersionKey = key;
             }
@@ -169,22 +179,25 @@ namespace ts {
             return;
         }
 
-        const result = getPackageJsonTypesVersionsOverride(typesVersions);
+        const result = getPackageJsonTypesVersionsOverrideWithTrace(typesVersions, state);
         if (!result) {
-            return undefined;
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, versionMajorMinor);
+            }
+            return;
         }
 
         const { version: bestVersionKey, directory: bestVersionPath } = result;
         if (!isString(bestVersionPath)) {
             if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, `typesVersion['${bestVersionKey}']`, "string", typeof bestVersionPath);
+                trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, `typesVersions['${bestVersionKey}']`, "string", typeof bestVersionPath);
             }
             return;
         }
 
         if (state.traceEnabled) {
             const path = normalizePath(combinePaths(baseDirectory, bestVersionPath));
-            trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, `typesVersion['${bestVersionKey}']`, bestVersionPath, path);
+            trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, `typesVersions['${bestVersionKey}']`, bestVersionPath, path);
         }
 
         return bestVersionPath;

src/compiler/semver.ts

@@ -1,48 +1,49 @@
 /* @internal */
 namespace ts {
-    // Per https://semver.org/#spec-item-2:
-    //
+    // https://semver.org/#spec-item-2
     // > A normal version number MUST take the form X.Y.Z where X, Y, and Z are non-negative
     // > integers, and MUST NOT contain leading zeroes. X is the major version, Y is the minor
     // > version, and Z is the patch version. Each element MUST increase numerically.
     //
     // NOTE: We differ here in that we allow X and X.Y, with missing parts having the default
     // value of `0`.
-    const versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:(\+[a-z0-9-.]+))?)?)?$/i;
+    const versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i;
 
-    // Per https://semver.org/#spec-item-9:
-    //
+    // https://semver.org/#spec-item-9
     // > A pre-release version MAY be denoted by appending a hyphen and a series of dot separated
     // > identifiers immediately following the patch version. Identifiers MUST comprise only ASCII
     // > alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers
     // > MUST NOT include leading zeroes.
     const prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i;
 
-    // Per https://semver.org/#spec-item-10:
-    //
+    // https://semver.org/#spec-item-10
     // > Build metadata MAY be denoted by appending a plus sign and a series of dot separated
     // > identifiers immediately following the patch or pre-release version. Identifiers MUST
     // > comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty.
     const buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i;
 
-    // Per https://semver.org/#spec-item-9:
-    //
+    // https://semver.org/#spec-item-9
     // > Numeric identifiers MUST NOT include leading zeroes.
     const numericIdentifierRegExp = /^(0|[1-9]\d*)$/;
 
     /**
-     * Describes a precise semantic version number, per https://semver.org
+     * Describes a precise semantic version number, https://semver.org
      */
     export class Version {
-        static readonly zero = new Version(0);
-
         readonly major: number;
         readonly minor: number;
         readonly patch: number;
         readonly prerelease: ReadonlyArray<string>;
         readonly build: ReadonlyArray<string>;
 
-        constructor(major: number, minor = 0, patch = 0, prerelease = "", build = "") {
+        constructor(text: string);
+        constructor(major: number, minor?: number, patch?: number, prerelease?: string, build?: string);
+        constructor(major: number | string, minor = 0, patch = 0, prerelease = "", build = "") {
+            if (typeof major === "string") {
+                const result = Debug.assertDefined(tryParseComponents(major), "Invalid version");
+                ({ major, minor, patch, prerelease, build } = result);
+            }
+
             Debug.assert(major >= 0, "Invalid argument: major");
             Debug.assert(minor >= 0, "Invalid argument: minor");
             Debug.assert(patch >= 0, "Invalid argument: patch");
@@ -51,104 +52,102 @@ namespace ts {
             this.major = major;
             this.minor = minor;
             this.patch = patch;
-            this.prerelease = prerelease === "" ? emptyArray : prerelease.split(".");
-            this.build = build === "" ? emptyArray : build.split(".");
-        }
-
-        static parse(text: string) {
-            return Debug.assertDefined(this.tryParse(text));
+            this.prerelease = prerelease ? prerelease.split(".") : emptyArray;
+            this.build = build ? build.split(".") : emptyArray;
         }
 
         static tryParse(text: string) {
-            const match = versionRegExp.exec(text);
-            if (!match) return undefined;
+            const result = tryParseComponents(text);
+            if (!result) return undefined;
 
-            const [, major, minor = 0, patch = 0, prerelease, build] = match;
-            if (prerelease && !prereleaseRegExp.test(prerelease)) return undefined;
-            if (build && !buildRegExp.test(build)) return undefined;
-            return new Version(+major, +minor, +patch, prerelease, build);
+            const { major, minor, patch, prerelease, build } = result;
+            return new Version(major, minor, patch, prerelease, build);
         }
 
-        static compare(left: Version | undefined, right: Version | undefined, compareBuildMetadata?: boolean) {
-            // Per https://semver.org/#spec-item-11:
-            //
+        compareTo(other: Version | undefined) {
+            // https://semver.org/#spec-item-11
             // > Precedence is determined by the first difference when comparing each of these
             // > identifiers from left to right as follows: Major, minor, and patch versions are
             // > always compared numerically.
             //
-            // > When major, minor, and patch are equal, a pre-release version has lower
-            // > precedence than a normal version.
+            // https://semver.org/#spec-item-11
+            // > Precedence for two pre-release versions with the same major, minor, and patch version
+            // > MUST be determined by comparing each dot separated identifier from left to right until
+            // > a difference is found [...]
             //
-            // Per https://semver.org/#spec-item-10:
-            //
-            // > Build metadata SHOULD be ignored when determining version precedence.
-            if (left === right) return Comparison.EqualTo;
-            if (left === undefined) return Comparison.LessThan;
-            if (right === undefined) return Comparison.GreaterThan;
-            return compareValues(left.major, right.major)
-                || compareValues(left.minor, right.minor)
-                || compareValues(left.patch, right.patch)
-                || compareVersionFragments(left.prerelease, right.prerelease, /*compareNumericIdentifiers*/ true)
-                || (compareBuildMetadata ? compareVersionFragments(left.build, right.build, /*compareNumericIdentifiers*/ false) : Comparison.EqualTo);
-        }
-
-        compareTo(other: Version, compareBuildMetadata?: boolean) {
-            return Version.compare(this, other, compareBuildMetadata);
+            // https://semver.org/#spec-item-11
+            // > Build metadata does not figure into precedence
+            if (this === other) return Comparison.EqualTo;
+            if (other === undefined) return Comparison.GreaterThan;
+            return compareValues(this.major, other.major)
+                || compareValues(this.minor, other.minor)
+                || compareValues(this.patch, other.patch)
+                || comparePrerelaseIdentifiers(this.prerelease, other.prerelease);
         }
 
         toString() {
             let result = `${this.major}.${this.minor}.${this.patch}`;
-            if (this.prerelease) result += `-${this.prerelease.join(".")}`;
-            if (this.build) result += `+${this.build.join(".")}`;
+            if (some(this.prerelease)) result += `-${this.prerelease.join(".")}`;
+            if (some(this.build)) result += `+${this.build.join(".")}`;
             return result;
         }
     }
 
-    function compareVersionFragments(left: ReadonlyArray<string>, right: ReadonlyArray<string>, compareNumericIdentifiers: boolean) {
-        // Per https://semver.org/#spec-item-11:
-        //
+    function tryParseComponents(text: string) {
+        const match = versionRegExp.exec(text);
+        if (!match) return undefined;
+
+        const [, major, minor = "0", patch = "0", prerelease = "", build = ""] = match;
+        if (prerelease && !prereleaseRegExp.test(prerelease)) return undefined;
+        if (build && !buildRegExp.test(build)) return undefined;
+        return {
+            major: parseInt(major, 10),
+            minor: parseInt(minor, 10),
+            patch: parseInt(patch, 10),
+            prerelease,
+            build
+        };
+    }
+
+    function comparePrerelaseIdentifiers(left: ReadonlyArray<string>, right: ReadonlyArray<string>) {
+        // https://semver.org/#spec-item-11
         // > When major, minor, and patch are equal, a pre-release version has lower precedence
         // > than a normal version.
         if (left === right) return Comparison.EqualTo;
         if (left.length === 0) return right.length === 0 ? Comparison.EqualTo : Comparison.GreaterThan;
         if (right.length === 0) return Comparison.LessThan;
 
-        // Per https://semver.org/#spec-item-11:
-        //
+        // https://semver.org/#spec-item-11
         // > Precedence for two pre-release versions with the same major, minor, and patch version
         // > MUST be determined by comparing each dot separated identifier from left to right until
-        // > a difference is found
+        // > a difference is found [...]
         const length = Math.min(left.length, right.length);
         for (let i = 0; i < length; i++) {
             const leftIdentifier = left[i];
             const rightIdentifier = right[i];
             if (leftIdentifier === rightIdentifier) continue;
 
-            const leftIsNumeric = compareNumericIdentifiers && numericIdentifierRegExp.test(leftIdentifier);
-            const rightIsNumeric = compareNumericIdentifiers && numericIdentifierRegExp.test(rightIdentifier);
+            const leftIsNumeric = numericIdentifierRegExp.test(leftIdentifier);
+            const rightIsNumeric = numericIdentifierRegExp.test(rightIdentifier);
             if (leftIsNumeric || rightIsNumeric) {
-                // Per https://semver.org/#spec-item-11:
-                //
+                // https://semver.org/#spec-item-11
                 // > Numeric identifiers always have lower precedence than non-numeric identifiers.
                 if (leftIsNumeric !== rightIsNumeric) return leftIsNumeric ? Comparison.LessThan : Comparison.GreaterThan;
 
-                // Per https://semver.org/#spec-item-11:
-                //
+                // https://semver.org/#spec-item-11
                 // > identifiers consisting of only digits are compared numerically
                 const result = compareValues(+leftIdentifier, +rightIdentifier);
                 if (result) return result;
             }
             else {
-                // Per https://semver.org/#spec-item-11:
-                //
+                // https://semver.org/#spec-item-11
                 // > identifiers with letters or hyphens are compared lexically in ASCII sort order.
                 const result = compareStringsCaseSensitive(leftIdentifier, rightIdentifier);
                 if (result) return result;
             }
         }
 
-        // Per https://semver.org/#spec-item-11:
-        //
+        // https://semver.org/#spec-item-11
         // > A larger set of pre-release fields has a higher precedence than a smaller set, if all
         // > of the preceding identifiers are equal.
         return compareValues(left.length, right.length);

src/jsTyping/jsTyping.ts

@@ -21,13 +21,13 @@ namespace ts.JsTyping {
 
     export interface CachedTyping {
         typingLocation: string;
-        version: Semver;
+        version: Version;
     }
 
     /* @internal */
     export function isTypingUpToDate(cachedTyping: CachedTyping, availableTypingVersions: MapLike<string>) {
-        const availableVersion = Semver.parse(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest")!);
-        return !availableVersion.greaterThan(cachedTyping.version);
+        const availableVersion = new Version(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest")!);
+        return availableVersion.compareTo(cachedTyping.version) <= 0;
     }
 
     /* @internal */

src/jsTyping/semver.ts

@@ -16,7 +16,6 @@
     "files": [
         "shared.ts",
         "types.ts",
-        "jsTyping.ts",
-        "semver.ts"
+        "jsTyping.ts"
     ]
 }

src/jsTyping/tsconfig.json

@@ -73,6 +73,7 @@
         "unittests/publicApi.ts",
         "unittests/reuseProgramStructure.ts",
         "unittests/session.ts",
+        "unittests/semver.ts",
         "unittests/symbolWalker.ts",
         "unittests/telemetry.ts",
         "unittests/textChanges.ts",