Feature: String templates

packages/compiler/lib/reflection.tsp

@@ -10,3 +10,4 @@ model Operation {}
 model Scalar {}
 model Union {}
 model UnionVariant {}
+model StringTemplate {}

packages/compiler/src/core/checker.ts

@@ -102,6 +102,14 @@ import {
   StdTypes,
   StringLiteral,
   StringLiteralNode,
+  StringTemplate,
+  StringTemplateExpressionNode,
+  StringTemplateHeadNode,
+  StringTemplateMiddleNode,
+  StringTemplateSpan,
+  StringTemplateSpanLiteral,
+  StringTemplateSpanValue,
+  StringTemplateTailNode,
   Sym,
   SymbolFlags,
   SymbolLinks,
@@ -641,6 +649,8 @@ export function createChecker(program: Program): Checker {
         return checkTupleExpression(node, mapper);
       case SyntaxKind.StringLiteral:
         return checkStringLiteral(node);
+      case SyntaxKind.StringTemplateExpression:
+        return checkStringTemplateExpresion(node, mapper);
       case SyntaxKind.ArrayExpression:
         return checkArrayExpression(node, mapper);
       case SyntaxKind.UnionExpression:
@@ -2382,6 +2392,48 @@ export function createChecker(program: Program): Checker {
         return getMergedSymbol(aliasType.node!.symbol) ?? aliasSymbol;
     }
   }
+
+  function checkStringTemplateExpresion(
+    node: StringTemplateExpressionNode,
+    mapper: TypeMapper | undefined
+  ): StringTemplate {
+    const spans: StringTemplateSpan[] = [createTemplateSpanLiteral(node.head)];
+    for (const span of node.spans) {
+      spans.push(createTemplateSpanValue(span.expression, mapper));
+      spans.push(createTemplateSpanLiteral(span.literal));
+    }
+    const type = createType({
+      kind: "StringTemplate",
+      node,
+      spans,
+    });
+
+    return type;
+  }
+
+  function createTemplateSpanLiteral(
+    node: StringTemplateHeadNode | StringTemplateMiddleNode | StringTemplateTailNode
+  ): StringTemplateSpanLiteral {
+    return createType({
+      kind: "StringTemplateSpan",
+      node: node,
+      isInterpolated: false,
+      type: getLiteralType(node),
+    });
+  }
+
+  function createTemplateSpanValue(
+    node: Expression,
+    mapper: TypeMapper | undefined
+  ): StringTemplateSpanValue {
+    return createType({
+      kind: "StringTemplateSpan",
+      node: node,
+      isInterpolated: true,
+      type: getTypeForNode(node, mapper),
+    });
+  }
+
   function checkStringLiteral(str: StringLiteralNode): StringLiteral {
     return getLiteralType(str);
   }
@@ -4058,7 +4110,13 @@ export function createChecker(program: Program): Checker {
     return finishTypeForProgramAndChecker(program, typePrototype, typeDef);
   }
 
-  function getLiteralType(node: StringLiteralNode): StringLiteral;
+  function getLiteralType(
+    node:
+      | StringLiteralNode
+      | StringTemplateHeadNode
+      | StringTemplateMiddleNode
+      | StringTemplateTailNode
+  ): StringLiteral;
   function getLiteralType(node: NumericLiteralNode): NumericLiteral;
   function getLiteralType(node: BooleanLiteralNode): BooleanLiteral;
   function getLiteralType(node: LiteralNode): LiteralType;
@@ -4870,16 +4928,23 @@ export function createChecker(program: Program): Checker {
     } as const);
   }
 
