feat(change_detection): change proto change detectors to coalesce records

modules/change_detection/src/change_detection_jit_generator.es6

@@ -296,7 +296,7 @@ export class ChangeDetectorJITGenerator {
 
     switch (r.mode) {
       case RECORD_TYPE_SELF:
-        throw new BaseException("Cannot evaluate self");
+        return assignmentTemplate(newValue, context);
 
       case RECORD_TYPE_CONST:
         return `${newValue} = ${this.genLiteral(r.funcOrValue)}`;

modules/change_detection/src/coalesce.js

@@ -0,0 +1,88 @@
+import {isPresent} from 'facade/lang';
+import {List, ListWrapper, Map, MapWrapper} from 'facade/collection';
+import {RECORD_TYPE_SELF, ProtoRecord} from './proto_change_detector';
+
+/**
+ * Removes "duplicate" records. It assuming that record evaluation does not
+ * have side-effects.
+ *
+ * Records that are not last in bindings are removed and all the indices
+ * of the records that depend on them are updated.
+ *
+ * Records that are last in bindings CANNOT be removed, and instead are
+ * replaced with very cheap SELF records.
+ */
+export function coalesce(records:List<ProtoRecord>):List<ProtoRecord> {
+  var res = ListWrapper.create();
+  var indexMap = MapWrapper.create();
+
+  for (var i = 0; i < records.length; ++i) {
+    var r = records[i];
+    var record = _replaceIndices(r, res.length + 1, indexMap);
+    var matchingRecord = _findMatching(record, res);
+
+    if (isPresent(matchingRecord) && record.lastInBinding) {
+      ListWrapper.push(res, _selfRecord(record, matchingRecord.selfIndex, res.length + 1));
+      MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex);
+
+    } else if (isPresent(matchingRecord) && !record.lastInBinding) {
+      MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex);
+
+    } else {
+      ListWrapper.push(res, record);
+      MapWrapper.set(indexMap, r.selfIndex, record.selfIndex);
+    }
+  }
+
+  return res;
+}
+
+function _selfRecord(r:ProtoRecord, contextIndex:number, selfIndex:number):ProtoRecord {
+  return new ProtoRecord(
+    RECORD_TYPE_SELF,
+    "self",
+    null,
+    [],
+    r.fixedArgs,
+    contextIndex,
+    selfIndex,
+    r.bindingMemento,
+    r.groupMemento,
+    r.expressionAsString,
+    r.lastInBinding,
+    r.lastInGroup
+  );
+}
+
+function _findMatching(r:ProtoRecord, rs:List<ProtoRecord>){
+  return ListWrapper.find(rs, (rr) =>
+    rr.mode === r.mode &&
+    rr.funcOrValue === r.funcOrValue &&
+    rr.contextIndex === r.contextIndex &&
+    ListWrapper.equals(rr.args, r.args)
+  );
+}
+
+function _replaceIndices(r:ProtoRecord, selfIndex:number, indexMap:Map) {
+  var args = ListWrapper.map(r.args, (a) => _map(indexMap, a));
+  var contextIndex = _map(indexMap, r.contextIndex);
+  return new ProtoRecord(
+    r.mode,
+    r.name,
+    r.funcOrValue,
+    args,
+    r.fixedArgs,
+    contextIndex,
+    selfIndex,
+    r.bindingMemento,
+    r.groupMemento,
+    r.expressionAsString,
+    r.lastInBinding,
+    r.lastInGroup
+  );
+}
+
+function _map(indexMap:Map, value:number) {
+  var r = MapWrapper.get(indexMap, value)
+  return isPresent(r) ? r : value;
+}

modules/change_detection/src/dynamic_change_detector.js

