expression parser #2 (#207)

* test(expression-parser): initial tests for ForOfStatement

* feat(kernel): add decoratable interface to support strongly typed decorators

* chore(tslint): disable no-this-assignment and interface-name rules

* fix(kernel): fix decorated interface

* feat(binding): add @connectable decorator back in (strongly typed)

refactor(binding): cleanup/shuffle some interfaces accordingly

* chore(ast): update typings for connectable binding

* fix(binding): wrap updatetarget/updatesource so vCurrent BBs work again

* feat(all): implement InterpolationBinding

* fix(expression-parser): fix differentation for caching of expressions/interpolations

* fix(iterator-binding): correctly compile and render ForOfStatement

refactor(template-compiler): cleanup/inline instruction classes

* feat(unparser): implement interpolation unparsing

* perf(expression-parser): remove unreachable branch

* test(expression-parser): add interpolation tests

* test(expression-parser): explicitly verify precedence

* chore(all): turn off emitDecoratorMetadata in jit and runtime to make sure we don't use it

packages/debug/src/binding/unparser.ts

@@ -226,17 +226,55 @@ export class Unparser implements AST.IVisitor<void> {
     }
   }
 
-  public visitArrayBindingPattern(expr: AST.ArrayBindingPattern): string { throw new Error('visitArrayBindingPattern'); }
+  public visitArrayBindingPattern(expr: AST.ArrayBindingPattern): void {
+    const elements = expr.elements;
+    this.text += '[';
+    for (let i = 0, length = elements.length; i < length; ++i) {
+      if (i !== 0) {
+        this.text += ',';
+      }
+      elements[i].accept(this);
+    }
+    this.text += ']';
+  }
 
-  public visitObjectBindingPattern(expr: AST.ObjectBindingPattern): string { throw new Error('visitObjectBindingPattern'); }
+  public visitObjectBindingPattern(expr: AST.ObjectBindingPattern): void {
+    const keys = expr.keys;
+    const values = expr.values;
+    this.text += '{';
+    for (let i = 0, length = keys.length; i < length; ++i) {
+      if (i !== 0) {
+        this.text += ',';
+      }
+      this.text += `'${keys[i]}':`;
+      values[i].accept(this);
+    }
+    this.text += '}';
+  }
 
-  public visitBindingIdentifier(expr: AST.BindingIdentifier): string { throw new Error('visitBindingIdentifier'); }
+  public visitBindingIdentifier(expr: AST.BindingIdentifier): void {
+    this.text += expr.name;
+  }
 
-  public visitHtmlLiteral(expr: AST.HtmlLiteral): string { throw new Error('visitHtmlLiteral'); }
+  public visitHtmlLiteral(expr: AST.HtmlLiteral): void { throw new Error('visitHtmlLiteral'); }
 
-  public visitForOfStatement(expr: AST.ForOfStatement): string { throw new Error('visitForOfStatement'); }
+  public visitForOfStatement(expr: AST.ForOfStatement): void {
+    expr.declaration.accept(this);
+    this.text += ' of ';
+    expr.iterable.accept(this);
+  }
 
-  public visitInterpolation(expr: AST.Interpolation): string { throw new Error('visitInterpolation'); }
+  public visitInterpolation(expr: AST.Interpolation): void {
+    const { parts, expressions } = expr;
+    const length = expressions.length;
+    this.text += '${';
+    this.text += parts[0];
+    for (let i = 0; i < length; i++) {
+      expressions[i].accept(this);
+      this.text += parts[i + 1];
+    }
+    this.text += '}';
+  }
 
   private writeArgs(args: ReadonlyArray<AST.IExpression>): void {
     this.text += '(';
@@ -332,17 +370,27 @@ export class Serializer implements AST.IVisitor<string> {
     return `{"type":"BindingBehavior","name":"${expr.name}","expression":${expr.expression.accept(this)},"args":${this.serializeExpressions(expr.args)}}`;
   }
 
-  public visitArrayBindingPattern(expr: AST.ArrayBindingPattern): string { throw new Error('visitArrayBindingPattern'); }
+  public visitArrayBindingPattern(expr: AST.ArrayBindingPattern): string {
+    return `{"type":"ArrayBindingPattern","elements":${this.serializeExpressions(expr.elements)}}`;
+  }
 
-  public visitObjectBindingPattern(expr: AST.ObjectBindingPattern): string { throw new Error('visitObjectBindingPattern'); }
+  public visitObjectBindingPattern(expr: AST.ObjectBindingPattern): string {
+    return `{"type":"ObjectBindingPattern","keys":${serializePrimitives(expr.keys)},"values":${this.serializeExpressions(expr.values)}}`;
+  }
 
-  public visitBindingIdentifier(expr: AST.BindingIdentifier): string { throw new Error('visitBindingIdentifier'); }
+  public visitBindingIdentifier(expr: AST.BindingIdentifier): string {
+    return `{"type":"BindingIdentifier","name":"${expr.name}"}`;
+  }
 
   public visitHtmlLiteral(expr: AST.HtmlLiteral): string { throw new Error('visitHtmlLiteral'); }
 
-  public visitForOfStatement(expr: AST.ForOfStatement): string { throw new Error('visitForOfStatement'); }
+  public visitForOfStatement(expr: AST.ForOfStatement): string {
+    return `{"type":"ForOfStatement","declaration":${expr.declaration.accept(this)},"iterable":${expr.iterable.accept(this)}}`;
+  }
 
-  public visitInterpolation(expr: AST.Interpolation): string { throw new Error('visitInterpolation'); }
+  public visitInterpolation(expr: AST.Interpolation): string {
+    return `{"type":"Interpolation","cooked":${serializePrimitives(expr.parts)},"expressions":${this.serializeExpressions(expr.expressions)}}`;
+  }
 
   // tslint:disable-next-line:no-any
   private serializeExpressions(args: ReadonlyArray<AST.IExpression>): string {

packages/jit/src/binding-command.ts

@@ -1,4 +1,3 @@
-// tslint:disable:interface-name
 import { Constructable, IContainer, Registration, Writable } from '@aurelia/kernel';
 import { BindingType, IExpressionParser, IResourceKind, IResourceType, ITemplateSource, TargetedInstruction } from '@aurelia/runtime';
 import {
@@ -12,7 +11,8 @@ import {
   SetPropertyInstruction,
   ToViewBindingInstruction,
   TriggerBindingInstruction,
-  TwoWayBindingInstruction
+  TwoWayBindingInstruction,
+  IteratorBindingInstruction
 } from '.';
 
 export interface IBindingCommandSource {
@@ -190,7 +190,7 @@ export class ForBindingCommand implements IBindingCommand {
       instructions: []
     };
     return new HydrateTemplateController(src, 'repeat', [
-      new ToViewBindingInstruction(this.parser.parse($symbol.rawValue, BindingType.ForCommand), 'items'),
+      new IteratorBindingInstruction(this.parser.parse($symbol.rawValue, BindingType.ForCommand), 'items'),
       new SetPropertyInstruction('item', 'local')
     // tslint:disable-next-line:align
     ], false);

packages/jit/src/expression-parser.ts

@@ -597,9 +597,6 @@ function parseInterpolation(state: ParserState): Interpolation {
       default:
         result += String.fromCharCode(state.currentChar);
     }
-    if (state.index >= length) {
-      break;
-    }
     nextChar(state);
   }
   if (expressions.length) {