@gi-tcg/gts-transpiler 0.4.3 → 0.4.5

package/dist/index.js

@@ -713,17 +713,12 @@ const eraseTs = (ast) => {
 };
 //#endregion
 //#region src/transform/constants.ts
-const DEFAULT_SHORTCUT_FUNCTION_PRELUDES = [
-	"cryo",
-	"hydro",
-	"pyro",
-	"electro",
-	"anemo",
-	"geo",
-	"dendro",
-	"omni"
+const DEFAULT_SHORTCUT_FUNCTION_PRELUDES = ["$"];
+const DEFAULT_QUERY_BINDINGS = [
+	"my",
+	"opp",
+	"macros"
 ];
-const DEFAULT_QUERY_BINDINGS = ["my", "opp"];
 //#endregion
 //#region src/transform/gts.ts
 const commonGtsVisitor = {
@@ -1245,10 +1240,11 @@ function applyReplacements(state, code, mappings) {
 			const lhs = `${payload.finalMetaType}_lhs`;
 			const requiredAttrsNs = `${payload.finalMetaType}_rans`;
 			const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ") || "never"}`;
-			const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
+			const length = payload.errorRange ? payload.errorRange[1] - payload.errorRange[0] : 0;
+			const needleString = `"${requiredAttrsNs}_NeedleString${"0".repeat(length)}" as string as ${requiredAttrsNs}.DiagMsg`;
 			if (payload.errorRange) state.extraMappings.push({
 				sourceOffset: payload.errorRange[0],
-				length: payload.errorRange[1] - payload.errorRange[0],
+				length,
 				generatedNeedle: needleString
 			});
 			replacement = dedent`
@@ -1257,7 +1253,13 @@ function applyReplacements(state, code, mappings) {
         type ${lhs} = typeof ${lhs};
         namespace ${requiredAttrsNs} {
           export type Collected = ${collectedAttrsExpr};
-          export type Expected = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}];
+          export type Expected = {
+            [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never;
+          }[keyof ${payload.defType}];
+          type DiagObj = {
+            [K in Expected]: K extends Collected ? never : \`'\${K}' is a required attribute but not provided\`;
+          }
+          export type DiagMsg = DiagObj[Expected];
         };
         ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
       `;
@@ -1291,7 +1293,7 @@ function applyReplacements(state, code, mappings) {
                 ? ${payload.attrName}                             /* have duplicate, disable this */
                 : never
         );
-        let ${payload.lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${omittedKeys}>;
+        let ${payload.lhs}!: ${payload.hintOnly ? `{}` : `{ ${Meta}: ${payload.metaType} }`} & Omit<${payload.defType}, ${omittedKeys}>;
       `;
 		} else if (payload.type === "createBindingTyping") {
 			const typingIdLhs = `${payload.typingId}_lhs`;
@@ -1326,6 +1328,7 @@ function applyReplacements(state, code, mappings) {
 //#endregion
 //#region src/transform/volar/walker.ts
 const EMPTY = { type: "EmptyStatement" };
+const ATTR_HINT_ATTR_NAME = JSON.stringify("~attrNameHint");
 const enterVMFromRoot = (state) => {
 	let defTypeId = {
 		type: "Identifier",
@@ -1405,7 +1408,8 @@ const enterAttr = (state, attrName) => {
 		defType: defTypeId.name,
 		metaType: metaTypeId.name,
 		lhs: lhsId.name,
-		attrName
+		attrName,
+		hintOnly: attrName === ATTR_HINT_ATTR_NAME
 	}));
 	return { lhsId };
 };
@@ -1437,6 +1441,19 @@ const exitAttr = (state, returningId) => {
 		returnType: returningId.name
 	}));
 };
+const insertHintStatement = (state, whiteSpaceStart, whiteSpaceEnd) => {
+	const { lhsId } = enterAttr(state, ATTR_HINT_ATTR_NAME);
+	state.typingPendingStatements.push({
+		type: "GTSAttributeNameHintStatement",
+		object: lhsId,
+		whiteSpaceStart,
+		whiteSpaceEnd
+	});
+	exitAttr(state, {
+		type: "Identifier",
+		name: `__gts_attrRet_hint_${state.idCounter++}`
+	});
+};
 const gtsToTypingsWalker = {
 	Program(node, { state, visit }) {
 		const body = [];
@@ -1601,11 +1618,11 @@ const gtsToTypingsWalker = {
 				}
 			}]
 		});
+		enterVMFromAttr(state, returnValue);
 		if (body.namedAttributes) {
-			enterVMFromAttr(state, returnValue);
 			visit(body.namedAttributes);
 			exitVM(state, body.namedAttributes.range);
-		}
+		} else exitVM(state, name.range);
 		if (bindingName) {
 			const export_ = node.bindingAccessModifier !== "private";
 			const typingId = {
@@ -1636,7 +1653,17 @@ const gtsToTypingsWalker = {
 		return EMPTY;
 	},
 	GTSNamedAttributeBlock(node, { state, visit }) {
-		for (const attr of node.attributes) visit(attr);
+		const attributeListEnd = node.directAction?.range?.[0] ?? node.range?.[1] ?? -1;
+		const attributeListStart = node.attributes[0]?.range?.[0] ?? attributeListEnd;
+		if (node.range && attributeListStart > node.range[0] + 1) insertHintStatement(state, node.range[0] + 1, attributeListStart - 1);
+		for (let i = 0; i < node.attributes.length; i++) {
+			const attribute = node.attributes[i];
+			visit(attribute);
+			let nextTokenStart;
+			if (i < node.attributes.length - 1) nextTokenStart = node.attributes[i + 1].range?.[0] ?? -1;
+			else nextTokenStart = attributeListEnd;
+			if (attribute.range && nextTokenStart > attribute.range[1]) insertHintStatement(state, attribute.range[1], nextTokenStart - 1);
+		}
 		if (node.directAction) {
 			const stubStatement = {
 				type: "ExpressionStatement",
@@ -1693,6 +1720,7 @@ const gtsToTypingsWalker = {
 					}
 				}]
 			});
+			exitAttr(state, returnValue);
 		}
 		return EMPTY;
 	},
@@ -1733,6 +1761,7 @@ function getPrintOptions(source, state) {
 			if (state.attributeNameNodes.has(node)) return false;
 			return state.sourceNodes.has(node);
 		},
+		printCommentsOnUntouchedNodes: true,
 		getLeadingComments: (node) => node.leadingComments,
 		getTrailingComments: (node) => node.trailingComments,
 		getMappingData: () => DEFAULT_VOLAR_MAPPING_DATA,
@@ -1802,6 +1831,12 @@ function getPrintOptions(source, state) {
 						end: state.contentStartOffset + 1
 					}, context.generatedOffset, context.generatedOffset + 1, DEFAULT_VOLAR_MAPPING_DATA);
 				}
+			},
+			GTSAttributeNameHintStatement(node, context) {
+				context.writeNode(node.object);
+				context.write(".");
+				context.writeSource(node.whiteSpaceStart, node.whiteSpaceEnd);
+				context.write(";");
 			}
 		},
 		experimentalGetLeftParenSourceRange: (node) => {
@@ -1968,18 +2003,12 @@ function transform(ast, option = {}, sourceInfo = {}) {
 const DEFAULT_GTS_CONFIG = {
 	runtimeImportSource: "@gi-tcg/gts-runtime",
 	providerImportSource: "@gi-tcg/core/gts",
-	shortcutFunctionPreludes: [
-		"cryo",
-		"hydro",
-		"pyro",
-		"electro",
-		"anemo",
-		"geo",
-		"dendro",
-		"omni",
-		"$"
-	],
-	queryBindings: ["my", "opp"]
+	shortcutFunctionPreludes: ["$"],
+	queryBindings: [
+		"my",
+		"opp",
+		"macros"
+	]
 };
 function* resolveGtsConfigImpl(filePath, inlineConfig = {}, options) {
 	const pathModule = options.pathModule || browserPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"
@@ -22,7 +22,7 @@
     "@sveltejs/acorn-typescript": "^1.0.8",
     "acorn": "^8.15.0",
     "dedent": "^1.7.2",
-    "espolar": "^0.6.0",
+    "espolar": "^0.6.1",
     "esrap": "2.2.1",
     "magic-string": "^0.30.21",
     "path-browserify-esm": "^1.0.6",

package/src/config.ts

@@ -33,18 +33,8 @@ export interface ResolveGtsConfigAsyncOptions extends ResolveGtsConfigBaseOption
 const DEFAULT_GTS_CONFIG: Required<GtsConfig> = {
   runtimeImportSource: "@gi-tcg/gts-runtime",
   providerImportSource: "@gi-tcg/core/gts",
-  shortcutFunctionPreludes: [
-    "cryo",
-    "hydro",
-    "pyro",
-    "electro",
-    "anemo",
-    "geo",
-    "dendro",
-    "omni",
-    "$",
-  ],
-  queryBindings: ["my", "opp"],
+  shortcutFunctionPreludes: ["$"],
+  queryBindings: ["my", "opp", "macros"],
 };
 
 function* resolveGtsConfigImpl(

package/src/transform/constants.ts

@@ -1,11 +1,2 @@
-export const DEFAULT_SHORTCUT_FUNCTION_PRELUDES: string[] = [
-  "cryo",
-  "hydro",
-  "pyro",
-  "electro",
-  "anemo",
-  "geo",
-  "dendro",
-  "omni",
-];
-export const DEFAULT_QUERY_BINDINGS: string[] = ["my", "opp"];
+export const DEFAULT_SHORTCUT_FUNCTION_PRELUDES: string[] = ["$"];
+export const DEFAULT_QUERY_BINDINGS: string[] = ["my", "opp", "macros"];

package/src/transform/volar/printer.ts

@@ -10,6 +10,7 @@ import {
   type AST as EspolarAST,
   defaultPrinters,
   type SourceRange,
+  type PrinterContext,
 } from "espolar";
 import type { CodeInformation } from "@volar/language-core";
 import {
@@ -19,7 +20,7 @@ import {
   LITERAL_FROM_ID_MAPPING_DATA,
   VERIFICATION_ONLY_MAPPING_DATA,
 } from "./mappings.ts";
-import type { TypingTranspileState } from "./walker.ts";
+import type { TypingTranspileState, GTSAttributeNameHintStatement } from "./walker.ts";
 
 export function getPrintOptions(
   source: string,
@@ -36,6 +37,7 @@ export function getPrintOptions(
       }
       return state.sourceNodes.has(node as Node);
     },
+    printCommentsOnUntouchedNodes: true,
     getLeadingComments: (node) => (node as Node).leadingComments,
     getTrailingComments: (node) => (node as Node).trailingComments,
     getMappingData: () => DEFAULT_VOLAR_MAPPING_DATA,
@@ -186,6 +188,14 @@ export function getPrintOptions(
           );
         }
       },
+      // @ts-expect-error This is a custom node type that don't have typing.
+      // @see `GTSAttributeNameHintStatement`
+      GTSAttributeNameHintStatement(node: GTSAttributeNameHintStatement, context: PrinterContext<CodeInformation>) {
+        context.writeNode(node.object as EspolarAST.Node);
+        context.write(".");
+        context.writeSource(node.whiteSpaceStart, node.whiteSpaceEnd);
+        context.write(";");
+      }
     },
     // Enable triggering signature completion
     experimentalGetLeftParenSourceRange: (node) => {

package/src/transform/volar/replacements.ts

@@ -38,6 +38,7 @@ type ReplacementPayload =
       metaType: string;
       lhs: string;
       attrName: string;
+      hintOnly: boolean;
     }
   | {
       type: "createBindingTyping";
@@ -121,11 +122,15 @@ export function applyReplacements(
         const lhs = `${payload.finalMetaType}_lhs`;
         const requiredAttrsNs = `${payload.finalMetaType}_rans`;
         const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ") || "never"}`;
-        const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
+        const length = payload.errorRange
+          ? payload.errorRange[1] - payload.errorRange[0]
+          : 0;
+        // Ensure that generated needle string is longer than error range so that error squiggle can cover all
+        const needleString = `"${requiredAttrsNs}_NeedleString${"0".repeat(length)}" as string as ${requiredAttrsNs}.DiagMsg`;
         if (payload.errorRange) {
           state.extraMappings.push({
             sourceOffset: payload.errorRange[0],
-            length: payload.errorRange[1] - payload.errorRange[0],
+            length,
             generatedNeedle: needleString,
           });
         }
@@ -135,7 +140,13 @@ export function applyReplacements(
         type ${lhs} = typeof ${lhs};
         namespace ${requiredAttrsNs} {
           export type Collected = ${collectedAttrsExpr};
-          export type Expected = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}];
+          export type Expected = {
+            [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never;
+          }[keyof ${payload.defType}];
+          type DiagObj = {
+            [K in Expected]: K extends Collected ? never : \`'\${K}' is a required attribute but not provided\`;
+          }
+          export type DiagMsg = DiagObj[Expected];
         };
         ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
       `;
@@ -169,7 +180,7 @@ export function applyReplacements(
                 ? ${payload.attrName}                             /* have duplicate, disable this */
                 : never
         );
-        let ${payload.lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${omittedKeys}>;
+        let ${payload.lhs}!: ${payload.hintOnly ? `{}` : `{ ${Meta}: ${payload.metaType} }`} & Omit<${payload.defType}, ${omittedKeys}>;
       `;
       } else if (payload.type === "createBindingTyping") {
         const typingIdLhs = `${payload.typingId}_lhs`;

package/src/transform/volar/walker.ts

@@ -92,7 +92,25 @@ export interface TypingTranspileState extends TranspileState {
   contentStartOffset: number;
 }
 
+/**
+ * Map whitespaces inside named attribute blocks to include a "NameHintStatement", which printed
+ * as following:
+ * ```ts
+ * __gts_attr_obj.      ;
+ * //             ^~~~~~ these whitespaces are mapped from source
+ * ```
+ * so that when user press Ctrl+Space inside whitespace characters, they can get hint of available
+ * attribute names inside this block.
+ */
+export interface GTSAttributeNameHintStatement {
+  type: "GTSAttributeNameHintStatement";
+  object: Identifier;
+  whiteSpaceStart: number;
+  whiteSpaceEnd: number;
+}
+
 const EMPTY: EmptyStatement = { type: "EmptyStatement" };
+const ATTR_HINT_ATTR_NAME = JSON.stringify("~attrNameHint");
 
 const enterVMFromRoot = (state: TypingTranspileState) => {
   let defTypeId: Identifier = {
@@ -174,7 +192,7 @@ const enterAttr = (
   const defTypeId = state.vmDefTypeIdStack.at(-1);
   const metaTypeId = state.metaTypeIdStack.at(-1);
   if (!defTypeId || !metaTypeId) {
-    // TODO error handling?
+    // FIXME error handling?
     return { lhsId: { type: "Identifier", name: "__gts_invalid_attr_obj" } };
   }
   state.attrsOfCurrentVm.at(-1)!.push(attrName);
@@ -189,6 +207,7 @@ const enterAttr = (
       metaType: metaTypeId.name,
       lhs: lhsId.name,
       attrName,
+      hintOnly: attrName === ATTR_HINT_ATTR_NAME,
     }),
   );
   return { lhsId: lhsId };
@@ -238,6 +257,25 @@ const exitAttr = (state: TypingTranspileState, returningId: Identifier) => {
   );
 };
 
+const insertHintStatement = (
+  state: TypingTranspileState,
+  whiteSpaceStart: number,
+  whiteSpaceEnd: number,
+) => {
+  const { lhsId } = enterAttr(state, ATTR_HINT_ATTR_NAME);
+  state.typingPendingStatements.push({
+    type: "GTSAttributeNameHintStatement",
+    object: lhsId,
+    whiteSpaceStart,
+    whiteSpaceEnd,
+  } satisfies GTSAttributeNameHintStatement as any);
+  const returnValue: Identifier = {
+    type: "Identifier",
+    name: `__gts_attrRet_hint_${state.idCounter++}`,
+  };
+  exitAttr(state, returnValue);
+};
+
 export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
   Program(node, { state, visit }) {
     const body: Program["body"] = [];
@@ -434,10 +472,12 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         },
       ],
     });
+    enterVMFromAttr(state, returnValue);
     if (body.namedAttributes) {
-      enterVMFromAttr(state, returnValue);
       visit(body.namedAttributes);
       exitVM(state, body.namedAttributes.range);
+    } else {
+      exitVM(state, name.range);
     }
     if (bindingName) {
       const export_ = node.bindingAccessModifier !== "private";
@@ -469,8 +509,35 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
     return EMPTY;
   },
   GTSNamedAttributeBlock(node, { state, visit }) {
-    for (const attr of node.attributes) {
-      visit(attr);
+    // Insert hint statement around each attribute name:
+    // ```
+    // define foo {
+    //   // (1) hidden hint 
+    //   bar 1; // (2a) hidden hint
+    //   baz 2; // (2b) hidden hint
+    // }
+    // ```
+    const attributeListEnd =
+      node.directAction?.range?.[0] ?? node.range?.[1] ?? -1;
+    const attributeListStart =
+      node.attributes[0]?.range?.[0] ?? attributeListEnd;
+    // (1)
+    if (node.range && attributeListStart > node.range[0] + 1) {
+      insertHintStatement(state, node.range[0] + 1, attributeListStart - 1);
+    }
+    for (let i = 0; i < node.attributes.length; i++) {
+      const attribute = node.attributes[i];
+      visit(attribute);
+      let nextTokenStart: number;
+      if (i < node.attributes.length - 1) {
+        nextTokenStart = node.attributes[i + 1].range?.[0] ?? -1;
+      } else {
+        nextTokenStart = attributeListEnd;
+      }
+      // (2)
+      if (attribute.range && nextTokenStart > attribute.range[1]) {
+        insertHintStatement(state, attribute.range[1], nextTokenStart - 1);
+      }
     }
     if (node.directAction) {
       const stubStatement: ExpressionStatement = {
@@ -527,6 +594,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
           },
         ],
       });
+      exitAttr(state, returnValue);
     }
     return EMPTY;
   },