Introduce parser concepts for import.meta.resolve(…).

.temp/.gitignore

@@ -0,0 +1 @@
+*.js

.temp/test/README.md

@@ -0,0 +1,6 @@
+This is a temporary example test. Run using:
+
+```shell
+hereby local
+node ./built/local/tsc.js --project ".temp/test/tsconfig.json"
+```

.temp/test/main.ts

@@ -0,0 +1,3 @@
+const entry = import.meta.resolve("./worker")
+const worker = new Worker(entry, {type: "module"});
+worker.addEventListener("message", console.log);

.temp/test/plus.ts

@@ -0,0 +1,4 @@
+export function plus(a: number, b: number): number {
+  console.log(import.meta)
+  return a + b;
+}

.temp/test/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "es2022",
+    "moduleResolution": "bundler"
+  },
+  "files": ["./main.ts", "./worker.ts"]
+}

.temp/test/worker.ts

@@ -0,0 +1,7 @@
+(async () => { 
+  postMessage({
+    "hi": "world",
+    "import.meta.url": import.meta.url,
+    "sum": (await import("./plus")).plus(2, 3)
+  })
+})()

src/compiler/parser.ts

@@ -5918,11 +5918,40 @@ namespace Parser {
                 expression = parseTokenNode<PrimaryExpression>();
             }
             else if (lookAhead(nextTokenIsDot)) {
-                // This is an 'import.*' metaproperty (i.e. 'import.meta')
+                // This is either specificallly an `import.meta.resolve(…)` call or more generally an 'import.*' metaproperty (i.e. 'import.meta')
                 nextToken(); // advance past the 'import'
                 nextToken(); // advance past the dot
-                expression = finishNode(factory.createMetaProperty(SyntaxKind.ImportKeyword, parseIdentifierName()), pos);
-                sourceFlags |= NodeFlags.PossiblyContainsImportMeta;
+                const identifierName = parseIdentifierName();
+
+                // TODO: use `parseRightSideOfDot`?
+                const foundImportMetaResolve = tryParse(() => {
+                    // `meta` and `resolve` are not JavaScript keywords, so we attempt to look for the direct string identifiers to recognizer `import.meta.resolve(…)`.
+                    if (identifierName.escapedText === "meta") {
+                        if (token() === SyntaxKind.DotToken) {
+                            nextToken(); // advance past the dot
+                            const nextIdentifierName = lookAhead(parseIdentifierName);
+                            if (nextIdentifierName.escapedText === "resolve") {
+                                if (lookAhead(() => nextToken() === SyntaxKind.OpenParenToken)) {
+                                    return true;
+                                }
+                            }
+                        }
+
+                    }
+                    return false;
+                });
+
+                if (foundImportMetaResolve) {
+                    sourceFlags |= NodeFlags.PossiblyContainsDynamicImport;
+
+                    expression = {} as any; // TODO: calculate the expression. Here are some failed attempts:
+                    // expression = finishNode(factoryCreateCallExpression(factoryCreateExpressionStatement(), undefined, parseArgumentList()), pos) as any;
+                    // expression = parseTokenNode<PrimaryExpression>();
+                    // expression = finishNode(factoryCreateToken(SyntaxKind.ImportMetaResolveExpression), getNodePos()) as PrimaryExpression;
+                } else {
+                    expression = finishNode(factory.createMetaProperty(SyntaxKind.ImportKeyword, identifierName), pos);
+                    sourceFlags |= NodeFlags.PossiblyContainsImportMeta;
+                }
             }
             else {
                 expression = parseMemberExpressionOrHigher();
@@ -5935,7 +5964,8 @@ namespace Parser {
         // Now, we *may* be complete.  However, we might have consumed the start of a
         // CallExpression or OptionalExpression.  As such, we need to consume the rest
         // of it here to be complete.
-        return parseCallExpressionRest(pos, expression);
+        const rest = parseCallExpressionRest(pos, expression);
+        return rest;
     }
 
     function parseMemberExpressionOrHigher(): MemberExpression {

src/compiler/program.ts

@@ -197,6 +197,7 @@ import {
     isImportCall,
     isImportDeclaration,
     isImportEqualsDeclaration,
+    isImportMetaResolveCall,
     isImportSpecifier,
     isImportTypeNode,
     isInJSFile,
@@ -3482,7 +3483,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         }
 
         if ((file.flags & NodeFlags.PossiblyContainsDynamicImport) || isJavaScriptFile) {
-            collectDynamicImportOrRequireOrJsDocImportCalls(file);
+            collectDynamicImportOrSimilarCalls(file);
         }
 
         file.imports = imports || emptyArray;
@@ -3546,7 +3547,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             }
         }
 
