Better

packages/compiler/src/testing/index.ts

@@ -36,4 +36,5 @@ export type {
 } from "./types.js";
 
 // TODO: use named imports
+export { t } from "./marked-template.js";
 export * from "./test-host-v2.js";

packages/compiler/src/testing/marked-template.ts

@@ -50,71 +50,41 @@ function valueMarker<const T extends Value>(valueKind?: T["valueKind"]) {
   };
 }
 
-export const m = {
-  // Types
-  type: typeMarker<Type>(),
-  model: typeMarker<Model>("Model"),
-  enum: typeMarker<Enum>("Enum"),
-  union: typeMarker<Union>("Union"),
-  interface: typeMarker<Interface>("Interface"),
-  op: typeMarker<Operation>("Operation"),
-  enumMember: typeMarker<EnumMember>("EnumMember"),
-  modelProperty: typeMarker<ModelProperty>("ModelProperty"),
-  namespace: typeMarker<Namespace>("Namespace"),
-  scalar: typeMarker<Type>("Scalar"),
-  unionVariant: typeMarker<Type>("UnionVariant"),
-  boolean: typeMarker<Type>("Boolean"),
-  number: typeMarker<Type>("Number"),
-  string: typeMarker<Type>("String"),
-
-  // Values
-  value: valueMarker<Value>(),
-  object: valueMarker<Value>("ObjectValue"),
-  array: valueMarker<Value>("ArrayValue"),
-};
-
 export type MarkerConfig<T extends Record<string, Entity>> = {
-  [K in keyof T]: {
-    pos: number;
-    end: number;
-  } & Marker<T[K], K & string>;
+  [K in keyof T]: Marker<T[K], K & string>;
 };
 
 export interface TemplateWithMarkers<T extends Record<string, Entity>> {
   readonly code: string;
   readonly markers: MarkerConfig<T>;
 }
 
