@gi-tcg/gts-transpiler 0.6.2 → 0.6.3

package/dist/index.js

@@ -70,7 +70,7 @@ function loosePlugin() {
 				if (this.type.label === "name" || this.type.keyword) return super.parseIdent(liberal);
 				else return this.createDummyIdentifier();
 			};
-			#proxiedThis = new Proxy(this, { get: (target, prop) => {
+			#proxiedThisTrapParseIdent = new Proxy(this, { get: (target, prop) => {
 				if (prop === "parseIdent") return this._patchedParseIdent;
 				const value = Reflect.get(target, prop);
 				if (typeof value === "function") return value.bind(target);
@@ -83,7 +83,38 @@ function loosePlugin() {
 				return this.finishNode(dummy, "Identifier");
 			}
 			parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
-				return super.parseSubscript.call(this.#proxiedThis, base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+				return super.parseSubscript.call(this.#proxiedThisTrapParseIdent, base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+			}
+			#proxiedThisTrapEofToRbrace = new Proxy(this, { get: (target, prop) => {
+				if (prop === "type" && target.type === tokTypes.eof) return tokTypes.braceR;
+				const value = Reflect.get(target, prop);
+				if (typeof value === "function") return value.bind(target);
+				return value;
+			} });
+			parseBlock(createNewLexicalScope, node, exitStrict) {
+				return super.parseBlock.call(this.#proxiedThisTrapEofToRbrace, createNewLexicalScope, node, exitStrict);
+			}
+			parseClassStaticBlock(node) {
+				return super.parseClassStaticBlock.call(this.#proxiedThisTrapEofToRbrace, node);
+			}
+			parseSwitchStatement(node) {
+				return super.parseSwitchStatement.call(this.#proxiedThisTrapEofToRbrace, node);
+			}
+			parseStatement(context, topLevel, exports) {
+				const { start, startLoc, lastTokEnd, lastTokEndLoc } = this;
+				if (topLevel && this.eat(tokTypes.braceR)) {
+					const errorNode = this.startNodeAt(start, startLoc);
+					errorNode.error = "Unexpected token }";
+					return this.finishNode(errorNode, "ErrorStatement");
+				}
+				try {
+					return super.parseStatement(context, topLevel, exports);
+				} catch (e) {
+					const errorNode = this.startNodeAt(lastTokEnd, lastTokEndLoc);
+					errorNode.error = e?.message;
+					while (this.type !== tokTypes.eof && this.type !== tokTypes.semi && this.type !== tokTypes.braceR) this.next();
+					return this.finishNode(errorNode, "ErrorStatement");
+				}
 			}
 		};
 	};
@@ -537,6 +568,11 @@ function parseLoose(input, options) {
 		const ast = GtsParser.parse(input, {
 			ecmaVersion: "latest",
 			sourceType: "module",
+			allowImportExportEverywhere: true,
+			allowReturnOutsideFunction: true,
+			allowAwaitOutsideFunction: true,
+			allowSuperOutsideMethod: true,
+			checkPrivateFields: false,
 			locations: true,
 			ranges: true,
 			onComment
@@ -1659,6 +1695,7 @@ function getPrintOptions(source, state) {
 		source,
 		isUntouched: (node) => {
 			if (node.type === "Identifier" && node.isDummy) return false;
+			if (node.type === "ErrorStatement") return false;
 			if (state.attributeNameNodes.has(node)) return false;
 			return state.sourceNodes.has(node);
 		},
@@ -1689,8 +1726,17 @@ function getPrintOptions(source, state) {
 				if (identifier.isDummy && identifier.range) {
 					const text = state.lastArgNodes.has(identifier) ? "," : "";
 					let firstNonWhiteSpaceIndex = context.source.slice(identifier.range[1]).search(/\S/);
-					const rangeEnd = firstNonWhiteSpaceIndex === -1 ? context.source.length : identifier.range[1] + firstNonWhiteSpaceIndex;
-					context.writeMapped(text, identifier.range[0], rangeEnd);
+					if (firstNonWhiteSpaceIndex !== 0) {
+						const rangeEnd = firstNonWhiteSpaceIndex === -1 ? context.source.length : identifier.range[1] + firstNonWhiteSpaceIndex;
+						context.writeMapped(text, identifier.range[0], rangeEnd);
+					} else {
+						const rangeEnd = Math.min(node.range[0] + 1, context.source.length);
+						context.createExtraMapping({
+							start: identifier.range[0],
+							end: rangeEnd
+						}, context.generatedOffset, context.generatedOffset + 1, DEFAULT_VOLAR_MAPPING_DATA);
+						context.write(text);
+					}
 				} else if (identifier.range && state.attributeNameNodes.has(identifier)) context.writeMapped(identifier.name, identifier.range[0], identifier.range[1], ATTRIBUTE_NAME_MAPPING_DATA);
 				else defaultPrinters.Identifier(node, context);
 			},
@@ -1740,6 +1786,16 @@ function getPrintOptions(source, state) {
 				context.write(".");
 				context.writeSource(node.whiteSpaceStart, node.whiteSpaceEnd);
 				context.write(";");
+			},
+			ErrorStatement(node, context) {
+				if (node.range) {
+					context.writePreservedNode(node);
+					const rangeEnd = Math.min(node.range[1] + 1, context.source.length);
+					context.createExtraMapping({
+						start: node.range[1],
+						end: rangeEnd
+					}, context.generatedOffset, context.generatedOffset + 1, VERIFICATION_ONLY_MAPPING_DATA);
+				} else context.write(`((_: never) => 0)(${JSON.stringify(node.error ?? "Unknown error")});`);
 			}
 		},
 		experimentalGetLeftParenSourceRange: (node) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"

package/src/parse/index.ts

@@ -59,6 +59,11 @@ export function parseLoose(
     const ast = GtsParser.parse(input, {
       ecmaVersion: "latest",
       sourceType: "module",
+      allowImportExportEverywhere: true,
+      allowReturnOutsideFunction: true,
+      allowAwaitOutsideFunction: true,
+      allowSuperOutsideMethod: true,
+      checkPrivateFields: false,
       locations: true,
       ranges: true,
       onComment,

package/src/parse/loose_plugin.ts

@@ -15,7 +15,7 @@ export function loosePlugin() {
           return this.createDummyIdentifier();
         }
       };
-      readonly #proxiedThis = new Proxy(this, {
+      readonly #proxiedThisTrapParseIdent = new Proxy(this, {
         get: (target, prop) => {
           if (prop === "parseIdent") {
             return this._patchedParseIdent;
@@ -48,7 +48,7 @@ export function loosePlugin() {
         forInit?: boolean | "await",
       ): AST.Expression {
         return super.parseSubscript.call(
-          this.#proxiedThis,
+          this.#proxiedThisTrapParseIdent,
           base,
           startPos,
           startLoc,
@@ -58,6 +58,80 @@ export function loosePlugin() {
           forInit,
         );
       }
+
+      // Parsing block statements typically has:
+      // ```js
+      // while (this.type !== tokTypes.braceR) {
+      //   this.parseStatement();
+      // }
+      // ```
+      // But what happens if the next token is EOF? Since we tolerate errors inside `parseStatement`,
+      // it can fall into an infinite loop. To avoid this, we use a proxy to trap `this.type`
+      // access and return a fake `braceR` when the current token is EOF.
+      readonly #proxiedThisTrapEofToRbrace = new Proxy(this, {
+        get: (target, prop) => {
+          if (prop === "type" && target.type === tokTypes.eof) {
+            return tokTypes.braceR;
+          }
+          const value = Reflect.get(target, prop);
+          if (typeof value === "function") {
+            return value.bind(target);
+          }
+          return value;
+        },
+      });
+
+      override parseBlock(
+        createNewLexicalScope?: boolean,
+        node?: AST.BlockStatement,
+        exitStrict?: boolean,
+      ): AST.BlockStatement {
+        return super.parseBlock.call(
+          this.#proxiedThisTrapEofToRbrace,
+          createNewLexicalScope,
+          node,
+          exitStrict,
+        );
+      }
+      override parseClassStaticBlock(node: AST.Node): AST.StaticBlock {
+        return super.parseClassStaticBlock.call(
+          this.#proxiedThisTrapEofToRbrace,
+          node,
+        );
+      }
+      override parseSwitchStatement(node: AST.Node): AST.SwitchStatement {
+        return super.parseSwitchStatement.call(
+          this.#proxiedThisTrapEofToRbrace,
+          node,
+        );
+      }
+
+      override parseStatement(
+        context?: string | null,
+        topLevel?: boolean,
+        exports?: AST.ExportSpecifier,
+      ): AST.ExpressionStatement | AST.Statement | AST.GTSDefineStatement {
+        const { start, startLoc, lastTokEnd, lastTokEndLoc } = this;
+        if (topLevel && this.eat(tokTypes.braceR)) {
+          const errorNode: any = this.startNodeAt(start, startLoc);
+          errorNode.error = "Unexpected token }";
+          return this.finishNode(errorNode, "ErrorStatement");
+        }
+        try {
+          return super.parseStatement(context, topLevel, exports);
+        } catch (e) {
+          const errorNode: any = this.startNodeAt(lastTokEnd, lastTokEndLoc);
+          errorNode.error = (e as Error)?.message;
+          while (
+            this.type !== tokTypes.eof &&
+            this.type !== tokTypes.semi &&
+            this.type !== tokTypes.braceR
+          ) {
+            this.next();
+          }
+          return this.finishNode(errorNode, "ErrorStatement");
+        }
+      }
     };
   };
 }

package/src/transform/volar/printer.ts

@@ -35,12 +35,15 @@ export function getPrintOptions(
       if (node.type === "Identifier" && (node as Identifier).isDummy) {
         return false;
       }
+      if ((node.type as string) === "ErrorStatement") {
+        return false;
+      }
       if (state.attributeNameNodes.has(node as Identifier | Literal)) {
         return false;
       }
       return state.sourceNodes.has(node as Node);
     },
-    
+
     printCommentsOnUntouchedNodes: true,
     getLeadingComments: (node) => (node as Node).leadingComments,
     getTrailingComments: (node) => (node as Node).trailingComments,
@@ -111,15 +114,28 @@ export function getPrintOptions(
         const identifier = node as Identifier;
         if (identifier.isDummy && identifier.range) {
           const text = state.lastArgNodes.has(identifier) ? "," : "";
-          // extend the source mapping of dummy id to the before next token
+          // extend the source mapping of dummy id.
           let firstNonWhiteSpaceIndex = context.source
             .slice(identifier.range[1])
             .search(/\S/);
-          const rangeEnd =
-            firstNonWhiteSpaceIndex === -1
-              ? context.source.length
-              : identifier.range[1] + firstNonWhiteSpaceIndex;
-          context.writeMapped(text, identifier.range[0], rangeEnd);
+          if (firstNonWhiteSpaceIndex !== 0) {
+            // a) if next char-seq is whitespaces, write them as mapped
+            const rangeEnd =
+              firstNonWhiteSpaceIndex === -1
+                ? context.source.length
+                : identifier.range[1] + firstNonWhiteSpaceIndex;
+            context.writeMapped(text, identifier.range[0], rangeEnd);
+          } else {
+            // b) otherwise create extra mapping directly for next character
+            const rangeEnd = Math.min(node.range[0] + 1, context.source.length);
+            context.createExtraMapping(
+              { start: identifier.range[0], end: rangeEnd },
+              context.generatedOffset,
+              context.generatedOffset + 1,
+              DEFAULT_VOLAR_MAPPING_DATA,
+            );
+            context.write(text);
+          }
         } else if (
           identifier.range &&
           state.attributeNameNodes.has(identifier)
@@ -222,6 +238,23 @@ export function getPrintOptions(
         context.writeSource(node.whiteSpaceStart, node.whiteSpaceEnd);
         context.write(";");
       },
+      ErrorStatement(node: any, context: PrinterContext<CodeInformation>) {
+        if (node.range) {
+          context.writePreservedNode(node);
+          const rangeEnd = Math.min(node.range[1] + 1, context.source.length);
+          context.createExtraMapping(
+            { start: node.range[1], end: rangeEnd },
+            context.generatedOffset,
+            context.generatedOffset + 1,
+            VERIFICATION_ONLY_MAPPING_DATA,
+          );
+        } else {
+          // Emit a TS error indicate the error. This should not happen.
+          context.write(
+            `((_: never) => 0)(${JSON.stringify(node.error ?? "Unknown error")});`,
+          );
+        }
+      },
     },
     // Enable triggering signature completion
     experimentalGetLeftParenSourceRange: (node) => {