string_literal.md

format/ast.ts

@@ -1,5 +1,6 @@
 export enum NodeType {
     Identifer = "Identifier",
+    StringLiteral = "StringLiteral",
     MessageReference = "MessageReference",
     TextElement = "TextElement",
     Placeable = "Placeable",
@@ -18,13 +19,19 @@ export interface Identifier extends SyntaxNode {
     readonly name: string;
 }
 
+export interface StringLiteral extends SyntaxNode {
+    readonly type: NodeType.StringLiteral;
+    readonly value: string;
+    parse(): {value: string};
+}
+
 export interface MessageReference extends SyntaxNode {
     readonly type: NodeType.MessageReference;
     readonly id: Identifier;
     readonly attribute: Identifier | null;
 }
 
-export type InlineExpression = MessageReference;
+export type InlineExpression = StringLiteral | MessageReference;
 
 export type Expression = InlineExpression;
 

format/scope.ts

@@ -16,13 +16,20 @@ export class Scope {
 
     resolveExpression(node: ast.Expression): Value {
         switch (node.type) {
+            case ast.NodeType.StringLiteral:
+                return this.resolveStringLiteral(node as ast.StringLiteral);
             case ast.NodeType.MessageReference:
                 return this.resolveMessageReference(node as ast.MessageReference);
             default:
                 throw new TypeError("Unknown node type.");
         }
     }
 
+    resolveStringLiteral(node: ast.StringLiteral): Value {
+        let {value} = node.parse();
+        return new StringValue(value);
+    }
+
     resolveMessageReference(node: ast.MessageReference): Value {
         let message = this.messages.get(node.id.name);
         if (message == undefined) {

spec/format/string_literal.md

@@ -0,0 +1,88 @@
+# StringLiteral
+
+`StringLiterals` can be interpolated as `Placeables` inside `Patterns`. They
+format to their text content.
+
+```properties
+test = {"Text"}
+```
+
+```json
+{
+    "value": "Text",
+    "errors": []
+}
+```
+
+All whitespace is preserved in `StringLiterals`.
+
+```properties
+test = A {"    "} B
+```
+
+```json
+{
+    "value": "A      B",
+    "errors": []
+}
+```
+
+When positioned at the front or at the end of a `Pattern`, `StringLiterals`
+can be used to preserve leading and trailing whitespace which would be
+otherwise trimmed inside `TextElement`.
+
+```properties
+test = {"    "}Text
+```
+
+```json
+{
+    "value": "    Text",
+    "errors": []
+}
+```
+
+## Escape Sequences
+
+Escape sequences are supported in `StringLiterals`.
+
+Characters from the Basic Multilingual Plane (BMP) can be escaped using the
+four-hexdigits escape sequences, starting with `\u`.
+
+```properties
+test = {"\u0041"}
+```
+
+```json
+{
+    "value": "A",
+    "errors": []
+}
+```
+
+Astral characters can be escaped using the six-hexdigit escape sequences,
+starting with `\U`.
+
+```properties
+test = {"\U01F602"}
+```
+
+```json
+{
+    "value": "😂",
+    "errors": []
+}
+```
+
+A double-backslash can be used to obtain a single backslash in the formatting output.
+
+```properties
+test = {"\\U01F602"}
+```
+
+```json
+{
+    "value": "\\U01F602",
+    "errors": []
+}
+```

spec/format/text_element.md

@@ -30,3 +30,18 @@ test =
     "errors": []
 }
 ```
+
+## Escape Sequences
+
+Escape sequences are not supported in `TextElements`.
+
+```properties
+test = \U01F602
+```
+
+```json
+{
+    "value": "\\U01F602",
+    "errors": []
+}
+```