Feature: String templates

common/changes/@typespec/compiler/feature-string-template_2023-11-14-00-00.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@typespec/compiler",
+      "comment": "**New language feature** **BREAKING** Added string template literal in typespec. Singel and multi-line strings can be interpolated with `${` and `}`. Example `\\`Doc for url ${url} is here: ${location}\\``",
+      "type": "none"
+    }
+  ],
+  "packageName": "@typespec/compiler"
+}

common/changes/@typespec/json-schema/feature-string-template_2023-11-14-00-00.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@typespec/json-schema",
+      "comment": "Added support for string template literals",
+      "type": "none"
+    }
+  ],
+  "packageName": "@typespec/json-schema"
+}

docs/language-basics/type-literals.md

@@ -62,6 +62,22 @@ two
 }
 ```
 
+## String template literal
+
+Single or multi line string literal can be interpolated using `${}`
+
+```typespec
+alias hello = "bonjour";
+alias Single = "${hello} world!";
+
+alias Multi = """
+  ${hello} 
+  world!
+  """;
+```
+
+Any valid expression can be used in the interpolation but only other literals will result in the template literal being assignable to a `valueof string`. Any other value will be dependent on the decorator/emitter receiving it to handle.
+
 ## Numeric literal
 
 Numeric literals can be declared by using the raw number

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

@@ -3,7 +3,12 @@ import { createSymbol, createSymbolTable } from "./binder.js";
 import { getDeprecationDetails, markDeprecated } from "./deprecation.js";
 import { ProjectionError, compilerAssert, reportDeprecated } from "./diagnostics.js";
 import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-utils.js";
-import { TypeNameOptions, getNamespaceFullName, getTypeName } from "./helpers/index.js";
+import {
+  TypeNameOptions,
+  getNamespaceFullName,
+  getTypeName,
+  stringTemplateToString,
+} from "./helpers/index.js";
 import { createDiagnostic } from "./messages.js";
 import { getIdentifierContext, hasParseError, visitChildren } from "./parser.js";
 import { Program, ProjectedProgram } from "./program.js";
@@ -102,6 +107,14 @@ import {
   StdTypes,
   StringLiteral,
   StringLiteralNode,
+  StringTemplate,
+  StringTemplateExpressionNode,
+  StringTemplateHeadNode,
+  StringTemplateMiddleNode,
+  StringTemplateSpan,
+  StringTemplateSpanLiteral,
+  StringTemplateSpanValue,
+  StringTemplateTailNode,
   Sym,
   SymbolFlags,
   SymbolLinks,
@@ -641,6 +654,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 +2397,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);
   }
@@ -3243,6 +3300,10 @@ export function createChecker(program: Program): Checker {
     if (type === nullType) {
       return true;
     }
+    if (type.kind === "StringTemplate") {
+      const [_, diagnostics] = stringTemplateToString(type);
+      return diagnostics.length === 0;
+    }
     const valueTypes = new Set(["String", "Number", "Boolean", "EnumMember", "Tuple"]);
     return valueTypes.has(type.kind);
   }
@@ -3424,6 +3485,8 @@ export function createChecker(program: Program): Checker {
     if (valueOf) {
       if (value.kind === "Boolean" || value.kind === "String" || value.kind === "Number") {
         return literalTypeToValue(value);
+      } else if (value.kind === "StringTemplate") {
+        return stringTemplateToString(value)[0];
       }
     }
     return value;
@@ -4058,7 +4121,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 +4939,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)!;
@@ -5267,6 +5343,7 @@ export function createChecker(program: Program): Checker {
       case "Number":
         return isNumericLiteralRelatedTo(source, target);
       case "String":
+      case "StringTemplate":
         return areScalarsRelated(target, getStdType("string"));
       case "Boolean":
         return areScalarsRelated(target, getStdType("boolean"));
@@ -6040,6 +6117,8 @@ function marshalArgumentsForJS<T extends Type>(args: T[]): MarshalledValue<T>[]
   return args.map((arg) => {
     if (arg.kind === "Boolean" || arg.kind === "String" || arg.kind === "Number") {
       return literalTypeToValue(arg);
+    } else if (arg.kind === "StringTemplate") {
+      return stringTemplateToString(arg)[0];
     }
     return arg as any;
   });

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/helpers/type-name-utils.ts

@@ -45,6 +45,8 @@ export function getTypeName(type: Type | ValueType, options?: TypeNameOptions):
       return getTypeName(type.type, options);
     case "Tuple":
       return "[" + type.values.map((x) => getTypeName(x, options)).join(", ") + "]";
+    case "StringTemplate":
+      return "string";
     case "String":
     case "Number":
     case "Boolean":

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