@openrewrite/rewrite 8.69.0 → 8.69.1

package/dist/javascript/parser.js

@@ -32,6 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -75,34 +84,33 @@ const uuid_1 = require("../uuid");
 const parser_utils_1 = require("./parser-utils");
 const type_mapping_1 = require("./type-mapping");
 const immer_1 = require("immer");
+const prettier_config_loader_1 = require("./format/prettier-config-loader");
 var Kind = _1.JS.Kind;
 function getScriptKindFromFileName(fileName) {
-    const ext = fileName.toLowerCase();
-    if (ext.endsWith('.tsx'))
-        return typescript_1.default.ScriptKind.TSX;
-    if (ext.endsWith('.jsx'))
-        return typescript_1.default.ScriptKind.JSX;
-    if (ext.endsWith('.ts'))
-        return typescript_1.default.ScriptKind.TS;
-    if (ext.endsWith('.js'))
-        return typescript_1.default.ScriptKind.JS;
-    if (ext.endsWith('.mjs'))
-        return typescript_1.default.ScriptKind.JS;
-    if (ext.endsWith('.cjs'))
-        return typescript_1.default.ScriptKind.JS;
-    if (ext.endsWith('.mts'))
+    const dotIndex = fileName.lastIndexOf('.');
+    if (dotIndex === -1)
         return typescript_1.default.ScriptKind.TS;
-    if (ext.endsWith('.cts'))
-        return typescript_1.default.ScriptKind.TS;
-    return typescript_1.default.ScriptKind.TS;
+    const ext = fileName.slice(dotIndex);
+    switch (ext) {
+        case '.tsx': return typescript_1.default.ScriptKind.TSX;
+        case '.jsx': return typescript_1.default.ScriptKind.JSX;
+        case '.ts':
+        case '.mts':
+        case '.cts': return typescript_1.default.ScriptKind.TS;
+        case '.js':
+        case '.mjs':
+        case '.cjs': return typescript_1.default.ScriptKind.JS;
+        default: return typescript_1.default.ScriptKind.TS;
+    }
 }
 class JavaScriptParser extends parser_1.Parser {
-    constructor({ ctx, relativeTo, styles, sourceFileCache } = {}) {
+    constructor({ ctx, relativeTo, styles, sourceFileCache, } = {}) {
         super({ ctx, relativeTo });
         this.compilerOptions = {
             target: typescript_1.default.ScriptTarget.Latest,
             module: typescript_1.default.ModuleKind.CommonJS,
             moduleResolution: typescript_1.default.ModuleResolutionKind.Node10,
+            noEmit: true,
             allowJs: true,
             checkJs: true,
             esModuleInterop: true,
@@ -116,6 +124,66 @@ class JavaScriptParser extends parser_1.Parser {
         this.styles = styles;
         this.sourceFileCache = sourceFileCache;
     }
+    /**
+     * Parses a single source file using only ts.createSourceFile(), bypassing
+     * the TypeScript type checker entirely. This is significantly faster than
+     * the full parse() method when type information is not needed.
+     *
+     * Use this method for formatting-only operations where AST structure is
+     * needed but type attribution is not required.
+     *
+     * @param input The parser input containing the source code
+     * @returns The parsed SourceFile, or a ParseExceptionResult if parsing failed
+     */
+    parseOnly(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = (0, parser_1.parserInputFile)(input);
+            const sourcePath = this.relativeTo && !path.isAbsolute(filePath)
+                ? path.join(this.relativeTo, filePath)
+                : filePath;
+            const sourceText = (0, parser_1.parserInputRead)(input);
+            const scriptKind = getScriptKindFromFileName(sourcePath);
+            // Create source file directly without a Program
+            const sourceFileOptions = {
+                languageVersion: typescript_1.default.ScriptTarget.Latest,
+                jsDocParsingMode: typescript_1.default.JSDocParsingMode.ParseNone
+            };
+            const tsSourceFile = typescript_1.default.createSourceFile(sourcePath, sourceText, sourceFileOptions, true, // setParentNodes
+            scriptKind);
+            // Check for parse-time syntax errors (accessible via internal parseDiagnostics)
+            // TypeScript stores parse errors directly on the source file
+            const parseDiagnostics = tsSourceFile.parseDiagnostics;
+            if (parseDiagnostics && parseDiagnostics.length > 0) {
+                const errors = parseDiagnostics.filter(d => d.category === typescript_1.default.DiagnosticCategory.Error);
+                if (errors.length > 0) {
+                    const errorMessages = errors.map(e => {
+                        if (e.file && e.start !== undefined) {
+                            const { line, character } = typescript_1.default.getLineAndCharacterOfPosition(e.file, e.start);
+                            const message = typescript_1.default.flattenDiagnosticMessageText(e.messageText, "\n");
+                            return `(${line + 1},${character + 1}): ${message} [${e.code}]`;
+                        }
+                        return `${typescript_1.default.flattenDiagnosticMessageText(e.messageText, "\n")} [${e.code}]`;
+                    }).join('; ');
+                    return this.error(input, new SyntaxError(`Compiler error(s): ${errorMessages}`));
+                }
+            }
+            try {
+                // Parse without type mapping (no type checker available)
+                const result = new JavaScriptParserVisitor(tsSourceFile, this.relativePath(input), undefined)
+                    .visit(tsSourceFile);
+                if (this.styles) {
+                    const styles = this.styles;
+                    return (0, immer_1.produce)(result, draft => {
+                        draft.markers.markers = draft.markers.markers.concat(styles);
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                return this.error(input, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error));
+            }
+        });
+    }
     // noinspection JSUnusedGlobalSymbols
     reset() {
         this.sourceFileCache && this.sourceFileCache.clear();
@@ -239,10 +307,15 @@ class JavaScriptParser extends parser_1.Parser {
             const program = typescript_1.default.createProgram([...inputFiles.keys()], this.compilerOptions, host, this.oldProgram);
             // Update the oldProgram reference
             this.oldProgram = program;
-            const typeChecker = program.getTypeChecker();
+            // Detect Prettier config for the project
+            const prettierLoader = this.relativeTo ? new prettier_config_loader_1.PrettierConfigLoader(this.relativeTo) : undefined;
+            if (prettierLoader) {
+                yield __await(prettierLoader.detectPrettier());
+            }
             // Create a single JavaScriptTypeMapping instance to be shared across all files in this parse batch.
             // This ensures that TypeScript types with the same type.id map to the same Type instance,
             // preventing duplicate Type.Class, Type.Parameterized, etc. instances.
+            const typeChecker = program.getTypeChecker();
             const typeMapping = new type_mapping_1.JavaScriptTypeMapping(typeChecker);
             for (const input of inputFiles.values()) {
                 const filePath = (0, parser_1.parserInputFile)(input);
@@ -262,11 +335,16 @@ class JavaScriptParser extends parser_1.Parser {
                     continue;
                 }
                 try {
+                    // Get Prettier config marker for this file (if Prettier is available)
+                    const prettierConfigMarker = yield __await((prettierLoader === null || prettierLoader === void 0 ? void 0 : prettierLoader.getConfigMarker(filePath)));
                     yield yield __await((0, immer_1.produce)(new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeMapping)
                         .visit(sourceFile), draft => {
                         if (this.styles) {
                             draft.markers.markers = draft.markers.markers.concat(this.styles);
                         }
+                        if (prettierConfigMarker) {
+                            draft.markers.markers = draft.markers.markers.concat([prettierConfigMarker]);
+                        }
                     }));
                 }
                 catch (error) {
@@ -415,6 +493,7 @@ class JavaScriptParserVisitor {
                 draft.comments = [];
             });
         }
+        const eof = this.prefix(node.endOfFileToken);
         let statements = this.semicolonPaddedStatementList(node.statements);
         // If there's trailing whitespace/comments after the shebang, prepend to first statement's prefix
         if (shebangTrailingSpace && statements.length > 0) {
@@ -442,7 +521,7 @@ class JavaScriptParserVisitor {
             statements: shebangStatement
                 ? [shebangStatement, ...statements]
                 : statements,
-            eof: this.prefix(node.endOfFileToken)
+            eof
         };
     }
     semicolonPaddedStatementList(statements) {
@@ -3869,16 +3948,20 @@ class JavaScriptParserVisitor {
         return prefixFromNode(node, this.sourceFile);
     }
     mapType(node) {
-        return this.typeMapping.type(node);
+        var _a;
+        return (_a = this.typeMapping) === null || _a === void 0 ? void 0 : _a.type(node);
     }
     mapPrimitiveType(node) {
-        return this.typeMapping.primitiveType(node);
+        var _a, _b;
+        return (_b = (_a = this.typeMapping) === null || _a === void 0 ? void 0 : _a.primitiveType(node)) !== null && _b !== void 0 ? _b : java_1.Type.Primitive.None;
     }
     mapVariableType(node) {
-        return this.typeMapping.variableType(node);
+        var _a;
+        return (_a = this.typeMapping) === null || _a === void 0 ? void 0 : _a.variableType(node);
     }
     mapMethodType(node) {
-        return this.typeMapping.methodType(node);
+        var _a;
+        return (_a = this.typeMapping) === null || _a === void 0 ? void 0 : _a.methodType(node);
     }
     mapCommaSeparatedList(nodes) {
         return this.mapToContainer(nodes, this.trailingComma(nodes));