ballercat · baransu · Dec 20, 2017 · Dec 21, 2017 · ballercat · Dec 21, 2017
diff --git a/src/__tests__/object-literal-spec.js b/src/__tests__/object-literal-spec.js
@@ -6,6 +6,24 @@ const compileAndRun = (src, imports) =>
 const outputIs = (t, value) => result =>
   t.is(result.instance.exports.test(), value);
 
+test("dot operator", t => {
+  return compileAndRun(
+    `
+  const memory: Memory = { 'initial': 1 };
+
+  type TestType = { 'foo': i32, 'bar': i32 };
+
+  export function test(): i32 {
+    let obj: TestType = 0;
+
+    obj["foo"] = 42;
+    obj.bar = 20;
+
+    return obj.foo + obj.bar;
+  }`
+  ).then(outputIs(t, 62));
+});
+
 test("types and assignment", t => {
   return compileAndRun(
     `

diff --git a/src/parser/access-identifier.js b/src/parser/access-identifier.js
@@ -0,0 +1,13 @@
+//@flow
+import Syntax from "../Syntax";
+import type Context from "./context";
+import type { Node } from "../flow/types";
+
+export function accessIdentifier(ctx: Context): Node {
+  const node = ctx.startNode();
+  // We're removing first character which is access dot operator
+  node.value = ctx.token.value.substring(1, ctx.token.value.length);
+  return ctx.endNode(node, Syntax.StringLiteral);
+}
+
+export default accessIdentifier;
diff --git a/src/parser/array-subscript.js b/src/parser/array-subscript.js
@@ -1,16 +1,16 @@
 // @flow
-import invariant from "invariant";
-import Syntax from "../Syntax";
+import invariant from 'invariant';
+import Syntax from '../Syntax';
 import metadata, {
   OBJECT_KEY_TYPES,
   TYPE_OBJECT,
   TYPE_ARRAY,
   TYPE_USER
-} from "./metadata";
-import { findLocalIndex, findGlobalIndex } from "./introspection";
+} from './metadata';
+import { findLocalIndex, findGlobalIndex } from './introspection';
 
-import type { TokenType, NodeType, MetadataType } from "../flow/types";
-import type Context from "./context";
+import type { TokenType, NodeType, MetadataType } from '../flow/types';
+import type Context from './context';
 
 export const nodeMetaType = (targetNode: NodeType): ?MetadataType =>
   metadata.get(TYPE_USER, targetNode) || metadata.get(TYPE_ARRAY, targetNode);
@@ -54,7 +54,7 @@ export const patchStringSubscript = (
     const absoluteByteOffset = byteOffsetsByKey[key];
     return [
       params[0],
-      ctx.makeNode({ value: absoluteByteOffset, type: "i32" }, Syntax.Constant)
+      ctx.makeNode({ value: absoluteByteOffset, type: 'i32' }, Syntax.Constant)
     ];
   }
   return params;

diff --git a/src/parser/expression.js b/src/parser/expression.js
@@ -5,7 +5,7 @@ import constant from "./constant";
 import stringLiteral from "./string-literal";
 import builtInType from "./builtin-type";
 import { getAssociativty, getPrecedence } from "./introspection";
-import maybeIdentifier from "./maybe-identifier";
+import maybeIdentifier, { accessIdentifier } from "./maybe-identifier";
 import { PRECEDENCE_FUNCTION_CALL } from "./precedence";
 import type Context from "./context";
 import type { Node, Token } from "../flow/types";
@@ -21,6 +21,7 @@ const isLBracket = valueIs("(");
 const isLSqrBracket = valueIs("[");
 const isTStart = valueIs("?");
 const isBlockStart = valueIs("{");
+
 export const isPunctuatorAndNotBracket = (t: ?Token) =>
   t && t.type === Syntax.Punctuator && t.value !== "]" && t.value !== ")";
 
@@ -62,15 +63,18 @@ const expression = (
       getAssociativty(previous) === "left"
     ) {
       if (value === "," && previous.type === Syntax.FunctionCall) {
-break;
-}
+        break;
+      }
       // if (value === ":" && previous.type === Syntax.Pair) break;
       consume();
     }
   };
 
   const processPunctuator = () => {
     switch (ctx.token.value) {
+      case ".":
+        operators.push(ctx.token);
+        break;
       case "(":
         depth++;
         // Function call.
@@ -91,12 +95,12 @@ break;
             operands.push(expr);
           }
           return false;
-        } 
-          if (ctx.token.value === "?") {
-            inTernary = true;
-          }
-          operators.push(ctx.token);
-        
+        }
+        if (ctx.token.value === "?") {
+          inTernary = true;
+        }
+        operators.push(ctx.token);
+
         break;
       case "[":
         depth++;
@@ -171,8 +175,18 @@ break;
         operands.push(constant(ctx));
         break;
       case Syntax.Identifier:
-        eatFunctionCall = true;
-        operands.push(maybeIdentifier(ctx));
+        const prev = last(operators);
+        if (prev && prev.value === ".") {
+          operators.pop();
+          operators.push({ ...prev, value: "[" });
+          operands.push(accessIdentifier(ctx));
+          eatUntil(isLSqrBracket);
+          consume();
+          eatFunctionCall = false;
+        } else {
+          operands.push(maybeIdentifier(ctx));
+          eatFunctionCall = true;
+        }
         break;
       case Syntax.StringLiteral:
         eatFunctionCall = false;
@@ -207,8 +221,8 @@ break;
   }
 
   while (operators.length) {
-consume();
-}
+    consume();
+  }
 
   // Should be a node
   return operands.pop();

diff --git a/src/parser/maybe-assignment.js b/src/parser/maybe-assignment.js
@@ -9,10 +9,10 @@ import type { NodeType } from "../flow/types";
 // It is easier to parse assignment this way as we need to maintain a valid type
 // through out the right-hand side of the expression
 function maybeAssignment(ctx: Context): NodeType {
-  const nextValue = ctx.stream.peek().value;
-  if (nextValue === "[") {
-return memoryStore(ctx);
-}
+  const { value } = ctx.stream.peek();
+  if (value === "[" || value === ".") {
+    return memoryStore(ctx);
+  }
 
   const target = maybeIdentifier(ctx);
   if (target.Type === Syntax.FunctionCall) {

diff --git a/src/parser/maybe-identifier.js b/src/parser/maybe-identifier.js
@@ -11,6 +11,11 @@ import {
   findUserTypeIndex
 } from "./introspection";
 
+export const accessIdentifier = (ctx: Context): Node => {
+  const node = ctx.startNode();
+  return ctx.endNode(node, Syntax.StringLiteral);
+};
+
 // Maybe identifier, maybe function call
 const maybeIdentifier = (ctx: Context): Node => {
   const node = ctx.startNode();

diff --git a/src/tokenizer/identifier/index.js b/src/tokenizer/identifier/index.js
@@ -4,12 +4,12 @@ import constant from "../constant";
 import string from "../string";
 import Syntax from "../../Syntax";
 
-const parse = char => {
+const maybeIdentifier = char => {
   // Don't allow these
-  if (!string(char) && !punctuator(char) && !constant(char) && char !== " ")    {
-return parse;
-}
+  if (!string(char) && !punctuator(char) && !constant(char) && char !== " ") {
+    return maybeIdentifier;
+  }
   return null;
 };
-const tokenParser = token(parse, Syntax.Identifier);
-export default tokenParser;
+
+export default token(maybeIdentifier, Syntax.Identifier);
diff --git a/src/tokenizer/index.js b/src/tokenizer/index.js
@@ -20,10 +20,10 @@ class Tokenizer {
       comments
     ]
   ) {
-    if (!(stream instanceof Stream))      {
-this.die(`Tokenizer expected instance of Stream in constructor.
+    if (!(stream instanceof Stream)) {
+      this.die(`Tokenizer expected instance of Stream in constructor.
                 Instead received ${JSON.stringify(stream)}`);
-}
+    }
     this.stream = stream;
     this.tokens = [];
     this.pos = 0;
@@ -58,8 +58,8 @@ this.die(`Tokenizer expected instance of Stream in constructor.
 
     // If we fell off the end then bail out
     if (Stream.eof(value)) {
-return null;
-}
+      return null;
+    }
 
     const token = this.token(value, matchers);
     token.start = start;
@@ -69,16 +69,16 @@ return null;
     };
     // Comments are ignored for now
     if (token.type !== comments.type) {
-this.tokens.push(token);
-}
+      this.tokens.push(token);
+    }
 
     return this.tokens[this.pos++];
   }
 
   match(char, parsers) {
     if (char == null) {
-return parsers;
-}
+      return parsers;
+    }
 
     return parsers.map(parse => parse(char)).filter(p => p);
   }
@@ -94,13 +94,13 @@ return parsers;
     if (parsers.length > 1) {
       parsers = parsers.filter(parser => (parser.strict ? parser.leaf : true));
       if (parsers.length > 1) {
-parsers = parsers.filter(parser => parser.strict);
-}
+        parsers = parsers.filter(parser => parser.strict);
+      }
     }
 
     if (parsers.length === 1) {
-token.type = parsers[0].type;
-}
+      token.type = parsers[0].type;
+    }
 
     return token;
   }
@@ -109,15 +109,15 @@ token.type = parsers[0].type;
    * Seek Stream until next non-whitespace character. Can end in eof/eol
    */
   seekNonWhitespace() {
-    while (this.stream.peek() && Stream.whitespace(this.stream.peek()))      {
-this.stream.next();
-}
+    while (this.stream.peek() && Stream.whitespace(this.stream.peek())) {
+      this.stream.next();
+    }
   }
 
   parse() {
     while (!Stream.eof(this.stream.peek())) {
-this.next();
-}
+      this.next();
+    }
 
     return this.tokens;
   }