Merge remote-tracking branch 'origin/main' into release-4.5

Author: typescript-bot

package-lock.json

@@ -619,7 +619,7 @@ namespace ts.moduleSpecifiers {
         const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
         const packageName = getPackageNameFromTypesPackageName(nodeModulesDirectoryName);
         // For classic resolution, only allow importing from node_modules/@types, not other node_modules
-        return getEmitModuleResolutionKind(options) !== ModuleResolutionKind.NodeJs && packageName === nodeModulesDirectoryName ? undefined : packageName;
+        return getEmitModuleResolutionKind(options) === ModuleResolutionKind.Classic && packageName === nodeModulesDirectoryName ? undefined : packageName;
 
         function tryDirectoryWithPackageJson(packageRootIndex: number) {
             const packageRootPath = path.substring(0, packageRootIndex);

src/compiler/checker.ts

@@ -7415,4 +7415,8 @@ namespace ts {
         const declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
         return !!declaration && (isParameter(declaration) || isCatchClauseVariableDeclaration(declaration));
     }
+
+    export function isFunctionExpressionOrArrowFunction(node: Node): node is FunctionExpression | ArrowFunction {
+        return node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.ArrowFunction;
+    }
 }

src/compiler/moduleSpecifiers.ts

@@ -0,0 +1,50 @@
+//// [assertionTypePredicates2.js]
+/**
+ * @typedef {{ x: number }} A
+ */
+
+/**
+ * @typedef { A & { y: number } } B
+ */
+
+/**
+ * @param {A} a
+ * @returns { asserts a is B }
+ */
+const foo = (a) => {
+    if (/** @type { B } */ (a).y !== 0) throw TypeError();
+    return undefined;
+};
+
+export const main = () => {
+    /** @type { A } */
+    const a = { x: 1 };
+    foo(a);
+};
+
+
+//// [assertionTypePredicates2.js]
+"use strict";
+/**
+ * @typedef {{ x: number }} A
+ */
+exports.__esModule = true;
+exports.main = void 0;
+/**
+ * @typedef { A & { y: number } } B
+ */
+/**
+ * @param {A} a
+ * @returns { asserts a is B }
+ */
+var foo = function (a) {
+    if ( /** @type { B } */(a).y !== 0)
+        throw TypeError();
+    return undefined;
+};
+var main = function () {
+    /** @type { A } */
+    var a = { x: 1 };
+    foo(a);
+};
+exports.main = main;

src/compiler/utilities.ts

@@ -0,0 +1,42 @@
+=== tests/cases/conformance/controlFlow/assertionTypePredicates2.js ===
+/**
+ * @typedef {{ x: number }} A
+ */
+
+/**
+ * @typedef { A & { y: number } } B
+ */
+
+/**
+ * @param {A} a
+ * @returns { asserts a is B }
+ */
+const foo = (a) => {
+>foo : Symbol(foo, Decl(assertionTypePredicates2.js, 12, 5))
+>a : Symbol(a, Decl(assertionTypePredicates2.js, 12, 13))
+
+    if (/** @type { B } */ (a).y !== 0) throw TypeError();
+>(a).y : Symbol(y, Decl(assertionTypePredicates2.js, 5, 19))
+>a : Symbol(a, Decl(assertionTypePredicates2.js, 12, 13))
+>y : Symbol(y, Decl(assertionTypePredicates2.js, 5, 19))
+>TypeError : Symbol(TypeError, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+
+    return undefined;
+>undefined : Symbol(undefined)
+
+};
+
+export const main = () => {
+>main : Symbol(main, Decl(assertionTypePredicates2.js, 17, 12))
+
+    /** @type { A } */
+    const a = { x: 1 };
+>a : Symbol(a, Decl(assertionTypePredicates2.js, 19, 9))
+>x : Symbol(x, Decl(assertionTypePredicates2.js, 19, 15))
+
+    foo(a);
+>foo : Symbol(foo, Decl(assertionTypePredicates2.js, 12, 5))
+>a : Symbol(a, Decl(assertionTypePredicates2.js, 19, 9))
+
+};
+

tests/baselines/reference/assertionTypePredicates2.js

@@ -0,0 +1,51 @@
+=== tests/cases/conformance/controlFlow/assertionTypePredicates2.js ===
+/**
+ * @typedef {{ x: number }} A
+ */
+
+/**
+ * @typedef { A & { y: number } } B
+ */
+
+/**
+ * @param {A} a
+ * @returns { asserts a is B }
+ */
+const foo = (a) => {
+>foo : (a: A) => asserts a is B
+>(a) => {    if (/** @type { B } */ (a).y !== 0) throw TypeError();    return undefined;} : (a: A) => asserts a is B
+>a : A
+
+    if (/** @type { B } */ (a).y !== 0) throw TypeError();
+>(a).y !== 0 : boolean
+>(a).y : number
+>(a) : B
+>a : A
+>y : number
+>0 : 0
+>TypeError() : TypeError
+>TypeError : TypeErrorConstructor
+
+    return undefined;
+>undefined : undefined
+
+};
+
+export const main = () => {
+>main : () => void
+>() => {    /** @type { A } */    const a = { x: 1 };    foo(a);} : () => void
+
+    /** @type { A } */
+    const a = { x: 1 };
+>a : A
+>{ x: 1 } : { x: number; }
+>x : number
+>1 : 1
+
+    foo(a);
+>foo(a) : void
+>foo : (a: A) => asserts a is B
+>a : A
+
+};
+