@@ -100,7 +100,7 @@ export class DynamicChangeDetector extends AbstractChangeDetector {
   _calculateCurrValue(proto:ProtoRecord) {
     switch (proto.mode) {
       case RECORD_TYPE_SELF:
-        throw new BaseException("Cannot evaluate self");
+        return this._readContext(proto);
 
       case RECORD_TYPE_CONST:
         return proto.funcOrValue;

modules/change_detection/src/proto_change_detector.js

@@ -31,6 +31,7 @@ import {ChangeDetectorJITGenerator} from './change_detection_jit_generator';
 
 import {ArrayChanges} from './array_changes';
 import {KeyValueChanges} from './keyvalue_changes';
+import {coalesce} from './coalesce';
 
 export const RECORD_TYPE_SELF = 0;
 export const RECORD_TYPE_CONST = 1;
@@ -66,7 +67,9 @@ export class ProtoRecord {
               selfIndex:number,
               bindingMemento:any,
               groupMemento:any,
-              expressionAsString:string) {
+              expressionAsString:string,
+              lastInBinding:boolean,
+              lastInGroup:boolean) {
 
     this.mode = mode;
     this.name = name;
@@ -77,8 +80,8 @@ export class ProtoRecord {
     this.selfIndex = selfIndex;
     this.bindingMemento = bindingMemento;
     this.groupMemento = groupMemento;
-    this.lastInBinding = false;
-    this.lastInGroup = false;
+    this.lastInBinding = lastInBinding;
+    this.lastInGroup = lastInGroup;
     this.expressionAsString = expressionAsString;
   }
 }
@@ -91,9 +94,11 @@ export class ProtoChangeDetector  {
 }
 
 export class DynamicProtoChangeDetector extends ProtoChangeDetector {
+  _records:List<ProtoRecord>;
   _recordBuilder:ProtoRecordBuilder;
 
   constructor() {
+    this._records = null;
     this._recordBuilder = new ProtoRecordBuilder();
   }
 
@@ -102,8 +107,15 @@ export class DynamicProtoChangeDetector extends ProtoChangeDetector {
   }
 
   instantiate(dispatcher:any, formatters:Map) {
-    var records = this._recordBuilder.records;
-    return new DynamicChangeDetector(dispatcher, formatters, records);
+    this._createRecordsIfNecessary();
+    return new DynamicChangeDetector(dispatcher, formatters, this._records);
+  }
+
+  _createRecordsIfNecessary() {
+    if (isBlank(this._records)) {
+      var records = this._recordBuilder.records;
+      this._records = coalesce(records);
+    }
   }
 }
 
@@ -113,6 +125,7 @@ export class JitProtoChangeDetector extends ProtoChangeDetector {
   _recordBuilder:ProtoRecordBuilder;
 
   constructor() {
+    this._factory = null;
     this._recordBuilder = new ProtoRecordBuilder();
   }
 
@@ -128,7 +141,7 @@ export class JitProtoChangeDetector extends ProtoChangeDetector {
   _createFactoryIfNecessary() {
     if (isBlank(this._factory)) {
       var c = _jitProtoChangeDetectorClassCounter++;
-      var records = this._recordBuilder.records;
+      var records = coalesce(this._recordBuilder.records);
       var typeName = `ChangeDetector${c}`;
       this._factory = new ChangeDetectorJITGenerator(typeName, records).generate();
     }
@@ -273,7 +286,7 @@ class _ConvertAstIntoProtoRecords {
     var selfIndex = ++ this.contextIndex;
     ListWrapper.push(this.protoRecords,
       new ProtoRecord(type, name, funcOrValue, args, fixedArgs, context, selfIndex,
-        this.bindingMemento, this.groupMemento, this.expressionAsString));
+        this.bindingMemento, this.groupMemento, this.expressionAsString, false, false));
     return selfIndex;
   }
 }

modules/change_detection/test/coalesce_spec.js

@@ -0,0 +1,82 @@
+import {ddescribe, describe, it, iit, xit, expect, beforeEach, afterEach} from 'test_lib/test_lib';
+
+import {coalesce} from 'change_detection/coalesce';
+import {RECORD_TYPE_SELF, ProtoRecord} from 'change_detection/proto_change_detector';
+
+export function main() {
+  function r(funcOrValue, args, contextIndex, selfIndex, lastInBinding = false) {
+    return new ProtoRecord(99,  "name", funcOrValue, args, null, contextIndex, selfIndex,
+      null, null, null, lastInBinding, false);
+  }
+
+  describe("change detection - coalesce", () => {
+    it("should work with an empty list", () => {
+      expect(coalesce([])).toEqual([]);
+    });
+
+    it("should remove non-terminal duplicate records" +
+      " and update the context indices referencing them", () => {
+      var rs = coalesce([
+        r("user",   [], 0, 1),
+        r("first",  [], 1, 2),
+        r("user",   [], 0, 3),
+        r("last",   [], 3, 4)
+      ]);
+
+      expect(rs).toEqual([
+        r("user",   [], 0, 1),
+        r("first",  [], 1, 2),
+        r("last",   [], 1, 3)
+      ]);
+    });
+
+    it("should update indices of other records", () => {
+      var rs = coalesce([
+        r("dup",   [],  0, 1),
+        r("dup",   [],  0, 2),
+        r("user",  [],  0, 3),
+        r("first", [3], 3, 4)
+      ]);
+
+      expect(rs).toEqual([
+        r("dup",   [],  0, 1),
+        r("user",  [],  0, 2),
+        r("first", [2], 2, 3)
+      ]);
+    });
+
+    it("should remove non-terminal duplicate records" +
+      " and update the args indices referencing them", () => {
+      var rs = coalesce([
+        r("user1",  [],  0, 1),
+        r("user2",  [],  0, 2),
+        r("hi",     [1], 0, 3),
+        r("hi",     [1], 0, 4),
+        r("hi",     [2], 0, 5)
+      ]);
+
+      expect(rs).toEqual([
+        r("user1",  [],  0, 1),
+        r("user2",  [],  0, 2),
+        r("hi",     [1], 0, 3),
+        r("hi",     [2], 0, 4)
+      ]);
+    });
+
+    it("should replace duplicate terminal records with" +
+      " self records", () => {
+
+      var rs = coalesce([
+        r("user",  [],  0, 1, true),
+        r("user",  [],  0, 2, true)
+      ]);
+
+      expect(rs[1]).toEqual(new ProtoRecord(
+        RECORD_TYPE_SELF, "self", null,
+        [], null, 1, 2,
+        null, null, null,
+        true, false)
+      );
+    });
+  });
+}

modules/facade/src/collection.dart

@@ -118,6 +118,13 @@ class ListWrapper {
     }
     l.fillRange(start, end, value);
   }
+  static bool equals(List a, List b){
+    if(a.length != b.length) return false;
+    for (var i = 0; i < a.length; ++i) {
+      if (a[i] != b[i]) return false;
+    }
+    return true;
+  }
 }
 
 bool isListLikeIterable(obj) => obj is Iterable;

modules/facade/src/collection.es6

@@ -169,6 +169,13 @@ export class ListWrapper {
   static fill(list:List, value, start:int = 0, end:int = undefined) {
     list.fill(value, start, end);
   }
+  static equals(a:List, b:List):boolean {
+    if(a.length != b.length) return false;
+    for (var i = 0; i < a.length; ++i) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
 }
 
 export function isListLikeIterable(obj):boolean {