-  function createLiteralType(value: string, node?: StringLiteralNode): StringLiteral;
+  function createLiteralType(
+    value: string,
+    node?:
+      | StringLiteralNode
+      | StringTemplateHeadNode
+      | StringTemplateMiddleNode
+      | StringTemplateTailNode
+  ): StringLiteral;
   function createLiteralType(value: number, node?: NumericLiteralNode): NumericLiteral;
   function createLiteralType(value: boolean, node?: BooleanLiteralNode): BooleanLiteral;
   function createLiteralType(
     value: string | number | boolean,
-    node?: StringLiteralNode | NumericLiteralNode | BooleanLiteralNode
+    node?: LiteralNode
   ): StringLiteral | NumericLiteral | BooleanLiteral;
   function createLiteralType(
     value: string | number | boolean,
-    node?: StringLiteralNode | NumericLiteralNode | BooleanLiteralNode
+    node?: LiteralNode
   ): StringLiteral | NumericLiteral | BooleanLiteral {
     if (program.literalTypes.has(value)) {
       return program.literalTypes.get(value)!;

packages/compiler/src/core/helpers/index.ts

@@ -3,5 +3,6 @@ export { getLocationContext } from "./location-context.js";
 export * from "./operation-utils.js";
 export * from "./path-interpolation.js";
 export * from "./projected-names-utils.js";
+export { stringTemplateToString } from "./string-template-utils.js";
 export * from "./type-name-utils.js";
 export * from "./usage-resolver.js";

packages/compiler/src/core/helpers/string-template-utils.ts

@@ -0,0 +1,39 @@
+import { createDiagnostic } from "../messages.js";
+import { Diagnostic, StringTemplate } from "../types.js";
+import { getTypeName } from "./type-name-utils.js";
+
+/**
+ * Convert a string template to a string value.
+ * Only literal interpolated can be converted to string.
+ * Otherwise diagnostics will be reported.
+ *
+ * @param stringTemplate String template to convert.
+ */
+export function stringTemplateToString(
+  stringTemplate: StringTemplate
+): [string, readonly Diagnostic[]] {
+  const diagnostics: Diagnostic[] = [];
+  const result = stringTemplate.spans
+    .map((x) => {
+      if (x.isInterpolated) {
+        switch (x.type.kind) {
+          case "String":
+          case "Number":
+          case "Boolean":
+            return String(x.type.value);
+          default:
+            diagnostics.push(
+              createDiagnostic({
+                code: "non-literal-string-template",
+                target: x.node,
+              })
+            );
+            return getTypeName(x.type);
+        }
+      } else {
+        return x.type.value;
+      }
+    })
+    .join("");
+  return [result, diagnostics];
+}

packages/compiler/src/core/messages.ts

@@ -586,6 +586,13 @@ const diagnostics = {
         "Projections are experimental - your code will need to change as this feature evolves.",
     },
   },
+  "non-literal-string-template": {
+    severity: "error",
+    messages: {
+      default:
+        "Value interpolated in this string template cannot be converted to a string. Only literal types can be automatically interpolated.",
+    },
+  },
 
   /**
    * Binder

packages/compiler/src/core/parser.ts

@@ -90,6 +90,11 @@ import {
   SourceFile,
   Statement,
   StringLiteralNode,
+  StringTemplateExpressionNode,
+  StringTemplateHeadNode,
+  StringTemplateMiddleNode,
+  StringTemplateSpanNode,
+  StringTemplateTailNode,
   Sym,
   SyntaxKind,
   TemplateParameterDeclarationNode,
@@ -1340,6 +1345,8 @@ function createParser(code: string | SourceFile, options: ParseOptions = {}): Pa
           return parseReferenceExpression();
         case Token.StringLiteral:
           return parseStringLiteral();
+        case Token.StringTemplateHead:
+          return parseStringTemplateExpression();
         case Token.TrueKeyword:
         case Token.FalseKeyword:
           return parseBooleanLiteral();
@@ -1446,6 +1453,119 @@ function createParser(code: string | SourceFile, options: ParseOptions = {}): Pa
     };
   }
 
+  function parseStringTemplateExpression(): StringTemplateExpressionNode {
+    const pos = tokenPos();
+    const head = parseStringTemplateHead();
+    const spans = parseStringTemplateSpans(head.tokenFlags);
+    const last = spans[spans.length - 1];
+
+    if (head.tokenFlags & TokenFlags.TripleQuoted) {
+      const [indentationsStart, indentationEnd] = scanner.findTripleQuotedStringIndent(
+        last.literal.pos,
+        last.literal.end
+      );
+      mutate(head).value = scanner.unindentAndUnescapeTripleQuotedString(
+        head.pos,
+        head.end,
+        indentationsStart,
+        indentationEnd,
+        Token.StringTemplateHead,
+        head.tokenFlags
+      );
+      for (const span of spans) {
+        mutate(span.literal).value = scanner.unindentAndUnescapeTripleQuotedString(
+          span.literal.pos,
+          span.literal.end,
+          indentationsStart,
+          indentationEnd,
+          span === last ? Token.StringTemplateTail : Token.StringTemplateMiddle,
+          head.tokenFlags
+        );
+      }
+    }
+    return {
+      kind: SyntaxKind.StringTemplateExpression,
+      head,
+      spans,
+      ...finishNode(pos),
+    };
+  }
+
+  function parseStringTemplateHead(): StringTemplateHeadNode {
+    const pos = tokenPos();
+    const flags = tokenFlags();
+    const text = flags & TokenFlags.TripleQuoted ? "" : tokenValue();
+
+    parseExpected(Token.StringTemplateHead);
+
+    return {
+      kind: SyntaxKind.StringTemplateHead,
+      value: text,
+      tokenFlags: flags,
+      ...finishNode(pos),
+    };
+  }
+
+  function parseStringTemplateSpans(tokenFlags: TokenFlags): readonly StringTemplateSpanNode[] {
+    const list: StringTemplateSpanNode[] = [];
+    let node: StringTemplateSpanNode;
+    do {
+      node = parseTemplateTypeSpan(tokenFlags);
+      list.push(node);
+    } while (node.literal.kind === SyntaxKind.StringTemplateMiddle);
+    return list;
+  }
+
+  function parseTemplateTypeSpan(tokenFlags: TokenFlags): StringTemplateSpanNode {
+    const pos = tokenPos();
+    const expression = parseExpression();
+    const literal = parseLiteralOfTemplateSpan(tokenFlags);
+    return {
+      kind: SyntaxKind.StringTemplateSpan,
+      literal,
+      expression,
+      ...finishNode(pos),
+    };
+  }
+  function parseLiteralOfTemplateSpan(
+    headTokenFlags: TokenFlags
+  ): StringTemplateMiddleNode | StringTemplateTailNode {
+    const pos = tokenPos();
+    const flags = tokenFlags();
+    const text = flags & TokenFlags.TripleQuoted ? "" : tokenValue();
+
+    if (token() === Token.CloseBrace) {
+      nextStringTemplateToken(headTokenFlags);
+      return parseTemplateMiddleOrTemplateTail();
+    } else {
+      parseExpected(Token.StringTemplateTail);
+      return {
+        kind: SyntaxKind.StringTemplateTail,
+        value: text,
+        tokenFlags: flags,
+        ...finishNode(pos),
+      };
+    }
+  }
+
+  function parseTemplateMiddleOrTemplateTail(): StringTemplateMiddleNode | StringTemplateTailNode {
+    const pos = tokenPos();
+    const flags = tokenFlags();
+    const text = flags & TokenFlags.TripleQuoted ? "" : tokenValue();
+    const kind =
+      token() === Token.StringTemplateMiddle
+        ? SyntaxKind.StringTemplateMiddle
+        : SyntaxKind.StringTemplateTail;
+
+    nextToken();
+    return {
+      kind,
+      value: text,
+      tokenFlags: flags,
+      ...finishNode(pos),
+    };
+  }
+
   function parseNumericLiteral(): NumericLiteralNode {
     const pos = tokenPos();
     const valueAsString = tokenValue();
@@ -2575,6 +2695,10 @@ function createParser(code: string | SourceFile, options: ParseOptions = {}): Pa
     scanner.scanDoc();
   }
 
+  function nextStringTemplateToken(tokenFlags: TokenFlags) {
+    scanner.reScanStringTemplate(tokenFlags);
+  }
+
   function createMissingIdentifier(): IdentifierNode {
     const pos = tokenPos();
     previousTokenEnd = pos;
@@ -3162,7 +3286,15 @@ export function visitChildren<T>(node: Node, cb: NodeCallback<T>): T | undefined
     case SyntaxKind.DocUnknownTag:
       return visitNode(cb, node.tagName) || visitEach(cb, node.content);
 
+    case SyntaxKind.StringTemplateExpression:
+      return visitNode(cb, node.head) || visitEach(cb, node.spans);
+    case SyntaxKind.StringTemplateSpan:
+      return visitNode(cb, node.expression) || visitNode(cb, node.literal);
+
     // no children for the rest of these.
+    case SyntaxKind.StringTemplateHead:
+    case SyntaxKind.StringTemplateMiddle:
+    case SyntaxKind.StringTemplateTail:
     case SyntaxKind.StringLiteral:
     case SyntaxKind.NumericLiteral:
     case SyntaxKind.BooleanLiteral: