Revert "added more informative test language and extra test case."

This reverts commit dd6ab9a.

Author: ngothingocmaiclht

tests/baselines/reference/dependentReturnType1.errors.txt

@@ -0,0 +1,314 @@
+file.js(155,13): error TS2322: Type 'undefined' is not assignable to type 'HelperCond<I, string, T | undefined, RegExp, SettingComposedValue<T>[]>'.
+file.js(168,16): error TS2536: Type 'I' cannot be used to index type '{ [s: string]: any; }'.
+file.js(185,9): error TS2322: Type 'Record<string, MyObj[]>' is not assignable to type 'HelperCond<T, string, MyObj[], undefined, Record<string, MyObj[]>>'.
+
+
+==== file.js (3 errors) ====
+    // Adapted from ts-error-deltas repos
+    
+    /**
+     * @template T
+     * @template A
+     * @template R1
+     * @template B
+     * @template R2
+     * @typedef {T extends A ? R1 : T extends B ? R2 : never} HelperCond
+     */
+    
+    /**
+     * @typedef IMessage
+     * @property {string} [html]
+     * @property {Object[]} [tokens]
+     */
+    
+    class NewKatex {
+        /**
+         * @param {string} s
+         * @returns {string}
+         */
+        render(s) {
+            return "";
+        }
+    
+        /**
+         * @template {string | IMessage} T
+         * @param {T} message
+         * @returns {T extends string ? string : T extends IMessage ? IMessage : never}
+         */
+        renderMessage(message) {
+            if (typeof message === 'string') {
+                return this.render(message); // Ok
+            }
+    
+            if (!message.html?.trim()) {
+                return message; // Ok
+            }
+    
+            if (!message.tokens) {
+                message.tokens = [];
+            }
+    
+            message.html = this.render(message.html);
+            return message; // Ok
+        }
+    }
+    
+    /**
+     * @template {true | false} T
+     * @param {{ dollarSyntax: boolean; parenthesisSyntax: boolean; }} options
+     * @param {T} _isMessage
+     * @returns {T extends true ? (message: IMessage) => IMessage : T extends false ? (message: string) => string : never}
+     */
+    function createKatexMessageRendering(options, _isMessage) {
+        const instance = new NewKatex();
+        if (_isMessage) {
+            return (/** @type {IMessage} */ message) => instance.renderMessage(message); // Ok
+        }
+        return (/** @type {string} */ message) => instance.renderMessage(message); // Ok
+    }
+    
+    // File: Rocket.Chat/apps/meteor/app/settings/lib/settings.ts
+    
+    /**
+     * @typedef {Record<any, any>} MyObj
+     */
+    
+    
+    /**
+     * @typedef {MyObj} SettingValue
+     */
+     
+    /**
+     * @template {SettingValue} T
+     * @typedef {Object} SettingComposedValue
+     * @property {string} key
+     * @property {SettingValue} value
+     */
+    
+    /**
+     * @callback SettingCallback
+     * @param {string} key
+     * @param {SettingValue} value
+     * @param {boolean} [initialLoad]
+     * @returns {void}
+     */
+    
+    /** @type {{ settings: { [s: string]: any } }} */
+    const Meteor = /** @type {any} */ (undefined);
+    /** @type {{ isRegExp(x: unknown): x is RegExp; }} */
+    const _ = /** @type {any} */ (undefined);
+    
+    /**
+     * @param {RegExp} x
+     * @returns {void}
+     */
+    function takesRegExp(x) {
+        return /** @type {any} */ undefined;
+    }
+    /**
+     * @param {string} x
+     * @returns {void}
+     */
+    function takesString(x) {
+        return /** @type {any} */ undefined;
+    }
+    
+    /**
+     * @class NewSettingsBase
+     */
+    class NewSettingsBase {
+        /**
+         * @template {SettingCallback | undefined} C
+         * @template {string | RegExp} I
+         * @template {SettingValue} T
+         * @param {I} _id
+         * @param {C} [callback]
+         * @returns {HelperCond<C, SettingCallback, void, undefined, HelperCond<I, string, T | undefined, RegExp, SettingComposedValue<T>[]>>}
+         */
+        newGet(_id, callback) {
+            if (callback !== undefined) {
+                if (!Meteor.settings) {
+                    return; // Ok
+                }
+                if (_id === '*') {
+                    return Object.keys(Meteor.settings).forEach((key) => {
+                        const value = Meteor.settings[key];
+                        callback(key, value);
+                    });
+                }
+                if (_.isRegExp(_id) && Meteor.settings) {
+                    return Object.keys(Meteor.settings).forEach((key) => {
+                        if (!_id.test(key)) {
+                            return;
+                        }
+                        const value = Meteor.settings[key];
+                        callback(key, value);
+                    });
+                }
+    
+                if (typeof _id === 'string') {
+                    const value = Meteor.settings[_id];
+                    if (value != null) {
+                        callback(_id, Meteor.settings[_id]);
+                    }
+                    return; // Ok
+                }
+    
+                return; // Ok, needed for exhaustiveness check
+            }
+    
+            if (!Meteor.settings) {
+                return undefined; // Error
+                ~~~~~~
+!!! error TS2322: Type 'undefined' is not assignable to type 'HelperCond<I, string, T | undefined, RegExp, SettingComposedValue<T>[]>'.
+            }
+    
+            if (_.isRegExp(_id)) {
+                return Object.keys(Meteor.settings).reduce((/** @type {SettingComposedValue<T>[]} */ items, key) => {
+                    const value = Meteor.settings[key];
+                    if (_id.test(key)) {
+                        items.push({ key, value });
+                    }
+                    return items;
+                }, []); // Ok
+            }
+    
+            return Meteor.settings?.[_id]; // Error
+                   ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2536: Type 'I' cannot be used to index type '{ [s: string]: any; }'.
+        }
+    }
+    
+    // File: Rocket.Chat/apps/meteor/app/ui-utils/client/lib/messageBox.ts
+    
+    /**
+     * @typedef {MyObj} MessageBoxAction
+     */
+    
+    /**
+     * @template {string | undefined} T
+     * @param {T} group
+     * @returns {HelperCond<T, string, MessageBoxAction[], undefined, Record<string, MessageBoxAction[]>>}
+     */
+    function getWithBug(group) {
+        if (!group) {
+            return /** @type {Record<string, MessageBoxAction[]>} */({}); // Error
+            ~~~~~~
+!!! error TS2322: Type 'Record<string, MyObj[]>' is not assignable to type 'HelperCond<T, string, MyObj[], undefined, Record<string, MyObj[]>>'.
+        }
+        return /** @type {MessageBoxAction[]} */([]); // Ok
+    }
+    
+    /**
+     * @template {string | undefined} T
+     * @param {T} group
+     * @returns {HelperCond<T, string, MessageBoxAction[], undefined, Record<string, MessageBoxAction[]>>}
+     */
+    function getWithoutBug(group) {
+        if (group === undefined) {
+            return /** @type {Record<string, MessageBoxAction[]>} */({}); // Ok
+        }
+        return /** @type {MessageBoxAction[]} */([]); // Ok
+    }
+    
+    // File: Rocket.Chat/apps/meteor/ee/server/lib/engagementDashboard/date.ts
+    
+    /**
+     * @param {string} x
+     * @returns {Date}
+     */
+    function mapDateForAPI(x) {
+        return /** @type {any} */ (undefined);
+    }
+    
+    /**
+     * @template {string | undefined} T
+     * @param {string} start
+     * @param {T} [end]
+     * @returns {HelperCond<T, string, { start: Date, end: Date }, undefined, { start: Date, end: undefined }>}
+     */
+    function transformDatesForAPI(start, end) {
+        return end !== undefined ?
+            {
+                start: mapDateForAPI(start),
+                end: mapDateForAPI(end),
+            } :
+            {
+                start: mapDateForAPI(start),
+                end: undefined
+            };
+    }
+    
+    // File: Rocket.Chat/packages/agenda/src/Agenda.ts
+    
+    /**
+     * @typedef {MyObj} RepeatOptions
+     */
+    
+    /**
+     * @typedef {MyObj} Job
+     */
+    
+    /**
+     * @typedef {Object} IJob
+     * @property {MyObj} data
+     */
+    class NewAgenda {
+        /**
+         * @param {string | number} interval
+         * @param {string} name
+         * @param {IJob['data']} data
+         * @param {RepeatOptions} options
+         * @returns {Promise<Job>}
+         */
+        async _createIntervalJob(interval, name, data, options) {
+            return /** @type {any} */ (undefined);
+        }
+    
+        /**
+         * @param {string | number} interval
+         * @param {string[]} names
+         * @param {IJob['data']} data
+         * @param {RepeatOptions} options
+         * @returns {Promise<Job[]> | undefined}
+         */
+        _createIntervalJobs(interval, names, data, options) {
+            return undefined;
+        }
+    
+        /**
+         * @template {string | string[]} T
+         * @param {string | number} interval
+         * @param {T} name
+         * @param {IJob['data']} data
+         * @param {RepeatOptions} options
+         * @returns {Promise<HelperCond<T, string, Job, string[], Job[] | undefined>>}
+         */
+        async newEvery(interval, name, data, options) {
+            if (typeof name === 'string') {
+                return this._createIntervalJob(interval, name, data, options); // Ok
+            }
+    
+            if (Array.isArray(name)) {
+                return this._createIntervalJobs(interval, name, data, options); // Ok
+            }
+    
+            throw new Error('Unexpected error: Invalid job name(s)');
+        }
+    }
+    
+    // File: angular/packages/common/src/pipes/case_conversion_pipes.ts
+    
+    /**
+     * @template {string | null | undefined} T
+     * @param {T} value
+     * @returns {HelperCond<T, string, string, null | undefined, null>}
+     */
+    function transform1(value) {
+        if (value == null) return null; // Ok
+        if (typeof value !== 'string') {
+            throw new Error();
+        }
+        return value.toLowerCase(); // Ok
+    }
+