-        function collectDynamicImportOrRequireOrJsDocImportCalls(file: SourceFile) {
+        function collectDynamicImportOrSimilarCalls(file: SourceFile) {
             const r = /import|require/g;
             while (r.exec(file.text) !== null) { // eslint-disable-line no-restricted-syntax
                 const node = getNodeAtPosition(file, r.lastIndex);
@@ -3555,7 +3556,8 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
                     imports = append(imports, node.arguments[0]);
                 }
                 // we have to check the argument list has length of at least 1. We will still have to process these even though we have parsing error.
-                else if (isImportCall(node) && node.arguments.length >= 1 && isStringLiteralLike(node.arguments[0])) {
+                else if ((isImportCall(node) || isImportMetaResolveCall(node)) && node.arguments.length >= 1 && isStringLiteralLike(node.arguments[0])) {
+                    console.log("isImportMetaResolveCall mbyybyey", node)
                     setParentRecursive(node, /*incremental*/ false); // we need parent data on imports before the program is fully bound, so we ensure it's set here
                     imports = append(imports, node.arguments[0]);
                 }

src/compiler/types.ts

@@ -302,6 +302,7 @@ export const enum SyntaxKind {
     AsExpression,
     NonNullExpression,
     MetaProperty,
+    ImportMetaResolveExpression,
     SyntheticExpression,
     SatisfiesExpression,
 
@@ -2479,6 +2480,10 @@ export interface ImportExpression extends PrimaryExpression {
     readonly kind: SyntaxKind.ImportKeyword;
 }
 
+export interface ImportMetaResolveExpression extends PrimaryExpression {
+    readonly kind: SyntaxKind.ImportMetaResolveExpression;
+}
+
 export interface DeleteExpression extends UnaryExpression {
     readonly kind: SyntaxKind.DeleteExpression;
     readonly expression: UnaryExpression;
@@ -3097,6 +3102,10 @@ export interface ImportCall extends CallExpression {
     readonly expression: ImportExpression;
 }
 
+export interface ImportMetaResolveCall extends CallExpression {
+    readonly expression: ImportMetaResolveExpression;
+}
+
 export interface ExpressionWithTypeArguments extends MemberExpression, NodeWithTypeArguments {
     readonly kind: SyntaxKind.ExpressionWithTypeArguments;
     readonly expression: LeftHandSideExpression;

src/compiler/utilities.ts

@@ -233,6 +233,7 @@ import {
     ImportDeclaration,
     ImportEqualsDeclaration,
     ImportMetaProperty,
+    ImportMetaResolveCall,
     ImportSpecifier,
     ImportTypeNode,
     IndexInfo,
@@ -2559,6 +2560,12 @@ export function isImportCall(n: Node): n is ImportCall {
     return n.kind === SyntaxKind.CallExpression && (n as CallExpression).expression.kind === SyntaxKind.ImportKeyword;
 }
 
+
+/** @internal */
+export function isImportMetaResolveCall(n: Node): n is ImportMetaResolveCall {
+    return n.kind === SyntaxKind.CallExpression && (n as CallExpression).expression.kind === SyntaxKind.ImportMetaResolveExpression;
+}
+
 /** @internal */
 export function isImportMeta(n: Node): n is ImportMetaProperty {
     return isMetaProperty(n)