esrap 2.2.5 → 2.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esrap",
-  "version": "2.2.5",
+  "version": "2.2.7",
   "description": "Parse in reverse",
   "repository": {
     "type": "git",

package/src/languages/ts/index.js

@@ -73,6 +73,118 @@ const OPERATOR_PRECEDENCE = {
 	'**': 13
 };
 
+/**
+ * Writes `keyword` bounded by source map locations for the exact character span,
+ * so breakpoints line up on keywords (not only identifiers and braces).
+ *
+ * @param {import('esrap').Context} context
+ * @param {number} line ESTree / acorn 1-based line
+ * @param {number} column 0-based ESTree column (UTF-16 indices, same as emitted JS)
+ * @param {string} keyword
+ */
+function write_source_keyword(context, line, column, keyword) {
+	context.location(line, column);
+	context.write(keyword);
+	context.location(line, column + keyword.length);
+}
+
+/**
+ * Sequential fragments from one ESTree `loc.start`, advancing columns for source mappings.
+ * Pass each printed fragment exactly (usually including trailing spaces), e.g. `declare `, `class `.
+ * Usage: `const kw = create_keyword_write(context, node, predicate);`
+ *
+ * @param {import('esrap').Context} context
+ * @param {TSESTree.Node} node
+ * @param {(n: any) => boolean} [map_ok] When false or missing `loc`, writes go through `context.write` only.
+ * @returns {(fragment: string) => void}
+ */
+function create_keyword_write(context, node, map_ok) {
+	let cursor =
+		node.loc && (!map_ok || map_ok(node))
+			? { line: node.loc.start.line, col: node.loc.start.column }
+			: null;
+
+	return (fragment) => {
+		if (cursor) {
+			write_source_keyword(context, cursor.line, cursor.col, fragment);
+			cursor.col += fragment.length;
+		} else {
+			context.write(fragment);
+		}
+	};
+}
+
+/**
+ * Map one keyword at `node.loc.start`, then append unmapped `suffix` (spaces, punctuation, etc.).
+ *
+ * @param {import('esrap').Context} context
+ * @param {TSESTree.Node} node
+ * @param {string} keyword
+ * @param {string} [suffix='']
+ */
+function write_keyword(context, node, keyword, suffix = '') {
+	if (node.loc) {
+		write_source_keyword(context, node.loc.start.line, node.loc.start.column, keyword);
+		context.write(suffix);
+	} else {
+		context.write(keyword + suffix);
+	}
+}
+
+/**
+ * `async function` offset heuristics assume the `function` token is on the same line as `async`
+ * and anchored with the function `id`/`body` ESTree locations.
+ *
+ * @param {TSESTree.FunctionDeclaration | TSESTree.FunctionExpression} node
+ */
+function function_async_function_offset_ok(node) {
+	const line = /** @type {{ loc?: { start: { line: number } } }} */ (node).loc?.start.line;
+	if (line === undefined) return false;
+
+	return node.id?.loc?.start.line === line || node.body?.loc?.start.line === line;
+}
+
+/** @param {{ loc?: { start: { line: number }, end: { line: number } } }} node */
+function single_line_node(node) {
+	return !!(node.loc && node.loc.start.line === node.loc.end.line);
+}
+
+/**
+ * @param {TSESTree.ClassDeclaration | TSESTree.ClassExpression} node
+ * @returns {boolean}
+ */
+function class_modifier_keywords_map_ok(node) {
+	return (
+		!!node.loc &&
+		!node.decorators?.length &&
+		(node.id
+			? node.id.loc?.start.line === node.loc.start.line
+			: node.body.loc.start.line === node.loc.start.line)
+	);
+}
+
+/**
+ * @param {TSESTree.MethodDefinition | TSESTree.TSAbstractMethodDefinition} node
+ * @returns {boolean}
+ */
+function method_modifiers_keywords_map_ok(node) {
+	return !!(
+		node.loc &&
+		!node.decorators?.length &&
+		node.loc.start.line === node.value.loc?.start.line
+	);
+}
+
+/**
+ * @param {TSESTree.PropertyDefinition | TSESTree.TSAbstractPropertyDefinition | TSESTree.AccessorProperty | TSESTree.TSAbstractAccessorProperty} node
+ * @returns {boolean}
+ */
+function field_modifiers_keywords_map_ok(node) {
+	if (!node.loc || node.decorators?.length) return false;
+	if (!node.value?.loc) return true;
+	return node.loc.start.line === node.value.loc.start.line;
+}
+
 /**
  * @param {BaseComment} comment
  * @param {Context} context
@@ -459,7 +571,7 @@ export default (options = {}) => {
 		 */
 		'CallExpression|NewExpression': (node, context) => {
 			if (node.type === 'NewExpression') {
-				context.write('new ');
+				write_keyword(context, node, 'new', ' ');
 			}
 
 			const needs_parens =
@@ -550,13 +662,11 @@ export default (options = {}) => {
 				}
 			}
 
-			if (node.declare) {
-				context.write('declare ');
-			}
-
-			if (node.abstract) context.write('abstract ');
+			const kw = create_keyword_write(context, node, class_modifier_keywords_map_ok);
 
-			context.write('class ');
+			if (node.declare) kw('declare ');
+			if (node.abstract) kw('abstract ');
+			kw('class ');
 
 			if (node.id) {
 				context.visit(node.id);
@@ -589,8 +699,14 @@ export default (options = {}) => {
 		 * @param {Context} context
 		 */
 		'ForInStatement|ForOfStatement': (node, context) => {
-			context.write('for ');
-			if (node.type === 'ForOfStatement' && node.await) context.write('await ');
+			const kw = create_keyword_write(context, node);
+
+			kw('for ');
+			if (node.type === 'ForOfStatement' && node.await) {
+				if (single_line_node(node)) kw('await ');
+				else context.write('await ');
+			}
+
 			context.write('(');
 
 			if (node.left.type === 'VariableDeclaration') {
@@ -610,8 +726,31 @@ export default (options = {}) => {
 		 * @param {Context} context
 		 */
 		'FunctionDeclaration|FunctionExpression': (node, context) => {
-			if (node.async) context.write('async ');
-			context.write(node.generator ? 'function* ' : 'function ');
+			if (!node.loc?.start) {
+				if (node.async) context.write('async ');
+				context.write(node.generator ? 'function* ' : 'function ');
+			} else {
+				const { line, column } = node.loc.start;
+
+				if (node.async) {
+					if (function_async_function_offset_ok(node)) {
+						write_source_keyword(context, line, column, 'async ');
+						const col2 = column + 'async '.length;
+						write_source_keyword(context, line, col2, 'function');
+						context.write(node.generator ? '* ' : ' ');
+					} else {
+						context.write('async ');
+						context.write(node.generator ? 'function* ' : 'function ');
+					}
+				} else if (node.generator) {
+					write_source_keyword(context, line, column, 'function');
+					context.write('* ');
+				} else {
+					write_source_keyword(context, line, column, 'function');
+					context.write(' ');
+				}
+			}
+
 			if (node.id) context.visit(node.id);
 
 			if (node.typeParameters) {
@@ -640,35 +779,34 @@ export default (options = {}) => {
 				}
 			}
 
+			const kw = create_keyword_write(context, node, method_modifiers_keywords_map_ok);
+
 			// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
 			if (node.abstract || node.type === 'TSAbstractMethodDefinition') {
-				context.write('abstract ');
+				kw('abstract ');
 			}
 
 			if (node.accessibility) {
-				context.write(node.accessibility + ' ');
+				kw(node.accessibility + ' ');
 			}
 
 			if (node.override) {
-				context.write('override ');
+				kw('override ');
 			}
 
 			if (node.static) {
-				context.write('static ');
+				kw('static ');
 			}
 
 			if (node.kind === 'get' || node.kind === 'set') {
-				// Getter or setter
-				context.write(node.kind + ' ');
+				kw(node.kind + ' ');
 			}
 
 			if (node.value.async) {
-				context.write('async ');
+				kw('async ');
 			}
 
-			if (node.value.generator) {
-				context.write('*');
-			}
+			if (node.value.generator) context.write('*');
 
 			if (node.computed) context.write('[');
 			context.visit(node.key);
@@ -704,8 +842,10 @@ export default (options = {}) => {
 				}
 			}
 
+			const kw = create_keyword_write(context, node, field_modifiers_keywords_map_ok);
+
 			if (node.accessibility) {
-				context.write(node.accessibility + ' ');
+				kw(node.accessibility + ' ');
 			}
 
 			if (
@@ -714,11 +854,11 @@ export default (options = {}) => {
 				node.type === 'TSAbstractPropertyDefinition' ||
 				node.type === 'TSAbstractAccessorProperty'
 			) {
-				context.write('abstract ');
+				kw('abstract ');
 			}
 
 			if (node.static) {
-				context.write('static ');
+				kw('static ');
 			}
 
 			if (
@@ -727,7 +867,7 @@ export default (options = {}) => {
 				node.type === 'AccessorProperty' ||
 				node.type === 'TSAbstractAccessorProperty'
 			) {
-				context.write('accessor ');
+				kw('accessor ');
 			}
 
 			if (node.computed) {
@@ -854,11 +994,21 @@ export default (options = {}) => {
 		ArrayPattern: shared['ArrayExpression|ArrayPattern'],
 
 		ArrowFunctionExpression: (node, context) => {
-			if (node.async) context.write('async ');
+			if (node.async) {
+				write_keyword(context, node, 'async', ' ');
+			}
+
+			if (node.typeParameters) {
+				context.visit(node.typeParameters);
+			}
 
 			context.write('(');
-			sequence(context, node.params, node.body.loc?.start ?? null, false);
-			context.write(') => ');
+			sequence(context, node.params, (node.returnType ?? node.body).loc?.start ?? null, false);
+			context.write(')');
+
+			if (node.returnType) context.visit(node.returnType);
+
+			context.write(' => ');
 
 			if (
 				node.body.type === 'ObjectExpression' ||
@@ -891,15 +1041,15 @@ export default (options = {}) => {
 				const precedence = EXPRESSIONS_PRECEDENCE[node.argument.type];
 
 				if (precedence && precedence < EXPRESSIONS_PRECEDENCE.AwaitExpression) {
-					context.write('await (');
+					write_keyword(context, node, 'await', ' (');
 					context.visit(node.argument);
 					context.write(')');
 				} else {
-					context.write('await ');
+					write_keyword(context, node, 'await', ' ');
 					context.visit(node.argument);
 				}
 			} else {
-				context.write('await');
+				write_keyword(context, node, 'await', '');
 			}
 		},
 
@@ -909,11 +1059,11 @@ export default (options = {}) => {
 
 		BreakStatement(node, context) {
 			if (node.label) {
-				context.write('break ');
+				write_keyword(context, node, 'break', ' ');
 				context.visit(node.label);
 				context.write(';');
 			} else {
-				context.write('break;');
+				write_keyword(context, node, 'break', ';');
 			}
 		},
 
@@ -969,11 +1119,11 @@ export default (options = {}) => {
 
 		ContinueStatement(node, context) {
 			if (node.label) {
-				context.write('continue ');
+				write_keyword(context, node, 'continue', ' ');
 				context.visit(node.label);
 				context.write(';');
 			} else {
-				context.write('continue;');
+				write_keyword(context, node, 'continue', ';');
 			}
 		},
 
@@ -989,9 +1139,19 @@ export default (options = {}) => {
 		},
 
 		DoWhileStatement(node, context) {
-			context.write('do ');
+			write_keyword(context, node, 'do', ' ');
 			context.visit(node.body);
-			context.write(' while (');
+
+			const test_loc = node.test.loc?.start;
+			const body_end = node.body.loc?.end;
+			if (test_loc && body_end && body_end.line === test_loc.line && test_loc.column >= 6) {
+				context.write(' ');
+				write_source_keyword(context, body_end.line, body_end.column + 1, 'while');
+				context.write(' (');
+			} else {
+				context.write(' while (');
+			}
+
 			context.visit(node.test);
 			context.write(');');
 		},
@@ -1014,7 +1174,9 @@ export default (options = {}) => {
 		},
 
 		ExportDefaultDeclaration(node, context) {
-			context.write('export default ');
+			const kw = create_keyword_write(context, node, single_line_node);
+			kw('export ');
+			kw('default ');
 
 			context.visit(node.declaration);
 
@@ -1031,23 +1193,25 @@ export default (options = {}) => {
 					for (const decorator of decl.decorators) {
 						context.visit(decorator);
 					}
-					context.write('export ');
+					write_keyword(context, node, 'export', ' ');
 					// Temporarily remove decorators so ClassDeclaration doesn't print them again
 					const savedDecorators = decl.decorators;
 					decl.decorators = [];
 					context.visit(node.declaration);
 					decl.decorators = savedDecorators;
 				} else {
-					context.write('export ');
+					write_keyword(context, node, 'export', ' ');
 					context.visit(node.declaration);
 				}
 				return;
 			}
 
-			context.write('export ');
+			const kw = create_keyword_write(context, node);
 
+			kw('export ');
 			if (node.exportKind === 'type') {
-				context.write('type ');
+				if (single_line_node(node)) kw('type ');
+				else context.write('type ');
 			}
 
 			context.write('{');
@@ -1098,7 +1262,7 @@ export default (options = {}) => {
 		},
 
 		ForStatement: (node, context) => {
-			context.write('for (');
+			write_keyword(context, node, 'for', ' (');
 
 			if (node.init) {
 				if (node.init.type === 'VariableDeclaration') {
@@ -1133,21 +1297,30 @@ export default (options = {}) => {
 		},
 
 		IfStatement(node, context) {
-			context.write('if (');
+			write_keyword(context, node, 'if', ' (');
 			context.visit(node.test);
 			context.write(') ');
 			context.visit(node.consequent);
 
 			if (node.alternate) {
 				context.space();
-				context.write('else ');
+
+				const alt_loc = node.alternate.loc?.start;
+				const con_end = node.consequent.loc?.end;
+				if (alt_loc && con_end && con_end.line === alt_loc.line && alt_loc.column >= 4) {
+					write_source_keyword(context, con_end.line, con_end.column + 1, 'else');
+					context.write(' ');
+				} else {
+					context.write('else ');
+				}
+
 				context.visit(node.alternate);
 			}
 		},
 
 		ImportDeclaration(node, context) {
 			if (node.specifiers.length === 0) {
-				context.write('import ');
+				write_keyword(context, node, 'import', ' ');
 				context.visit(node.source);
 				context.write(';');
 				return;
@@ -1172,8 +1345,13 @@ export default (options = {}) => {
 				}
 			}
 
-			context.write('import ');
-			if (node.importKind == 'type') context.write('type ');
+			const kw = create_keyword_write(context, node);
+
+			kw('import ');
+			if (node.importKind == 'type') {
+				if (single_line_node(node)) kw('type ');
+				else context.write('type ');
+			}
 
 			if (default_specifier) {
 				context.write(default_specifier.local.name, default_specifier);
@@ -1209,7 +1387,7 @@ export default (options = {}) => {
 		},
 
 		ImportExpression(node, context) {
-			context.write('import(');
+			write_keyword(context, node, 'import', '(');
 			context.visit(node.source);
 			//@ts-expect-error for some reason the types haven't been updated
 			if (node.arguments) {
@@ -1339,8 +1517,10 @@ export default (options = {}) => {
 
 			// shorthand methods
 			if (node.value.type === 'FunctionExpression') {
-				if (node.kind !== 'init') context.write(node.kind + ' ');
-				if (node.value.async) context.write('async ');
+				const kw = create_keyword_write(context, node);
+
+				if (node.kind !== 'init') kw(node.kind + ' ');
+				if (node.value.async) kw('async ');
 				if (node.value.generator) context.write('*');
 				if (node.computed) context.write('[');
 				context.visit(node.key);
@@ -1360,7 +1540,9 @@ export default (options = {}) => {
 				context.visit(node.value.body);
 			} else {
 				if (node.computed) context.write('[');
-				if (node.kind === 'get' || node.kind === 'set') context.write(node.kind + ' ');
+				if (node.kind === 'get' || node.kind === 'set') {
+					write_keyword(context, node, node.kind, ' ');
+				}
 				context.visit(node.key);
 				context.write(node.computed ? ']: ' : ': ');
 				context.visit(node.value);
@@ -1382,11 +1564,11 @@ export default (options = {}) => {
 					node.argument.loc &&
 					before(comments[comment_index].loc.start, node.argument.loc.start);
 
-				context.write(contains_comment ? 'return (' : 'return ');
+				write_keyword(context, node, 'return', contains_comment ? ' (' : ' ');
 				context.visit(node.argument);
 				context.write(contains_comment ? ');' : ';');
 			} else {
-				context.write('return;');
+				write_keyword(context, node, 'return', ';');
 			}
 		},
 
@@ -1399,7 +1581,7 @@ export default (options = {}) => {
 		SpreadElement: shared['RestElement|SpreadElement'],
 
 		StaticBlock(node, context) {
-			context.write('static {');
+			write_keyword(context, node, 'static', ' {');
 			context.indent();
 			context.newline();
 
@@ -1415,7 +1597,7 @@ export default (options = {}) => {
 		},
 
 		SwitchStatement(node, context) {
-			context.write('switch (');
+			write_keyword(context, node, 'switch', ' (');
 			context.visit(node.discriminant);
 			context.write(') {');
 			context.indent();
@@ -1431,12 +1613,12 @@ export default (options = {}) => {
 
 				if (block.test) {
 					context.newline();
-					context.write('case ');
+					write_keyword(context, block, 'case', ' ');
 					context.visit(block.test);
 					context.write(':');
 				} else {
 					context.newline();
-					context.write('default:');
+					write_keyword(context, block, 'default', ':');
 				}
 
 				context.indent();
@@ -1485,29 +1667,40 @@ export default (options = {}) => {
 		},
 
 		ThrowStatement(node, context) {
-			context.write('throw ');
+			write_keyword(context, node, 'throw', ' ');
 			if (node.argument) context.visit(node.argument);
 			context.write(';');
 		},
 
 		TryStatement(node, context) {
-			context.write('try ');
+			write_keyword(context, node, 'try', ' ');
 			context.visit(node.block);
 
 			if (node.handler) {
+				context.write(' ');
+
 				if (node.handler.param) {
-					context.write(' catch(');
+					write_keyword(context, node.handler, 'catch', '(');
 					context.visit(node.handler.param);
 					context.write(') ');
 				} else {
-					context.write(' catch ');
+					write_keyword(context, node.handler, 'catch', ' ');
 				}
 
 				context.visit(node.handler.body);
 			}
 
 			if (node.finalizer) {
-				context.write(' finally ');
+				const fin_loc = node.finalizer.loc?.start;
+				const prev_end = node.handler ? node.handler.loc?.end : node.block.loc?.end;
+				if (fin_loc && prev_end && prev_end.line === fin_loc.line && fin_loc.column >= 7) {
+					context.write(' ');
+					write_source_keyword(context, prev_end.line, prev_end.column + 1, 'finally');
+					context.write(' ');
+				} else {
+					context.write(' finally ');
+				}
+
 				context.visit(node.finalizer);
 			}
 		},
@@ -1553,25 +1746,27 @@ export default (options = {}) => {
 		},
 
 		WhileStatement(node, context) {
-			context.write('while (');
+			write_keyword(context, node, 'while', ' (');
 			context.visit(node.test);
 			context.write(') ');
 			context.visit(node.body);
 		},
 
 		WithStatement(node, context) {
-			context.write('with (');
+			write_keyword(context, node, 'with', ' (');
 			context.visit(node.object);
 			context.write(') ');
 			context.visit(node.body);
 		},
 
 		YieldExpression(node, context) {
+			const word = node.delegate ? 'yield*' : 'yield';
+
 			if (node.argument) {
-				context.write(node.delegate ? `yield* ` : `yield `);
+				write_keyword(context, node, word, ' ');
 				context.visit(node.argument);
 			} else {
-				context.write(node.delegate ? `yield*` : `yield`);
+				write_keyword(context, node, word, '');
 			}
 		},
 
@@ -1588,13 +1783,15 @@ export default (options = {}) => {
 			],
 
 		TSDeclareFunction(node, context) {
-			context.write('declare ');
+			const kw = create_keyword_write(context, node);
+
+			kw('declare ');
 
 			if (node.async) {
-				context.write('async ');
+				kw('async ');
 			}
 
-			context.write('function');
+			kw('function');
 
 			if (node.generator) {
 				context.write('*');
@@ -1793,6 +1990,11 @@ export default (options = {}) => {
 				context.write(' extends ');
 				context.visit(node.constraint);
 			}
+
+			if (node.default) {
+				context.write(' = ');
+				context.visit(node.default);
+			}
 		},
 
 		TSTypePredicate(node, context) {
@@ -1848,19 +2050,28 @@ export default (options = {}) => {
 		TSMappedType(node, context) {
 			context.write('{[');
 
-			if (node.typeParameter) {
-				context.visit(node.typeParameter);
+			const legacy_type_parameter = node.typeParameter;
+			const key = node.key ?? legacy_type_parameter?.name;
+			const constraint = node.constraint ?? legacy_type_parameter?.constraint;
+
+			if (key && typeof key === 'object') {
+				context.visit(key);
 			} else {
-				context.visit(node.key);
+				context.write(key, node);
+			}
+
+			if (constraint) {
 				context.write(' in ');
-				context.visit(node.constraint);
+				context.visit(constraint);
 			}
 
 			context.write(']');
+
 			if (node.typeAnnotation) {
 				context.write(': ');
 				context.visit(node.typeAnnotation);
 			}
+
 			context.write('}');
 		},
 
@@ -2019,9 +2230,15 @@ export default (options = {}) => {
 
 		TSModuleDeclaration(node, context) {
 			if (node.declare) context.write('declare ');
-			else context.write('namespace ');
 
-			context.visit(node.id);
+			if (node.global) {
+				context.write('global', node.id);
+			} else {
+				// @ts-expect-error `acorn-typescript` and `@typescript-eslint/types` have slightly different type definitions
+				const kind = node.kind ?? (node.id.type === 'Literal' ? 'module' : 'namespace');
+				context.write(kind + ' ');
+				context.visit(node.id);
+			}
 
 			if (!node.body) return;
 			context.visit(node.body);
@@ -2187,11 +2404,11 @@ function handle_var_declaration(node, context) {
 
 	context.append(child_context);
 
-	if (node.declare) {
-		child_context.write('declare ');
-	}
+	const kw = create_keyword_write(child_context, node);
+
+	if (node.declare) kw('declare ');
+	kw(node.kind + ' ');
 
-	child_context.write(`${node.kind} `);
 	child_context.append(open);
 
 	let first = true;