Update compiler.ts

Author: bartdesmet

src/core/expressions/compiler.ts

@@ -116,10 +116,29 @@ class Expression {
   static Invoke(expression: Expression, ...args: Expression[]): InvocationExpression {
     return new InvocationExpression(expression, args);
   }
+
+  static New(typeName: string, ...args: Expression[]): NewExpression {
+    return new NewExpression(typeName, args);
+  }
+
+  static Call(obj: Expression, methodName: string, ...args: Expression[]): CallExpression {
+    return new CallExpression(obj, methodName, args);
+  }
+
+  static Member(obj: Expression, memberName: string): MemberExpression {
+    return new MemberExpression(obj, memberName);
+  }
+
+  static Index(obj: Expression, ...args: Expression[]): IndexExpression {
+    return new IndexExpression(obj, args);
+  }
 }
 
 class ExpressionVisitor {
   Visit(node: Expression): Expression {
+    if (node === null) {
+      return null;
+    }
     return node.Accept(this);
   }
 
@@ -151,6 +170,22 @@ class ExpressionVisitor {
     return node.Update(this.Visit(node.expression), this.VisitMany(node.args));
   }
 
+  VisitCall(node: CallExpression): Expression {
+    return node.Update(this.Visit(node.obj), this.VisitMany(node.args));
+  }
+
+  VisitNew(node: NewExpression): Expression {
+    return node.Update(this.VisitMany(node.args));
+  }
+
+  VisitMember(node: MemberExpression): Expression {
+    return node.Update(this.Visit(node.obj));
+  }
+
+  VisitIndex(node: IndexExpression): Expression {
+    return node.Update(this.Visit(node.obj), this.VisitMany(node.args));
+  }
+
   VisitMany<T extends Expression>(nodes: T[]): T[] {
     var res = new Array<T>(nodes.length);
 
@@ -325,6 +360,7 @@ class LambdaExpression<T extends Function> extends Expression {
     var comp = new LambdaCompiler();
     comp.Visit(this);
     var code = comp.code;
+    code = code.replace(/\"/g, "\\\""); // TODO: more escape sequences
     code = "new Function(\"return " + code + ";\")";
     code = code.replace(/\r?\n|\r/g, "");
     alert(code);
@@ -363,6 +399,136 @@ class InvocationExpression extends Expression {
   }
 }
 
+class CallExpression extends Expression {
+  _expression: Expression;
+  _method: string;
+  _args: Expression[];
+
+  constructor(expression: Expression, methodName: string, args: Expression[]) {
+    super(ExpressionType.Call);
+    this._expression = expression;
+    this._method = methodName;
+    this._args = args;
+  }
+
+  get obj(): Expression {
+    return this._expression;
+  }
+
+  get method(): string {
+    return this._method;
+  }
+
+  get args(): Expression[] {
+    return this._args;
+  }
+
+  Accept(visitor: ExpressionVisitor): Expression {
+    return visitor.VisitCall(this);
+  }
+
+  Update(expression: Expression, args: Expression[]): CallExpression {
+    if (expression !== this._expression || args !== this._args) {
+      return new CallExpression(expression, this._method, args);
+    }
+
+    return this;
+  }
+}
+
+class IndexExpression extends Expression {
+  _expression: Expression;
+  _args: Expression[];
+
+  constructor(expression: Expression, args: Expression[]) {
+    super(ExpressionType.Index);
+    this._expression = expression;
+    this._args = args;
+  }
+
+  get obj(): Expression {
+    return this._expression;
+  }
+
+  get args(): Expression[] {
+    return this._args;
+  }
+
+  Accept(visitor: ExpressionVisitor): Expression {
+    return visitor.VisitIndex(this);
+  }
+
+  Update(expression: Expression, args: Expression[]): IndexExpression {
+    if (expression !== this._expression || args !== this._args) {
+      return new IndexExpression(expression, args);
+    }
+
+    return this;
+  }
+}
+
+class NewExpression extends Expression {
+  _type: string;
+  _args: Expression[];
+
+  constructor(typeName: string, args: Expression[]) {
+    super(ExpressionType.New);
+    this._type = typeName;
+    this._args = args;
+  }
+
+  get type(): string {
+    return this._type;
+  }
+
+  get args(): Expression[] {
+    return this._args;
+  }
+
+  Accept(visitor: ExpressionVisitor): Expression {
+    return visitor.VisitNew(this);
+  }
+
+  Update(args: Expression[]): NewExpression {
+    if (args !== this._args) {
+      return new NewExpression(this._type, args);
+    }
+
+    return this;
+  }
+}
+
+class MemberExpression extends Expression {
+  _obj: Expression;
+  _member: string;
+
+  constructor(obj: Expression, memberName: string) {
+    super(ExpressionType.Member);
+    this._obj = obj;
+    this._member = memberName;
+  }
+
+  get obj(): Expression {
+    return this._obj;
+  }
+
+  get member(): string {
+    return this._member;
+  }
+
+  Accept(visitor: ExpressionVisitor): Expression {
+    return visitor.VisitMember(this);
+  }
+
+  Update(obj: Expression): MemberExpression {
+    if (obj !== this._obj) {
+      return new MemberExpression(obj, this._member);
+    }
+
+    return this;
+  }
+}
+
 class LambdaCompiler extends ExpressionVisitor {
   _stack: string[];
 
@@ -385,10 +551,13 @@ class LambdaCompiler extends ExpressionVisitor {
       value = "\"" + node.value + "\""; // TODO: escape characters
     }
     else if (node.value instanceof Array) {
-      value = "[" + node.value + "]"; // TODO: proper formatting
+      value = JSON.stringify(node.value);
+    }
+    else if (node.value === undefined) {
+      value = "undefined";
     }
     else {
-      value = node.value.toString();
+      value = node.value.toString(); // TODO
     }
 
     this._stack.push(value);
@@ -417,7 +586,7 @@ class LambdaCompiler extends ExpressionVisitor {
         break;
     }
 
-    var res = i + "" + o;
+    var res = "(" + i + "" + o + ")";
     this._stack.push(res);
 
     return node;
@@ -538,11 +707,36 @@ class LambdaCompiler extends ExpressionVisitor {
   }
 
   VisitInvoke(node: InvocationExpression): Expression {
-    this.VisitMany(node.args);
     this.Visit(node.expression);
+    this.VisitMany(node.args);
+
+    var n = node.args.length;
+    var args = new Array<string>(n);
+    for (var i = 0; i < n; i++) {
+      args[n - i - 1] = this._stack.pop();
+    }
+
+    var argList = args.join(", ");
 
     var func = this._stack.pop();
 
+    var res = func + "(" + argList + ")";
+
+    this._stack.push(res);
+
+    return node;
+  }
+
+  VisitCall(node: CallExpression): Expression {
+    var res = "";
+
+    if (node.obj !== null) {
+      this.Visit(node.obj);
+      res = this._stack.pop() + ".";
+    }
+
+    this.VisitMany(node.args);
+
     var n = node.args.length;
     var args = new Array<string>(n);
     for (var i = 0; i < n; i++) {
@@ -551,7 +745,61 @@ class LambdaCompiler extends ExpressionVisitor {
 
     var argList = args.join(", ");
 
-    var res = func + "(" + argList + ")";
+    res += node.method + "(" + argList + ")";
+
+    this._stack.push(res);
+
+    return node;
+  }
+
+  VisitNew(node: NewExpression): Expression {
+    this.VisitMany(node.args);
+
+    var n = node.args.length;
+    var args = new Array<string>(n);
+    for (var i = 0; i < n; i++) {
+      args[n - i - 1] = this._stack.pop();
+    }
+
+    var argList = args.join(", ");
+
+    var res = "new " + node.type + "(" + argList + ")";
+
+    this._stack.push(res);
+
+    return node;
+  }
+
+  VisitMember(node: MemberExpression): Expression {
+    var res = "";
+
+    if (node.obj !== null) {
+      this.Visit(node.obj);
+      res = this._stack.pop() + ".";
+    }
+
+    res += node.member;
+
+    this._stack.push(res);
+
+    return node;
+  }
+
+  VisitIndex(node: IndexExpression): Expression {
+    this.Visit(node.obj);
+    var res = this._stack.pop();
+
+    this.VisitMany(node.args);
+
+    var n = node.args.length;
+    var args = new Array<string>(n);
+    for (var i = 0; i < n; i++) {
+      args[n - i - 1] = this._stack.pop();
+    }
+
+    var argList = args.join(", ");
+
+    res += "[" + argList + "]";
 
     this._stack.push(res);
 
@@ -629,6 +877,10 @@ enum ExpressionType {
   UnaryPlus,
   OnesComplement,
   Condition,
+  New,
+  Call,
+  Member,
+  Index,
 }
 
 class Binder extends ExpressionVisitor {
@@ -669,8 +921,16 @@ class Binder extends ExpressionVisitor {
   }
 }
 
+var resources =
+  {
+    "my://xs": [1, 2, 3, 4, 5],
+    "my://ss": ["bar", "foo", "qux"],
+    "rx://operators/filter": function (xs: any[], f: (any) => boolean) { return xs.filter(f); },
+    "rx://operators/map": function (xs: any[], f: (any) => any) { return xs.map(f); },
+  };
+
 var x = Expression.Parameter("x");
-var f =
+var f1 =
   Expression.Invoke(
     Expression.Parameter("rx://operators/map"),
     Expression.Invoke(
@@ -696,22 +956,28 @@ var f =
       )
     );
 
-var fvs = new FreeVariableScanner();
-fvs.Visit(f);
-
-var unbound = fvs.result;
-
-var resources =
-  {
-    "my://xs": [1, 2, 3, 4, 5],
-    "rx://operators/filter": function (xs: any[], f: (any) => boolean) { return xs.filter(f); },
-    "rx://operators/map": function (xs: any[], f: (any) => any) { return xs.map(f); },
-  };
+var f2 =
+  Expression.Invoke(
+    Expression.Parameter("rx://operators/map"),
+    Expression.Parameter("my://ss"),
+    Expression.Lambda<(string) => string>(
+      Expression.Call(
+        x,
+        "substring",
+        Expression.Constant(1)
+        ),
+      x
+      )
+    );
 
 var binder = new Binder(resources);
-var bound = Expression.Lambda<() => number[]>(binder.Visit(f));
 
-var compiled = bound.Compile();
-var res = compiled();
-alert(res.join(", "));
+var b1 = Expression.Lambda<() => number[]>(binder.Visit(f1));
+var c1 = b1.Compile();
+var r1 = c1();
+alert(r1.join(", "));
 
+var b2 = Expression.Lambda<() => string[]>(binder.Visit(f2));
+var c2 = b2.Compile();
+var r2 = c2();
+alert(r2.join(", "));