getExpression is not an async function

While here, I cleaned up all the jsdoc comments. We don't need to
specify types in the comments since we're using TypeScript.

Author: freshstrangemusic

src/types/global.d.ts

@@ -155,7 +155,7 @@ declare namespace browser.experiments.nimbus {
 
   function setCollection(collectionId: string): Promise<void>;
 
-  function evaluateJEXL(expression: string, context: object): Promise<object>;
+  function evaluateJEXL(expression: string, context: object): Promise<unknown>;
 
   function getClientContext(): Promise<object>;
 

src/ui/jexlParser.ts

@@ -21,9 +21,11 @@ const grammar = {
 
 /**
  * Evaluates a JEXL expression within a given context.
- * @param {string} expression - The JEXL expression to evaluate.
- * @param {object} context - The context in which to evaluate the expression.
- * @returns {Promise<string>} - The result of the evaluation as a string.
+ *
+ * @param expression The JEXL expression to evaluate.
+ * @param context The context in which to evaluate the expression.
+ *
+ * @returns The result of the evaluation as a string.
  */
 export async function evaluateJexl(
   expression: string,
@@ -51,14 +53,16 @@ export async function evaluateJexl(
 
 /**
  * Evaluates a JEXL expression using the browser's Nimbus API.
- * @param {string} expression - The JEXL expression to evaluate.
- * @param {object} context - The context in which to evaluate the expression.
- * @returns {Promise<object|boolean>} - The result of the evaluation.
+ *
+ * @param expression - The JEXL expression to evaluate.
+ * @param context - The context in which to evaluate the expression.
+ *
+ * @returns The result of the evaluation.
  */
 async function evaluateExpression(
   expression: string,
   context: object,
-): Promise<object | boolean> {
+): Promise<unknown> {
   try {
     return await browser.experiments.nimbus.evaluateJEXL(expression, context);
   } catch (error) {
@@ -69,10 +73,12 @@ async function evaluateExpression(
 
 /**
  * Traverses the AST to evaluate sub-expressions and collect parts that evaluate to false.
- * @param {ASTNode} ast - The AST node to traverse.
- * @param {object} context - The context in which to evaluate the expressions.
- * @param {string[]} falseParts - An array to collect expressions that evaluate to false.
- * @returns {Promise<unknown>} - The result of the traversal.
+ *
+ * @param ast The AST node to traverse.
+ * @param context The context in which to evaluate the expressions.
+ * @param falseParts An array to collect expressions that evaluate to false.
+ *
+ * @returns The result of the traversal.
  */
 async function traverseAst(
   ast: ASTNode,
@@ -83,16 +89,16 @@ async function traverseAst(
     return true;
   }
 
-  const subExpr = await getExpression(ast);
+  const subExpr = getExpression(ast);
   const result = await evaluateExpression(subExpr, context);
 
   if (ast.type === "BinaryExpression" || ast.type === "LogicalExpression") {
     const leftResult = await evaluateExpression(
-      await getExpression(ast.left),
+      getExpression(ast.left),
       context,
     );
     const rightResult = await evaluateExpression(
-      await getExpression(ast.right),
+      getExpression(ast.right),
       context,
     );
 
@@ -164,8 +170,10 @@ async function traverseAst(
 
 /**
  * Retrieves the full identifier string from an AST node.
- * @param {Identifier} ast - The AST node representing an identifier.
- * @returns {string} - The full identifier string.
+ *
+ * @param ast The AST node representing an identifier.
+ *
+ * @returns  The full identifier string.
  */
 function getFullIdentifier(ast: Identifier): string {
   if (!ast.from) {
@@ -176,17 +184,19 @@ function getFullIdentifier(ast: Identifier): string {
 
 /**
  * Converts an AST node to its corresponding JEXL expression string.
- * @param {ASTNode} ast - The AST node to convert.
- * @returns {Promise<string>} - The JEXL expression string.
+ *
+ * @param ast The AST node to convert.
+ *
+ * @returns The JEXL expression string.
  */
-async function getExpression(ast: ASTNode): Promise<string> {
+function getExpression(ast: ASTNode): string {
   if (!ast) {
     return "";
   }
 
   if (ast.type === "BinaryExpression" || ast.type === "LogicalExpression") {
-    const leftExpr = await getExpression(ast.left);
-    const rightExpr = await getExpression(ast.right);
+    const leftExpr = getExpression(ast.left);
+    const rightExpr = getExpression(ast.right);
     const leftWrapped =
       ast.left.type === "Literal" ||
       ast.left.type === "Identifier" ||
@@ -201,47 +211,41 @@ async function getExpression(ast: ASTNode): Promise<string> {
         : `(${rightExpr})`;
     return `${leftWrapped} ${ast.operator} ${rightWrapped}`;
   } else if (ast.type === "UnaryExpression") {
-    const rightExpr = await getExpression(ast.right);
+    const rightExpr = getExpression(ast.right);
     return `${ast.operator}(${rightExpr})`;
   } else if (ast.type === "Transform") {
-    const subjectExpr = await getExpression(ast.subject);
-    const argsExpr = ast.args
-      ? (await Promise.all(ast.args.map(getExpression))).join(", ")
-      : "";
+    const subjectExpr = getExpression(ast.subject);
+    const argsExpr = ast.args ? ast.args.map(getExpression).join(", ") : "";
     return argsExpr.length === 0
       ? `${subjectExpr}|${ast.name}`
       : `${subjectExpr}|${ast.name}(${argsExpr})`;
   } else if (ast.type === "FilterExpression") {
-    const subjectExpr = await getExpression(ast.subject);
-    const filterExpr = await getExpression(ast.expr);
+    const subjectExpr = getExpression(ast.subject);
+    const filterExpr = getExpression(ast.expr);
     return `${subjectExpr}[${filterExpr}]`;
   } else if (ast.type === "Literal") {
     return typeof ast.value === "string" ? `'${ast.value}'` : `${ast.value}`;
   } else if (ast.type === "Identifier") {
     return getFullIdentifier(ast);
   } else if (ast.type === "ArrayLiteral") {
-    const elementsExpr = (await Promise.all(ast.value.map(getExpression))).join(
-      ", ",
-    );
+    const elementsExpr = ast.value.map(getExpression).join(", ");
     return `[${elementsExpr}]`;
   } else if (ast.type === "ObjectLiteral") {
     const entries = Object.entries(ast.value);
-    const objectExpr = await Promise.all(
-      entries.map(async ([key, value]) => {
-        const valueExpr = await getExpression(value);
-        if (value.type === "ObjectLiteral") {
-          const nestedEntries = Object.entries(value.value);
-          const nestedObjectExpr = await Promise.all(
-            nestedEntries.map(async ([nestedKey, nestedValue]) => {
-              const nestedValueExpr = await getExpression(nestedValue);
-              return `${nestedKey}: ${nestedValueExpr}`;
-            }),
-          );
-          return `${key}: { ${nestedObjectExpr.join(", ")} }`;
-        }
-        return `${key}: ${valueExpr}`;
-      }),
-    );
+    const objectExpr = entries.map(async ([key, value]) => {
+      const valueExpr = getExpression(value);
+      if (value.type === "ObjectLiteral") {
+        const nestedEntries = Object.entries(value.value);
+        const nestedObjectExpr = nestedEntries.map(
+          ([nestedKey, nestedValue]) => {
+            const nestedValueExpr = getExpression(nestedValue);
+            return `${nestedKey}: ${nestedValueExpr}`;
+          },
+        );
+        return `${key}: { ${nestedObjectExpr.join(", ")} }`;
+      }
+      return `${key}: ${valueExpr}`;
+    });
     return `{ ${objectExpr.join(", ")} }`;
   }
   return "";