feat: add isAsync and isAsterisk to function expressions and isOptional to ElementAccessExpr

src/asl.ts

@@ -23,7 +23,6 @@ import {
   isArgument,
   isArrayBinding,
   isArrayLiteralExpr,
-  isArrowFunctionExpr,
   isAwaitExpr,
   isBinaryExpr,
   isBindingElem,
@@ -51,7 +50,7 @@ import {
   isForInStmt,
   isForOfStmt,
   isFunctionDecl,
-  isFunctionExpr,
+  isFunctionLike,
   isIdentifier,
   isIfStmt,
   isLabelledStmt,
@@ -104,7 +103,6 @@ import {
   isGetAccessorDecl,
   isTaggedTemplateExpr,
   isOmittedExpr,
-  isFunctionLike,
   isQuasiString,
 } from "./guards";
 import {
@@ -1680,7 +1678,7 @@ export class ASL {
         const throwTransition = this.throw(expr);
 
         const callbackfn = expr.args[0].expr;
-        if (callbackfn !== undefined && isFunctionExpr(callbackfn)) {
+        if (callbackfn !== undefined && isFunctionLike(callbackfn)) {
           const callbackStates = this.evalStmt(callbackfn.body);
 
           return this.evalExpr(
@@ -2448,7 +2446,7 @@ export class ASL {
     // detect the immediate for-loop closure surrounding this throw statement
     // because of how step function's Catch feature works, we need to check if the try
     // is inside or outside the closure
-    const mapOrParallelClosure = node.findParent(isFunctionExpr);
+    const mapOrParallelClosure = node.findParent(isFunctionLike);
 
     // catchClause or finallyBlock that will run upon throwing this error
     const catchOrFinally = node.throw();
@@ -2709,7 +2707,7 @@ export class ASL {
     expr: CallExpr & { expr: PropAccessExpr }
   ): ASLGraph.NodeResults {
     const predicate = expr.args[0]?.expr;
-    if (!(isFunctionExpr(predicate) || isArrowFunctionExpr(predicate))) {
+    if (!isFunctionLike(predicate)) {
       throw new SynthError(
         ErrorCodes.StepFunction_invalid_filter_syntax,
         `the 'predicate' argument of slice must be a function or arrow expression, found: ${predicate?.kindName}`
@@ -4739,7 +4737,7 @@ function nodeToString(
     return `[${nodeToString(expr.expr)}]`;
   } else if (isElementAccessExpr(expr)) {
     return `${nodeToString(expr.expr)}[${nodeToString(expr.element)}]`;
-  } else if (isFunctionExpr(expr) || isArrowFunctionExpr(expr)) {
+  } else if (isFunctionLike(expr)) {
     return `function(${expr.parameters.map(nodeToString).join(", ")})`;
   } else if (isIdentifier(expr)) {
     return expr.name;

src/assert.ts

@@ -69,18 +69,22 @@ export function assertConstantValue(val: any, message?: string): ConstantValue {
   );
 }
 
-export function assertNodeKind<Kind extends NodeKind>(
+export function assertNodeKind<Kind extends NodeKind[]>(
   node: FunctionlessNode | undefined,
-  kind: Kind
-): NodeInstance<Kind> {
-  if (node?.kind !== kind) {
-    throw Error(
-      `Expected node of type ${getNodeKindName(kind)} and found ${
-        node ? getNodeKindName(node.kind) : "undefined"
-      }`
-    );
+  ...kinds: Kind
+): NodeInstance<Kind[number]> {
+  if (node) {
+    for (const kind of kinds) {
+      if (node?.kind === kind) {
+        return <NodeInstance<Kind[number]>>node;
+      }
+    }
   }
-  return <NodeInstance<Kind>>node;
+  throw Error(
+    `Expected node of type ${kinds.map(getNodeKindName).join(", ")} and found ${
+      node ? getNodeKindName(node.kind) : "undefined"
+    }`
+  );
 }
 
 // to prevent the closure serializer from trying to import all of functionless.

src/compile.ts

@@ -296,6 +296,31 @@ export function compile(
                 ]),
               ]);
 
+          const isAsync =
+            ts.isFunctionDeclaration(impl) ||
+            ts.isFunctionExpression(impl) ||
+            ts.isArrowFunction(impl) ||
+            ts.isMethodDeclaration(impl)
+              ? [
+                  impl.modifiers?.find(
+                    (mod) => mod.kind === ts.SyntaxKind.AsyncKeyword
+                  )
+                    ? ts.factory.createTrue()
+                    : ts.factory.createFalse(),
+                ]
+              : [];
+
+          const isAsterisk =
+            ts.isFunctionDeclaration(impl) ||
+            ts.isFunctionExpression(impl) ||
+            ts.isMethodDeclaration(impl)
+              ? [
+                  impl.asteriskToken
+                    ? ts.factory.createTrue()
+                    : ts.factory.createFalse(),
+                ]
+              : [];
+
           return newExpr(type, [
             ...resolveFunctionName(),
             ts.factory.createArrayLiteralExpression(
@@ -309,6 +334,10 @@ export function compile(
               )
             ),
             body,
+            // isAsync for Functions, Arrows and Methods
+            ...isAsync,
+            // isAsterisk for Functions and Methods
+            ...isAsterisk,
           ]);
         });
 
@@ -340,7 +369,9 @@ export function compile(
       ): ts.Expression {
         if (node === undefined) {
           return ts.factory.createIdentifier("undefined");
-        } else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        } else if (ts.isArrowFunction(node)) {
+          return toFunction(NodeKind.ArrowFunctionExpr, node, scope);
+        } else if (ts.isFunctionExpression(node)) {
           return toFunction(NodeKind.FunctionExpr, node, scope);
         } else if (ts.isExpressionStatement(node)) {
           return newExpr(NodeKind.ExprStmt, [toExpr(node.expression, scope)]);
@@ -419,14 +450,29 @@ export function compile(
               ? ts.factory.createTrue()
               : ts.factory.createFalse(),
           ]);
+        } else if (ts.isPropertyAccessChain(node)) {
+          return newExpr(NodeKind.PropAccessExpr, [
+            toExpr(node.expression, scope),
+            toExpr(node.name, scope),
+            node.questionDotToken
+              ? ts.factory.createTrue()
+              : ts.factory.createFalse(),
+          ]);
+        } else if (ts.isElementAccessChain(node)) {
+          return newExpr(NodeKind.ElementAccessExpr, [
+            toExpr(node.expression, scope),
+            toExpr(node.argumentExpression, scope),
+            node.questionDotToken
+              ? ts.factory.createTrue()
+              : ts.factory.createFalse(),
+          ]);
         } else if (ts.isElementAccessExpression(node)) {
-          const type = checker.getTypeAtLocation(node.argumentExpression);
           return newExpr(NodeKind.ElementAccessExpr, [
             toExpr(node.expression, scope),
             toExpr(node.argumentExpression, scope),
-            type
-              ? ts.factory.createStringLiteral(checker.typeToString(type))
-              : ts.factory.createIdentifier("undefined"),
+            node.questionDotToken
+              ? ts.factory.createTrue()
+              : ts.factory.createFalse(),
           ]);
         } else if (ts.isVariableStatement(node)) {
           return newExpr(NodeKind.VariableStmt, [

src/declaration.ts

@@ -79,12 +79,40 @@ export class MethodDecl extends BaseDecl<NodeKind.MethodDecl> {
   constructor(
     readonly name: PropName,
     readonly parameters: ParameterDecl[],
-    readonly body: BlockStmt
+    readonly body: BlockStmt,
+
+    /**
+     * true if this function has an `async` modifier
+     * ```ts
+     * class Foo {
+     *   async foo() {}
+     *
+     *   // asterisk can co-exist
+     *   async *foo() {}
+     * }
+     * ```
+     */
+    readonly isAsync: boolean,
+    /**
+     * true if this function has an `*` modifier
+     *
+     * ```ts
+     * class Foo {
+     *   foo*() {}
+     *
+     *   // async can co-exist
+     *   async *foo() {}
+     * }
+     * ```
+     */
+    readonly isAsterisk: boolean
   ) {
     super(NodeKind.MethodDecl, arguments);
     this.ensure(name, "name", NodeKind.PropName);
     this.ensureArrayOf(parameters, "parameters", [NodeKind.ParameterDecl]);
     this.ensure(body, "body", [NodeKind.BlockStmt]);
+    this.ensure(isAsync, "isAsync", ["boolean"]);
+    this.ensure(isAsterisk, "isAsterisk", ["boolean"]);
   }
 }
 
@@ -142,12 +170,34 @@ export class FunctionDecl<
     // according to the spec, name is mandatory on a FunctionDecl and FunctionExpr
     readonly name: string | undefined,
     readonly parameters: ParameterDecl[],
-    readonly body: BlockStmt
+    readonly body: BlockStmt,
+    /**
+     * true if this function has an `async` modifier
+     * ```ts
+     * async function foo() {}
+     * // asterisk can co-exist
+     * async function *foo() {}
+     * ```
+     */
+    readonly isAsync: boolean,
+    /**
+     * true if this function has an `*` modifier
+     *
+     * ```ts
+     * function foo*() {}
+     *
+     * // async can co-exist
+     * async function *foo() {}
+     * ```
+     */
+    readonly isAsterisk: boolean
   ) {
     super(NodeKind.FunctionDecl, arguments);
     this.ensure(name, "name", ["undefined", "string"]);
     this.ensureArrayOf(parameters, "parameters", [NodeKind.ParameterDecl]);
     this.ensure(body, "body", [NodeKind.BlockStmt]);
+    this.ensure(isAsync, "isAsync", ["boolean"]);
+    this.ensure(isAsterisk, "isAsterisk", ["boolean"]);
   }
 }
 

src/ensure.ts

@@ -59,7 +59,7 @@ export function ensure<Assert extends Assertion>(
   nodeKind: NodeKind,
   item: any,
   fieldName: string,
-  assertions: Assert[]
+  assertions: Assert[] | readonly Assert[]
 ): asserts item is AssertionToInstance<Assert> {
   if (!is(item, assertions)) {
     throw new Error(

src/event-bridge/utils.ts

@@ -79,7 +79,11 @@ export const getPropertyAccessKeyFlatten = (
 ): string | number => {
   if (isElementAccessExpr(expr)) {
     return getPropertyAccessKey(
-      new ElementAccessExpr(expr.expr, flattenExpression(expr.element, scope))
+      new ElementAccessExpr(
+        expr.expr,
+        flattenExpression(expr.element, scope),
+        expr.isOptional
+      )
     );
   }
   return getPropertyAccessKey(expr);
@@ -186,7 +190,7 @@ export const flattenExpression = (expr: Expr, scope: EventScope): Expr => {
     }
     return typeof key === "string"
       ? new PropAccessExpr(parent, new Identifier(key), false)
-      : new ElementAccessExpr(parent, new NumberLiteralExpr(key));
+      : new ElementAccessExpr(parent, new NumberLiteralExpr(key), false);
   } else if (isComputedPropertyNameExpr(expr)) {
     return flattenExpression(expr.expr, scope);
   } else if (isArrayLiteralExpr(expr)) {

src/expression.ts

@@ -80,10 +80,21 @@ export class ArrowFunctionExpr<
   F extends AnyFunction = AnyFunction
 > extends BaseExpr<NodeKind.ArrowFunctionExpr> {
   readonly _functionBrand?: F;
-  constructor(readonly parameters: ParameterDecl[], readonly body: BlockStmt) {
+  constructor(
+    readonly parameters: ParameterDecl[],
+    readonly body: BlockStmt,
+    /**
+     * true if this function has an `async` modifier
+     * ```ts
+     * async () =>  {}
+     * ```
+     */
+    readonly isAsync: boolean
+  ) {
     super(NodeKind.ArrowFunctionExpr, arguments);
     this.ensure(body, "body", [NodeKind.BlockStmt]);
     this.ensureArrayOf(parameters, "parameters", [NodeKind.ParameterDecl]);
+    this.ensure(isAsync, "isAsync", ["boolean"]);
   }
 }
 
@@ -94,12 +105,34 @@ export class FunctionExpr<
   constructor(
     readonly name: string | undefined,
     readonly parameters: ParameterDecl[],
-    readonly body: BlockStmt
+    readonly body: BlockStmt,
+    /**
+     * true if this function has an `async` modifier
+     * ```ts
+     * async function foo() {}
+     * // asterisk can co-exist
+     * async function *foo() {}
+     * ```
+     */
+    readonly isAsync: boolean,
+    /**
+     * true if this function has an `*` modifier
+     *
+     * ```ts
+     * function foo*() {}
+     *
+     * // async can co-exist
+     * async function *foo() {}
+     * ```
+     */
+    readonly isAsterisk: boolean
   ) {
     super(NodeKind.FunctionExpr, arguments);
     this.ensure(name, "name", ["undefined", "string"]);
     this.ensureArrayOf(parameters, "parameters", [NodeKind.ParameterDecl]);
     this.ensure(body, "body", [NodeKind.BlockStmt]);
+    this.ensure(isAsync, "isAsync", ["boolean"]);
+    this.ensure(isAsterisk, "isAsterisk", ["boolean"]);
   }
 }
 
@@ -158,6 +191,12 @@ export class PropAccessExpr extends BaseExpr<NodeKind.PropAccessExpr> {
   constructor(
     readonly expr: Expr,
     readonly name: Identifier | PrivateIdentifier,
+    /**
+     * Whether this is using optional chaining.
+     * ```ts
+     * a?.prop
+     * ```
+     */
     readonly isOptional: boolean
   ) {
     super(NodeKind.PropAccessExpr, arguments);
@@ -167,7 +206,17 @@ export class PropAccessExpr extends BaseExpr<NodeKind.PropAccessExpr> {
 }
 
 export class ElementAccessExpr extends BaseExpr<NodeKind.ElementAccessExpr> {
-  constructor(readonly expr: Expr, readonly element: Expr) {
+  constructor(
+    readonly expr: Expr,
+    readonly element: Expr,
+    /**
+     * Whether this is using optional chaining.
+     * ```ts
+     * a?.[element]
+     * ```
+     */
+    readonly isOptional: boolean
+  ) {
     super(NodeKind.ElementAccessExpr, arguments);
     this.ensure(expr, "expr", ["Expr"]);
     this.ensure(element, "element", ["Expr"]);