StringLiteral

README.md

@@ -37,7 +37,7 @@ npm run mtsc ./tests/singleVar.ts
 - [ ] Make semicolon a statement ender, not statement separator.
   - Hint: You'll need a predicate to peek at the next token and decide if it's the start of an element.
   - Bonus: Switch from semicolon to newline as statement ender.
-- [ ] Add string literals.
+- [x] Add string literals.
 - [ ] Add let.
   - Then add use-before-declaration errors in the checker.
   - Finally, add an ES2015 -> ES5 transform that transforms `let` to `var`.

baselines/reference/singleTypedVar.errors.baseline

@@ -2,5 +2,9 @@
   {
     "pos": 17,
     "message": "Cannot assign initialiser of type 'number' to variable with declared type 'string'."
+  },
+  {
+    "pos": 41,
+    "message": "Cannot assign initialiser of type 'string' to variable with declared type 'number'."
   }
 ]

baselines/reference/singleTypedVar.js.baseline

@@ -1 +1 @@
-"var s = 1"
+"var s = 1;\nvar n = 'test';\n"

baselines/reference/singleTypedVar.tree.baseline

@@ -22,6 +22,21 @@
         "kind": "Literal",
         "value": 1
       }
+    },
+    {
+      "kind": "Var",
+      "name": {
+        "kind": "Identifier",
+        "text": "n"
+      },
+      "typename": {
+        "kind": "Identifier",
+        "text": "number"
+      },
+      "init": {
+        "kind": "Literal",
+        "value": "'test'"
+      }
     }
   ]
 }

baselines/reference/stringLIteral.errors.baseline

@@ -0,0 +1 @@
+[]

baselines/reference/stringLIteral.js.baseline

@@ -0,0 +1 @@
+"var singleQuote = 'singleQuote';\nvar doubleQuote = \"doubleQuote\""

baselines/reference/stringLIteral.tree.baseline

@@ -0,0 +1,47 @@
+{
+  "locals": {
+    "singleQuote": [
+      {
+        "kind": "Var",
+        "pos": 3
+      }
+    ],
+    "doubleQuote": [
+      {
+        "kind": "Var",
+        "pos": 36
+      }
+    ]
+  },
+  "statements": [
+    {
+      "kind": "Var",
+      "name": {
+        "kind": "Identifier",
+        "text": "singleQuote"
+      },
+      "init": {
+        "kind": "Literal",
+        "value": "singleQuote"
+      }
+    },
+    {
+      "kind": "Var",
+      "name": {
+        "kind": "Identifier",
+        "text": "doubleQuote"
+      },
+      "init": {
+        "kind": "Literal",
+        "value": "double'Quote"
+      }
+    },
+    {
+      "kind": "ExpressionStatement",
+      "expr": {
+        "kind": "Identifier",
+        "text": "(missing)"
+      }
+    }
+  ]
+}

src/check.ts

@@ -54,7 +54,7 @@ export function check(module: Module) {
         error(expression.pos, 'Could not resolve ' + expression.text);
         return errorType;
       case Node.Literal:
-        return numberType;
+        return typeof expression.value === 'string' ? stringType : numberType;
       case Node.Assignment:
         const v = checkExpression(expression.value);
         const t = checkExpression(expression.name);

src/lex.ts

@@ -1,4 +1,4 @@
-import { Token, Lexer } from './types';
+import { Token, Lexer, CharCodes } from './types';
 
 const keywords = {
   function: Token.Function,
@@ -40,6 +40,9 @@ export function lex(s: string): Lexer {
         text in keywords
           ? keywords[text as keyof typeof keywords]
           : Token.Identifier;
+    } else if (['"', "'"].includes(s.charAt(pos))) {
+      text = scanString();
+      token = Token.String;
     } else {
       pos++;
       switch (s.charAt(pos - 1)) {
@@ -62,6 +65,62 @@ export function lex(s: string): Lexer {
   function scanForward(pred: (x: string) => boolean) {
     while (pos < s.length && pred(s.charAt(pos))) pos++;
   }
+
+  function scanString() {
+    const quote = s.charCodeAt(pos);
+    pos++;
+
+    let stringValue = '';
+    let start = pos;
+
+    while (true) {
+      if (pos >= s.length) {
+        // report unterminated string literal error
+      }
+
+      const char = s.charCodeAt(pos);
+
+      if (char === quote) {
+        stringValue += s.slice(start, pos);
+        pos++;
+        break;
+      }
+
+      if (char === CharCodes.backslash) {
+        stringValue += s.slice(start, pos);
+        stringValue += scanEscapeSequence();
+        start = pos;
+        continue;
+      }
+
+      pos++;
+    }
+
+    return stringValue;
+  }
+
+  function scanEscapeSequence() {
+    pos++;
+    const char = s.charCodeAt(pos);
+    pos++;
+
+    switch (char) {
+      case CharCodes.b:
+        return '\b';
+      case CharCodes.t:
+        return '\t';
+      case CharCodes.n:
+        return '\n';
+      case CharCodes.r:
+        return '\r';
+      case CharCodes.singleQuote:
+        return "'";
+      case CharCodes.doubleQuote:
+        return '"';
+      default:
+        return '';
+    }
+  }
 }
 
 export function lexAll(s: string) {

src/parse.ts

@@ -36,6 +36,8 @@ export function parse(lexer: Lexer): Module {
       return { kind: Node.Identifier, text: lexer.text(), pos };
     } else if (tryParseToken(Token.Literal)) {
       return { kind: Node.Literal, value: +lexer.text(), pos };
+    } else if (tryParseToken(Token.String)) {
+      return { kind: Node.Literal, value: lexer.text(), pos };
     }
     error(
       pos,

src/types.ts

@@ -10,6 +10,7 @@ export enum Token {
   Semicolon = 'Semicolon',
   Colon = 'Colon',
   Whitespace = 'Whitespace',
+  String = 'String',
   Unknown = 'Unknown',
   BOF = 'BOF',
   EOF = 'EOF',
@@ -49,7 +50,7 @@ export type Identifier = Location & {
 
 export type Literal = Location & {
   kind: Node.Literal;
-  value: number;
+  value: number | string;
 };
 
 export type Assignment = Location & {
@@ -93,3 +94,13 @@ export type Module = {
 };
 
 export type Type = { id: string };
+
+export enum CharCodes {
+  b = 98,
+  t = 116,
+  n = 110,
+  r = 114,
+  singleQuote = 39,
+  doubleQuote = 34,
+  backslash = 92,
+}

tests/singleTypedVar.ts

@@ -1 +1,2 @@
 var s: string = 1;
+var n: number = 'test';

tests/stringLiteral.ts

@@ -0,0 +1,2 @@
+var singleQuote = 'singleQuote';
+var doubleQuote = 'double\'Quote';