-type Prettify<T> = {
-  [K in keyof T]: T[K];
+type Prettify<T extends Record<string, Entity>> = {
+  [K in keyof T]: T[K] & Entity;
 } & {};
+
 type InferType<T> = T extends Marker<infer K, infer _> ? K : never;
 type CollectType<T extends ReadonlyArray<Marker<Entity, string> | string>> = {
   [K in T[number] as K extends Marker<infer _K, infer N> ? N : never]: InferType<K>;
 };
 /** Specify that this value is dynamic and needs to be interpolated with the given keys */
-export function extract<const T extends (Marker<Entity, string> | string)[]>(
+function extract<const T extends (Marker<Entity, string> | string)[]>(
   strings: TemplateStringsArray,
   ...keys: T
-): TemplateWithMarkers<Prettify<CollectType<T>> & Record<string, Entity>> {
+): TemplateWithMarkers<Prettify<CollectType<T>>> {
   const markers: MarkerConfig<any> = {};
   const result: string[] = [strings[0]];
-  let pos = strings[0].length;
   keys.forEach((key, i) => {
     if (typeof key === "string") {
       result.push(key);
-      pos += key.length;
     } else {
-      result.push(key.name);
+      result.push(`/*${key.name}*/${key.name}`);
       markers[key.name] = {
-        pos,
-        end: pos + key.name.length,
         entityKind: key.entityKind,
         name: key.name,
         kind: (key as any).kind,
         valueKind: (key as any).valueKind,
       };
-      pos += key.name.length;
     }
     result.push(strings[i + 1]);
   });
@@ -124,4 +94,28 @@ export function extract<const T extends (Marker<Entity, string> | string)[]>(
   };
 }
 
-const a = extract`foo ${m.model("bar")} ${"regular"}  ${m.enum("def")}`;
+/** TypeSpec template marker */
+export const t = {
+  code: extract,
+
+  // Types
+  type: typeMarker<Type>(),
+  model: typeMarker<Model>("Model"),
+  enum: typeMarker<Enum>("Enum"),
+  union: typeMarker<Union>("Union"),
+  interface: typeMarker<Interface>("Interface"),
+  op: typeMarker<Operation>("Operation"),
+  enumMember: typeMarker<EnumMember>("EnumMember"),
+  modelProperty: typeMarker<ModelProperty>("ModelProperty"),
+  namespace: typeMarker<Namespace>("Namespace"),
+  scalar: typeMarker<Type>("Scalar"),
+  unionVariant: typeMarker<Type>("UnionVariant"),
+  boolean: typeMarker<Type>("Boolean"),
+  number: typeMarker<Type>("Number"),
+  string: typeMarker<Type>("String"),
+
+  // Values
+  value: valueMarker<Value>(),
+  object: valueMarker<Value>("ObjectValue"),
+  array: valueMarker<Value>("ArrayValue"),
+};

packages/compiler/src/testing/test-host-v2.ts

@@ -213,6 +213,9 @@ function createTesterInstance(params: TesterInternalParams): TesterInstance {
       ...usings,
       params.wraps ? applyWraps(codeStr, params.wraps) : codeStr,
     ].join("\n");
+
+    const markerPositions = extractMarkers(actualCode);
+
     fs.addTypeSpecFile("main.tsp", actualCode);
     const program = await coreCompile(fs.compilerHost, resolveVirtualPath("main.tsp"));
     savedProgram = program;
@@ -222,8 +225,9 @@ function createTesterInstance(params: TesterInternalParams): TesterInstance {
       if (!file) {
         throw new Error(`Couldn't find main.tsp in program`);
       }
-      for (const marker of Object.values(code.markers)) {
-        const { pos, end, name, kind, entityKind, valueKind } = marker;
+      for (const marker of markerPositions) {
+        const { name, pos, end } = marker;
+        const markerConfig = code.markers[name];
         const node = getNodeAtPosition(file, pos);
         if (!node) {
           throw new Error(`Could not find node at ${pos}-${end}`);
@@ -235,23 +239,31 @@ function createTesterInstance(params: TesterInternalParams): TesterInstance {
         const entity = program.checker.getTypeOrValueForNode(getSymNode(sym));
         if (entity === null) {
           throw new Error(
-            `Expected ${name} to be of entity kind ${entityKind} but got null (Means a value failed to resolve) at ${pos}-${end}`,
+            `Expected ${name} to be of entity kind ${markerConfig?.entityKind} but got null (Means a value failed to resolve) at ${pos}-${end}`,
           );
         }
-        if (entity.entityKind !== entityKind) {
-          throw new Error(
-            `Expected ${name} to be of entity kind ${entityKind} but got (${entity?.entityKind}) ${getEntityName(entity)} at ${pos}-${end}`,
-          );
-        }
-        if (entity.entityKind === "Type" && entity.kind !== kind) {
-          throw new Error(
-            `Expected ${name} to be of kind ${kind} but got (${entity.kind}) ${getEntityName(entity)} at ${pos}-${end}`,
-          );
-        } else if (entity?.entityKind === "Value" && entity.valueKind !== valueKind) {
-          throw new Error(
-            `Expected ${name} to be of value kind ${valueKind} but got (${entity.valueKind}) ${getEntityName(entity)} at ${pos}-${end}`,
-          );
+        if (markerConfig) {
+          const { entityKind, kind, valueKind } = markerConfig as any;
+          if (entity.entityKind !== entityKind) {
+            throw new Error(
+              `Expected ${name} to be of entity kind ${entityKind} but got (${entity?.entityKind}) ${getEntityName(entity)} at ${pos}-${end}`,
+            );
+          }
+          if (entity.entityKind === "Type" && kind !== undefined && entity.kind !== kind) {
+            throw new Error(
+              `Expected ${name} to be of kind ${kind} but got (${entity.kind}) ${getEntityName(entity)} at ${pos}-${end}`,
+            );
+          } else if (
+            entity?.entityKind === "Value" &&
+            valueKind !== undefined &&
+            entity.valueKind !== valueKind
+          ) {
+            throw new Error(
+              `Expected ${name} to be of value kind ${valueKind} but got (${entity.valueKind}) ${getEntityName(entity)} at ${pos}-${end}`,
+            );
+          }
         }
+
         (types as any)[name] = entity;
       }
     }
@@ -306,3 +318,30 @@ function addTestLib(fs: TestFileSystem): Record<string, Type> {
   });
   return testTypes;
 }
+
+export interface PositionedMarker {
+  name: string;
+  pos: number;
+  end: number;
+}
+function extractMarkers(code: string): PositionedMarker[] {
+  // Extract TypeScript fourslash-style markers: /*markerName*/
+  // Returns an array of Marker objects with name, pos, and end
+  const markerRegex = /\/\*([a-zA-Z0-9_]+)\*\//g;
+  const markers: PositionedMarker[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = markerRegex.exec(code)) !== null) {
+    const markerName = match[1];
+    // The marker is immediately followed by the identifier
+    // Find the next word after the marker
+    const afterMarker = code.slice(markerRegex.lastIndex);
+    const idMatch = /([a-zA-Z0-9_]+)/.exec(afterMarker);
+    if (idMatch) {
+      const id = idMatch[1];
+      const pos = markerRegex.lastIndex;
+      const end = pos + id.length;
+      markers.push({ name: markerName, pos, end });
+    }
+  }
+  return markers;
+}