@angular-wave/angular.ts 0.0.50 → 0.0.51

package/src/core/parser/interpreter.js

@@ -1,13 +1,9 @@
-import {
-  assignableAST,
-  findConstantAndWatchExpressions,
-  getInputs,
-  getStringValue,
-  plusFn,
-} from "./shared";
-import { forEach, isDefined } from "../../shared/utils";
+import { isDefined } from "../../shared/utils";
 import { ASTType } from "./ast-type";
 
+export const PURITY_ABSOLUTE = 1;
+export const PURITY_RELATIVE = 2;
+
 export class ASTInterpreter {
   /**
    * @param {function(any):any} $filter
@@ -19,49 +15,53 @@ export class ASTInterpreter {
   /**
    * Compiles the AST into a function.
    * @param {import("./ast").ASTNode} ast - The AST to compile.
-   * @returns
+   * @returns {import("./parse").CompiledExpression}
    */
   compile(ast) {
-    const self = this;
-    findConstantAndWatchExpressions(ast, self.$filter);
+    let decoratedNode = findConstantAndWatchExpressions(ast, this.$filter);
+    /** @type {import("./ast").ASTNode} */
     let assignable;
+    /** @type {import("./parse").CompiledExpression} */
     let assign;
-    if ((assignable = assignableAST(ast))) {
-      assign = this.recurse(assignable);
+    if ((assignable = assignableAST(decoratedNode))) {
+      assign = /** @type {import("./parse").CompiledExpression} */ (
+        this.recurse(assignable)
+      );
     }
-    const toWatch = getInputs(ast.body);
+    const toWatch = getInputs(decoratedNode.body);
     let inputs;
     if (toWatch) {
       inputs = [];
-      forEach(toWatch, (watch, key) => {
-        const input = self.recurse(watch);
+      for (const [key, watch] of Object.entries(toWatch)) {
+        const input = /** @type {import("./parse").CompiledExpression} */ (
+          this.recurse(watch)
+        );
         input.isPure = watch.isPure;
         watch.input = input;
         inputs.push(input);
         watch.watchId = key;
-      });
+      }
     }
     const expressions = [];
-    forEach(ast.body, (expression) => {
-      expressions.push(self.recurse(expression.expression));
+    decoratedNode.body.forEach((expression) => {
+      expressions.push(this.recurse(expression.expression));
     });
 
+    /** @type {import("./parse").CompiledExpression} */
     const fn =
-      ast.body.length === 0
+      decoratedNode.body.length === 0
         ? () => {}
-        : ast.body.length === 1
+        : decoratedNode.body.length === 1
           ? expressions[0]
           : function (scope, locals) {
               let lastValue;
-              forEach(expressions, (exp) => {
+              expressions.forEach((exp) => {
                 lastValue = exp(scope, locals);
               });
               return lastValue;
             };
     if (assign) {
-      fn.assign = function (scope, value, locals) {
-        return assign(scope, locals, value);
-      };
+      fn.assign = (scope, value, locals) => assign(scope, locals, value);
     }
     if (inputs) {
       fn.inputs = inputs;
@@ -73,17 +73,14 @@ export class ASTInterpreter {
    * Recurses the AST nodes.
    * @param {import("./ast").ASTNode} ast - The AST node.
    * @param {Object} [context] - The context.
-   * @param {boolean|number} [create] - The create flag.
-   * @returns {function} The recursive function.
+   * @param {boolean|1} [create] - The create flag.
+   * @returns {import("./parse").CompiledExpressionFunction} The recursive function.
    */
   recurse(ast, context, create) {
     let left;
     let right;
     const self = this;
     let args;
-    if (ast.input) {
-      return this.inputs(ast.input, ast.watchId);
-    }
     switch (ast.type) {
       case ASTType.Literal:
         return this.value(ast.value, context);
@@ -114,33 +111,43 @@ export class ASTInterpreter {
         }
         if (ast.computed) right = this.recurse(ast.property);
         return ast.computed
-          ? this.computedMember(left, right, context, create)
-          : this.nonComputedMember(left, right, context, create);
+          ? this.computedMember(
+              left,
+              /** @type {function } */ (right),
+              context,
+              create,
+            )
+          : this.nonComputedMember(
+              left,
+              /** @type {string } */ (right),
+              context,
+              create,
+            );
       case ASTType.CallExpression:
         args = [];
-        forEach(ast.arguments, (expr) => {
+        ast.arguments.forEach((expr) => {
           args.push(self.recurse(expr));
         });
         if (ast.filter) right = this.$filter(ast.callee.name);
         if (!ast.filter) right = this.recurse(ast.callee, true);
         return ast.filter
-          ? function (scope, locals, assign, inputs) {
+          ? function (scope, locals, assign) {
               const values = [];
               for (let i = 0; i < args.length; ++i) {
-                values.push(args[i](scope, locals, assign, inputs));
+                values.push(args[i](scope, locals, assign));
               }
-              const value = right.apply(undefined, values, inputs);
+              const value = right.apply(undefined, values);
               return context
                 ? { context: undefined, name: undefined, value }
                 : value;
             }
-          : function (scope, locals, assign, inputs) {
-              const rhs = right(scope, locals, assign, inputs);
+          : function (scope, locals, assign) {
+              const rhs = right(scope, locals, assign);
               let value;
               if (rhs.value != null) {
                 const values = [];
                 for (let i = 0; i < args.length; ++i) {
-                  values.push(args[i](scope, locals, assign, inputs));
+                  values.push(args[i](scope, locals, assign));
                 }
                 value = rhs.value.apply(rhs.context, values);
               }
@@ -149,27 +156,27 @@ export class ASTInterpreter {
       case ASTType.AssignmentExpression:
         left = this.recurse(ast.left, true, 1);
         right = this.recurse(ast.right);
-        return function (scope, locals, assign, inputs) {
-          const lhs = left(scope, locals, assign, inputs);
-          const rhs = right(scope, locals, assign, inputs);
+        return function (scope, locals, assign) {
+          const lhs = left(scope, locals, assign);
+          const rhs = right(scope, locals, assign);
           lhs.context[lhs.name] = rhs;
           return context ? { value: rhs } : rhs;
         };
       case ASTType.ArrayExpression:
         args = [];
-        forEach(ast.elements, (expr) => {
+        ast.elements.forEach((expr) => {
           args.push(self.recurse(expr));
         });
-        return function (scope, locals, assign, inputs) {
+        return function (scope, locals, assign) {
           const value = [];
           for (let i = 0; i < args.length; ++i) {
-            value.push(args[i](scope, locals, assign, inputs));
+            value.push(args[i](scope, locals, assign));
           }
           return context ? { value } : value;
         };
       case ASTType.ObjectExpression:
         args = [];
-        forEach(ast.properties, (property) => {
+        ast.properties.forEach((property) => {
           if (property.computed) {
             args.push({
               key: self.recurse(property.key),
@@ -187,18 +194,17 @@ export class ASTInterpreter {
             });
           }
         });
-        return function (scope, locals, assign, inputs) {
+        return function (scope, locals, assign) {
           const value = {};
           for (let i = 0; i < args.length; ++i) {
             if (args[i].computed) {
-              value[args[i].key(scope, locals, assign, inputs)] = args[i].value(
+              value[args[i].key(scope, locals, assign)] = args[i].value(
                 scope,
                 locals,
                 assign,
-                inputs,
               );
             } else {
-              value[args[i].key] = args[i].value(scope, locals, assign, inputs);
+              value[args[i].key] = args[i].value(scope, locals, assign);
             }
           }
           return context ? { value } : value;
@@ -225,8 +231,8 @@ export class ASTInterpreter {
    * @returns {function} The unary plus function.
    */
   "unary+"(argument, context) {
-    return function (scope, locals, assign, inputs) {
-      let arg = argument(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      let arg = argument(scope, locals, assign);
       if (isDefined(arg)) {
         arg = +arg;
       } else {
@@ -243,8 +249,8 @@ export class ASTInterpreter {
    * @returns {function} The unary minus function.
    */
   "unary-"(argument, context) {
-    return function (scope, locals, assign, inputs) {
-      let arg = argument(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      let arg = argument(scope, locals, assign);
       if (isDefined(arg)) {
         arg = -arg;
       } else {
@@ -261,8 +267,8 @@ export class ASTInterpreter {
    * @returns {function} The unary negation function.
    */
   "unary!"(argument, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg = !argument(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = !argument(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -275,9 +281,9 @@ export class ASTInterpreter {
    * @returns {function} The binary plus function.
    */
   "binary+"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const lhs = left(scope, locals, assign, inputs);
-      const rhs = right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const lhs = left(scope, locals, assign);
+      const rhs = right(scope, locals, assign);
       const arg = plusFn(lhs, rhs);
       return context ? { value: arg } : arg;
     };
@@ -291,9 +297,9 @@ export class ASTInterpreter {
    * @returns {function} The binary minus function.
    */
   "binary-"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const lhs = left(scope, locals, assign, inputs);
-      const rhs = right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const lhs = left(scope, locals, assign);
+      const rhs = right(scope, locals, assign);
       const arg = (isDefined(lhs) ? lhs : 0) - (isDefined(rhs) ? rhs : 0);
       return context ? { value: arg } : arg;
     };
@@ -307,19 +313,15 @@ export class ASTInterpreter {
    * @returns {function} The binary multiplication function.
    */
   "binary*"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) *
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) * right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
 
   "binary/"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) /
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) / right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -332,10 +334,8 @@ export class ASTInterpreter {
    * @returns {function} The binary division function.
    */
   "binary%"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) %
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) % right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -348,10 +348,8 @@ export class ASTInterpreter {
    * @returns {function} The binary strict equality function.
    */
   "binary==="(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) ===
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) === right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -364,10 +362,8 @@ export class ASTInterpreter {
    * @returns {function} The binary strict inequality function.
    */
   "binary!=="(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) !==
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) !== right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -380,10 +376,8 @@ export class ASTInterpreter {
    * @returns {function} The binary equality function.
    */
   "binary=="(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) ==
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) == right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -396,10 +390,8 @@ export class ASTInterpreter {
    * @returns {function} The binary inequality function.
    */
   "binary!="(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) !=
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) != right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -412,10 +404,8 @@ export class ASTInterpreter {
    * @returns {function} The binary less-than function.
    */
   "binary<"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) <
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) < right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -428,10 +418,8 @@ export class ASTInterpreter {
    * @returns {function} The binary greater-than function.
    */
   "binary>"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) >
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) > right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -444,10 +432,8 @@ export class ASTInterpreter {
    * @returns {function} The binary less-than-or-equal-to function.
    */
   "binary<="(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) <=
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) <= right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -460,10 +446,8 @@ export class ASTInterpreter {
    * @returns {function} The binary greater-than-or-equal-to function.
    */
   "binary>="(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) >=
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) >= right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -475,10 +459,8 @@ export class ASTInterpreter {
    * @returns {function} The binary logical AND function.
    */
   "binary&&"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) &&
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) && right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -491,10 +473,8 @@ export class ASTInterpreter {
    * @returns {function} The binary logical OR function.
    */
   "binary||"(left, right, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg =
-        left(scope, locals, assign, inputs) ||
-        right(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = left(scope, locals, assign) || right(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -508,10 +488,10 @@ export class ASTInterpreter {
    * @returns {function} The ternary conditional function.
    */
   "ternary?:"(test, alternate, consequent, context) {
-    return function (scope, locals, assign, inputs) {
-      const arg = test(scope, locals, assign, inputs)
-        ? alternate(scope, locals, assign, inputs)
-        : consequent(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const arg = test(scope, locals, assign)
+        ? alternate(scope, locals, assign)
+        : consequent(scope, locals, assign);
       return context ? { value: arg } : arg;
     };
   }
@@ -532,7 +512,7 @@ export class ASTInterpreter {
    * Returns the value of an identifier.
    * @param {string} name - The identifier name.
    * @param {Object} [context] - The context.
-   * @param {boolean} [create] - Whether to create the identifier if it does not exist.
+   * @param {boolean|1} [create] - Whether to create the identifier if it does not exist.
    * @returns {function} The function returning the identifier value.
    */
   identifier(name, context, create) {
@@ -554,16 +534,16 @@ export class ASTInterpreter {
    * @param {function} left - The left operand function.
    * @param {function} right - The right operand function.
    * @param {Object} [context] - The context.
-   * @param {boolean} [create] - Whether to create the member if it does not exist.
+   * @param {boolean|1} [create] - Whether to create the member if it does not exist.
    * @returns {function} The function returning the computed member value.
    */
   computedMember(left, right, context, create) {
-    return function (scope, locals, assign, inputs) {
-      const lhs = left(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const lhs = left(scope, locals, assign);
       let rhs;
       let value;
       if (lhs != null) {
-        rhs = right(scope, locals, assign, inputs);
+        rhs = right(scope, locals, assign);
         rhs = getStringValue(rhs);
         if (create && create !== 1) {
           if (lhs && !lhs[rhs]) {
@@ -584,12 +564,12 @@ export class ASTInterpreter {
    * @param {function} left - The left operand function.
    * @param {string} right - The right operand function.
    * @param {Object} [context] - The context.
-   * @param {boolean} [create] - Whether to create the member if it does not exist.
+   * @param {boolean|1} [create] - Whether to create the member if it does not exist.
    * @returns {function} The function returning the non-computed member value.
    */
   nonComputedMember(left, right, context, create) {
-    return function (scope, locals, assign, inputs) {
-      const lhs = left(scope, locals, assign, inputs);
+    return function (scope, locals, assign) {
+      const lhs = left(scope, locals, assign);
       if (create && create !== 1) {
         if (lhs && lhs[right] == null) {
           lhs[right] = {};
@@ -602,17 +582,306 @@ export class ASTInterpreter {
       return value;
     };
   }
+}
 
-  /**
-   * Returns the value of an input expression.
-   * @param {function} input - The input function.
-   * @param {number} watchId - The watch identifier.
-   * @returns {function} The function returning the input value.
-   */
-  inputs(input, watchId) {
-    return function (scope, value, locals, inputs) {
-      if (inputs) return inputs[watchId];
-      return input(scope, value, locals);
+/**
+ * @typedef {import("./ast").ASTNode & {
+ *  isPure: boolean|number,
+ *  constant: boolean,
+ *  toWatch: Array,
+ * }} DecoratedASTNode
+ */
+
+/**
+ * Decorates AST with constant, toWatch, and isPure properties
+ * @param {import("./ast").ASTNode} ast
+ * @param {function(any):any} $filter
+ * @param {boolean|1|2} [parentIsPure]
+ * @returns {DecoratedASTNode}
+ */
+function findConstantAndWatchExpressions(ast, $filter, parentIsPure) {
+  let allConstants;
+  let argsToWatch;
+  let isStatelessFilter;
+  let decoratedNode = /** @type  {DecoratedASTNode} */ (ast);
+  let decoratedLeft,
+    decoratedRight,
+    decoratedTest,
+    decoratedAlternate,
+    decoratedConsequent,
+    decoratedObject,
+    decoratedProperty,
+    decoratedKey;
+  const astIsPure = (decoratedNode.isPure = isPure(ast, parentIsPure));
+
+  switch (ast.type) {
+    case ASTType.Program:
+      allConstants = true;
+      decoratedNode.body.forEach((expr) => {
+        let decorated = findConstantAndWatchExpressions(
+          expr.expression,
+          $filter,
+          astIsPure,
+        );
+        allConstants = allConstants && decorated.constant;
+      });
+      decoratedNode.constant = allConstants;
+      return decoratedNode;
+    case ASTType.Literal:
+      decoratedNode.constant = true;
+      decoratedNode.toWatch = [];
+      return decoratedNode;
+    case ASTType.UnaryExpression:
+      var decorated = findConstantAndWatchExpressions(
+        decoratedNode.argument,
+        $filter,
+        astIsPure,
+      );
+      decoratedNode.constant = decorated.constant;
+      decoratedNode.toWatch = decorated.toWatch;
+      return decoratedNode;
+    case ASTType.BinaryExpression:
+      decoratedLeft = findConstantAndWatchExpressions(
+        decoratedNode.left,
+        $filter,
+        astIsPure,
+      );
+      decoratedRight = findConstantAndWatchExpressions(
+        decoratedNode.right,
+        $filter,
+        astIsPure,
+      );
+      decoratedNode.constant =
+        decoratedLeft.constant && decoratedRight.constant;
+      decoratedNode.toWatch = decoratedLeft.toWatch.concat(
+        decoratedRight.toWatch,
+      );
+      return decoratedNode;
+    case ASTType.LogicalExpression:
+      decoratedLeft = findConstantAndWatchExpressions(
+        decoratedNode.left,
+        $filter,
+        astIsPure,
+      );
+      decoratedRight = findConstantAndWatchExpressions(
+        decoratedNode.right,
+        $filter,
+        astIsPure,
+      );
+      decoratedNode.constant =
+        decoratedLeft.constant && decoratedRight.constant;
+      decoratedNode.toWatch = decoratedNode.constant ? [] : [ast];
+      return decoratedNode;
+    case ASTType.ConditionalExpression:
+      decoratedTest = findConstantAndWatchExpressions(
+        ast.test,
+        $filter,
+        astIsPure,
+      );
+      decoratedAlternate = findConstantAndWatchExpressions(
+        ast.alternate,
+        $filter,
+        astIsPure,
+      );
+      decoratedConsequent = findConstantAndWatchExpressions(
+        ast.consequent,
+        $filter,
+        astIsPure,
+      );
+      decoratedNode.constant =
+        decoratedTest.constant &&
+        decoratedAlternate.constant &&
+        decoratedConsequent.constant;
+      decoratedNode.toWatch = decoratedNode.constant ? [] : [ast];
+      return decoratedNode;
+    case ASTType.Identifier:
+      decoratedNode.constant = false;
+      decoratedNode.toWatch = [ast];
+      return decoratedNode;
+    case ASTType.MemberExpression:
+      decoratedObject = findConstantAndWatchExpressions(
+        ast.object,
+        $filter,
+        astIsPure,
+      );
+      if (ast.computed) {
+        decoratedProperty = findConstantAndWatchExpressions(
+          ast.property,
+          $filter,
+          astIsPure,
+        );
+      }
+      decoratedNode.constant =
+        decoratedObject.constant &&
+        (!decoratedNode.computed || decoratedProperty.constant);
+      decoratedNode.toWatch = decoratedNode.constant ? [] : [ast];
+      return decoratedNode;
+    case ASTType.CallExpression:
+      isStatelessFilter = ast.filter
+        ? isStateless($filter, ast.callee.name)
+        : false;
+      allConstants = isStatelessFilter;
+      argsToWatch = [];
+      ast.arguments.forEach((expr) => {
+        decorated = findConstantAndWatchExpressions(expr, $filter, astIsPure);
+        allConstants = allConstants && decorated.constant;
+        argsToWatch.push.apply(argsToWatch, decorated.toWatch);
+      });
+      decoratedNode.constant = allConstants;
+      decoratedNode.toWatch = isStatelessFilter ? argsToWatch : [decoratedNode];
+      return decoratedNode;
+    case ASTType.AssignmentExpression:
+      decoratedLeft = findConstantAndWatchExpressions(
+        ast.left,
+        $filter,
+        astIsPure,
+      );
+      decoratedRight = findConstantAndWatchExpressions(
+        ast.right,
+        $filter,
+        astIsPure,
+      );
+      decoratedNode.constant =
+        decoratedLeft.constant && decoratedRight.constant;
+      decoratedNode.toWatch = [decoratedNode];
+      return decoratedNode;
+    case ASTType.ArrayExpression:
+      allConstants = true;
+      argsToWatch = [];
+      ast.elements.forEach((expr) => {
+        decorated = findConstantAndWatchExpressions(expr, $filter, astIsPure);
+        allConstants = allConstants && decorated.constant;
+        argsToWatch.push.apply(argsToWatch, decorated.toWatch);
+      });
+      decoratedNode.constant = allConstants;
+      decoratedNode.toWatch = argsToWatch;
+      return decoratedNode;
+    case ASTType.ObjectExpression:
+      allConstants = true;
+      argsToWatch = [];
+      ast.properties.forEach((property) => {
+        decorated = findConstantAndWatchExpressions(
+          property.value,
+          $filter,
+          astIsPure,
+        );
+        allConstants = allConstants && decorated.constant;
+        argsToWatch.push.apply(argsToWatch, decorated.toWatch);
+        if (property.computed) {
+          // `{[key]: value}` implicitly does `key.toString()` which may be non-pure
+          decoratedKey = findConstantAndWatchExpressions(
+            property.key,
+            $filter,
+            false,
+          );
+          allConstants = allConstants && decoratedKey.constant;
+          argsToWatch.push.apply(argsToWatch, decoratedKey.toWatch);
+        }
+      });
+      decoratedNode.constant = allConstants;
+      decoratedNode.toWatch = argsToWatch;
+      return decoratedNode;
+    case ASTType.ThisExpression:
+      decoratedNode.constant = false;
+      decoratedNode.toWatch = [];
+      return decoratedNode;
+    case ASTType.LocalsExpression:
+      decoratedNode.constant = false;
+      decoratedNode.toWatch = [];
+      return decoratedNode;
+  }
+}
+
+/**
+ * Converts a single expression AST node into an assignment expression if the expression is assignable.
+ *
+ * @param {import("./ast").ASTNode} ast
+ * @returns {import("./ast").ASTNode}
+ */
+function assignableAST(ast) {
+  if (ast.body.length === 1 && isAssignable(ast.body[0].expression)) {
+    return {
+      type: ASTType.AssignmentExpression,
+      left: ast.body[0].expression,
+      right: { type: ASTType.NGValueParameter },
+      operator: "=",
     };
   }
 }
+
+function plusFn(l, r) {
+  if (typeof l === "undefined") return r;
+  if (typeof r === "undefined") return l;
+  return l + r;
+}
+
+/**
+ *
+ * @param {import("./ast").ASTNode[]} body
+ * @returns {any}
+ */
+function getInputs(body) {
+  if (body.length !== 1) return;
+  const lastExpression = /** @type {DecoratedASTNode} */ (body[0].expression);
+  const candidate = lastExpression.toWatch;
+  if (candidate.length !== 1) return candidate;
+  return candidate[0] !== lastExpression ? candidate : undefined;
+}
+
+/**
+ * Detect nodes which could depend on non-shallow state of objects
+ * @param {import("./ast").ASTNode} node
+ * @param {boolean|PURITY_ABSOLUTE|PURITY_RELATIVE} parentIsPure
+ * @returns {boolean|PURITY_ABSOLUTE|PURITY_RELATIVE}
+ */
+function isPure(node, parentIsPure) {
+  switch (node.type) {
+    // Computed members might invoke a stateful toString()
+    case ASTType.MemberExpression:
+      if (node.computed) {
+        return false;
+      }
+      break;
+
+    // Unary always convert to primitive
+    case ASTType.UnaryExpression:
+      return PURITY_ABSOLUTE;
+
+    // The binary + operator can invoke a stateful toString().
+    case ASTType.BinaryExpression:
+      return node.operator !== "+" ? PURITY_ABSOLUTE : false;
+
+    // Functions / filters probably read state from within objects
+    case ASTType.CallExpression:
+      return false;
+  }
+
+  return undefined === parentIsPure ? PURITY_RELATIVE : parentIsPure;
+}
+
+function isStateless($filter, filterName) {
+  const fn = $filter(filterName);
+  return !fn.$stateful;
+}
+
+/**
+ * Converts parameter to  strings property name for use  as keys in an object.
+ * Any non-string object, including a number, is typecasted into a string via the toString method.
+ * {@link https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Property_accessors#Property_names}
+ *
+ * @param {!any} name
+ * @returns {string}
+ */
+function getStringValue(name) {
+  return `${name}`;
+}
+
+/**
+ * @param {import("./ast").ASTNode} ast
+ * @returns {boolean}
+ */
+export function isAssignable(ast) {
+  return (
+    ast.type === ASTType.Identifier || ast.type === ASTType.MemberExpression
+  );
+}