First version of object access dot operator

baransu · baransu · commit 00df71d2e264 · 2017-12-20T18:07:11.000+01:00
diff --git a/src/Syntax.js b/src/Syntax.js
@@ -13,6 +13,7 @@ const Syntax = {
   Punctuator: "Punctuator",
   Identifier: "Identifier",
   ArraySubscript: "ArraySubscript",
+  AccessIdentifier: "AccessIdentifier",
   Constant: "Constant",
   Type: "Type",
   Declaration: "Declaration",
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/expression.js b/src/parser/expression.js
@@ -3,6 +3,7 @@ import Syntax from "../Syntax";
 import operator from "./operator";
 import constant from "./constant";
 import stringLiteral from "./string-literal";
+import accessIdentifier from "./access-identifier";
 import builtInType from "./builtin-type";
 import { getAssociativty, getPrecedence } from "./introspection";
 import maybeIdentifier from "./maybe-identifier";
@@ -174,6 +175,19 @@ break;
         eatFunctionCall = true;
         operands.push(maybeIdentifier(ctx));
         break;
+      case Syntax.AccessIdentifier:
+        // We're manually creating StringLiteral from AccessIdentifier
+        operators.push({
+          type: "Punctuator",
+          value: "[",
+          start: {},
+          end: {}
+        });
+        operands.push(accessIdentifier(ctx));
+        eatUntil(isLSqrBracket);
+        consume();
+        eatFunctionCall = false;
+        break;
       case Syntax.StringLiteral:
         eatFunctionCall = false;
         operands.push(stringLiteral(ctx));
diff --git a/src/parser/maybe-assignment.js b/src/parser/maybe-assignment.js
@@ -1,18 +1,18 @@
 //@flow
-import Syntax from "../Syntax";
-import maybeIdentifier from "./maybe-identifier";
-import memoryStore from "./memory-store";
-import expression from "./expression";
-import type Context from "./context";
-import type { NodeType } from "../flow/types";
+import Syntax from '../Syntax';
+import maybeIdentifier from './maybe-identifier';
+import memoryStore from './memory-store';
+import expression from './expression';
+import type Context from './context';
+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 { type, value } = ctx.stream.peek();
+  if (value === '[' || type === Syntax.AccessIdentifier) {
+    return memoryStore(ctx);
+  }
 
   const target = maybeIdentifier(ctx);
   if (target.Type === Syntax.FunctionCall) {
diff --git a/src/tokenizer/access-identifier/index.js b/src/tokenizer/access-identifier/index.js
@@ -0,0 +1,14 @@
+// @flow
+
+import token from "../token";
+import Syntax from "../../Syntax";
+import { maybeIdentifier } from "../identifier";
+
+const maybeAccessIdentifier = char => {
+  if (char === ".") {
+    return maybeIdentifier;
+  }
+  return null;
+};
+
+export default token(maybeAccessIdentifier, Syntax.AccessIdentifier);
diff --git a/src/tokenizer/identifier/index.js b/src/tokenizer/identifier/index.js
@@ -1,15 +1,15 @@
-import token from "../token";
-import punctuator from "../punctuator";
-import constant from "../constant";
-import string from "../string";
-import Syntax from "../../Syntax";
+import token from '../token';
+import punctuator from '../punctuator';
+import constant from '../constant';
+import string from '../string';
+import Syntax from '../../Syntax';
 
-const parse = char => {
+export 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
@@ -1,6 +1,7 @@
 import Stream from "../utils/stream";
 import punctuator from "./punctuator";
 import constant from "./constant";
+import accessIdentifier from "./access-identifier";
 import identifier from "./identifier";
 import keyword from "./keyword";
 import string from "./string";
@@ -11,6 +12,7 @@ class Tokenizer {
   constructor(
     stream,
     parsers = [
+      accessIdentifier,
       punctuator,
       constant,
       identifier,
