[BACKPORT] Performance Tuning for Ember 3.13

.vscode/settings.json

@@ -24,5 +24,6 @@
   "files.trimTrailingWhitespace": true,
   "editor.renderWhitespace": "boundary",
   "editor.insertSpaces": true,
-  "editor.tabSize": 2
+  "editor.tabSize": 2,
+  "workbench.colorCustomizations": {}
 }

package.json

@@ -76,6 +76,10 @@
     "tslint-config-prettier": "^1.12.0",
     "tslint-plugin-prettier": "^1.3.0"
   },
+  "resolutions": {
+    "typescript": "3.3.3",
+    "broccoli-typescript-transpiler/typescript": "3.3.3"
+  },
   "changelog": {
     "repo": "glimmerjs/glimmer-vm",
     "labels": {
@@ -91,4 +95,4 @@
       "build/symlink-dependencies"
     ]
   }
-}
+}

packages/@glimmer/reference/index.ts

@@ -1,16 +1,25 @@
-export { Reference as BasicReference, PathReference as BasicPathReference } from './lib/reference';
+export {
+  Reference as BasicReference,
+  PathReference as BasicPathReference,
+  VersionedReference as Reference,
+  VersionedPathReference as PathReference,
+  VersionedReference,
+  VersionedPathReference,
+  CachedReference,
+  Mapper,
+  map,
+  ReferenceCache,
+  Validation,
+  NotModified,
+  isModified,
+} from './lib/reference';
 
 export { ConstReference } from './lib/const';
 
 export { ListItem } from './lib/iterable';
 
 export * from './lib/validators';
 
-export {
-  VersionedReference as Reference,
-  VersionedPathReference as PathReference,
-} from './lib/validators';
-
 export {
   IterationItem,
   Iterator,

packages/@glimmer/reference/lib/const.ts

@@ -1,4 +1,5 @@
-import { CONSTANT_TAG, VersionedReference, Tag } from './validators';
+import { CONSTANT_TAG, Tag } from './validators';
+import { VersionedReference } from './reference';
 
 export class ConstReference<T> implements VersionedReference<T> {
   public tag: Tag = CONSTANT_TAG;

packages/@glimmer/reference/lib/iterable.ts

@@ -1,5 +1,6 @@
 import { LinkedList, ListNode, Opaque, Option, dict, expect } from '@glimmer/util';
-import { VersionedPathReference as PathReference, Tag } from './validators';
+import { Tag } from './validators';
+import { VersionedPathReference as PathReference } from './reference';
 
 export interface IterationItem<T, U> {
   key: string;

packages/@glimmer/reference/lib/reference.ts

@@ -1,4 +1,5 @@
-import { Opaque } from '@glimmer/util';
+import { Opaque, Option } from '@glimmer/util';
+import { Revision, Tag, Tagged, value, validate } from './validators';
 
 export interface Reference<T> {
   value(): T;
@@ -9,3 +10,128 @@ export default Reference;
 export interface PathReference<T> extends Reference<T> {
   get(key: string): PathReference<Opaque>;
 }
+
+//////////
+
+export interface VersionedReference<T = Opaque> extends Reference<T>, Tagged {}
+
+export interface VersionedPathReference<T = Opaque> extends PathReference<T>, Tagged {
+  get(property: string): VersionedPathReference<Opaque>;
+}
+
+export abstract class CachedReference<T> implements VersionedReference<T> {
+  public abstract tag: Tag;
+
+  private lastRevision: Option<Revision> = null;
+  private lastValue: Option<T> = null;
+
+  value(): T {
+    let { tag, lastRevision, lastValue } = this;
+
+    if (lastRevision === null || !validate(tag, lastRevision)) {
+      lastValue = this.lastValue = this.compute();
+      this.lastRevision = value(tag);
+    }
+
+    return lastValue as T;
+  }
+
+  protected abstract compute(): T;
+
+  protected invalidate() {
+    this.lastRevision = null;
+  }
+}
+
+//////////
+
+export type Mapper<T, U> = (value: T) => U;
+
+class MapperReference<T, U> extends CachedReference<U> {
+  public tag: Tag;
+
+  private reference: VersionedReference<T>;
+  private mapper: Mapper<T, U>;
+
+  constructor(reference: VersionedReference<T>, mapper: Mapper<T, U>) {
+    super();
+    this.tag = reference.tag;
+    this.reference = reference;
+    this.mapper = mapper;
+  }
+
+  protected compute(): U {
+    let { reference, mapper } = this;
+    return mapper(reference.value());
+  }
+}
+
+export function map<T, U>(
+  reference: VersionedReference<T>,
+  mapper: Mapper<T, U>
+): VersionedReference<U> {
+  return new MapperReference<T, U>(reference, mapper);
+}
+
+//////////
+
+export class ReferenceCache<T> implements Tagged {
+  public tag: Tag;
+
+  private reference: VersionedReference<T>;
+  private lastValue: Option<T> = null;
+  private lastRevision: Option<Revision> = null;
+  private initialized = false;
+
+  constructor(reference: VersionedReference<T>) {
+    this.tag = reference.tag;
+    this.reference = reference;
+  }
+
+  peek(): T {
+    if (!this.initialized) {
+      return this.initialize();
+    }
+
+    return this.lastValue as T;
+  }
+
+  revalidate(): Validation<T> {
+    if (!this.initialized) {
+      return this.initialize();
+    }
+
+    let { reference, lastRevision } = this;
+    let tag = reference.tag;
+
+    if (validate(tag, lastRevision as number)) return NOT_MODIFIED;
+    this.lastRevision = value(tag);
+
+    let { lastValue } = this;
+    let currentValue = reference.value();
+    if (currentValue === lastValue) return NOT_MODIFIED;
+    this.lastValue = currentValue;
+
+    return currentValue;
+  }
+
+  private initialize(): T {
+    let { reference } = this;
+
+    let currentValue = (this.lastValue = reference.value());
+    this.lastRevision = value(reference.tag);
+    this.initialized = true;
+
+    return currentValue;
+  }
+}
+
+export type Validation<T> = T | NotModified;
+
+export type NotModified = 'adb3b78e-3d22-4e4b-877a-6317c2c5c145';
+
+const NOT_MODIFIED: NotModified = 'adb3b78e-3d22-4e4b-877a-6317c2c5c145';
+
+export function isModified<T>(value: Validation<T>): value is T {
+  return value !== NOT_MODIFIED;
+}