[hir] Parse and codegen FunctionExpression

compiler/forget/src/HIR/BuildHIR.ts

@@ -1148,6 +1148,22 @@ function lowerExpression(
         loc: exprLoc,
       };
     }
+    case "FunctionExpression": {
+      const expr = exprPath as NodePath<t.FunctionExpression>;
+      const name: string | null = expr.get("id")?.node?.name ?? null;
+      const body = expr.get("body").node;
+      const params: Array<string> = expr.get("params").map((p) => {
+        todoInvariant(p.isIdentifier(), "handle non identifier params");
+        return p.node.name;
+      });
+      return {
+        kind: "FunctionExpression",
+        name,
+        body,
+        params,
+        loc: exprLoc,
+      };
+    }
     default: {
       todo(`lowerExpression(${exprNode.type})`);
       //   assertExhaustive(

compiler/forget/src/HIR/Codegen.ts

@@ -498,6 +498,13 @@ export function codegenInstructionValue(
       value = codegenPlace(temp, instrValue);
       break;
     }
+    case "FunctionExpression": {
+      const id =
+        instrValue.name !== null ? t.identifier(instrValue.name) : null;
+      const params = instrValue.params.map((p) => t.identifier(p));
+      value = t.functionExpression(id, params, instrValue.body);
+      break;
+    }
     default: {
       assertExhaustive(
         instrValue,

compiler/forget/src/HIR/HIR.ts

@@ -309,6 +309,12 @@ export type InstructionData =
   | { kind: "ComputedStore"; object: Place; property: Place; value: Place }
   // load `object[index]` - like PropertyLoad but with a dynamic property
   | { kind: "ComputedLoad"; object: Place; property: Place }
+  | {
+      kind: "FunctionExpression";
+      name: string | null;
+      params: Array<string>;
+      body: t.BlockStatement;
+    }
 
   /**
    * Catch-all for statements such as type imports, nested class declarations, etc

compiler/forget/src/HIR/PrintHIR.ts

@@ -290,6 +290,12 @@ export function printInstructionValue(instrValue: InstructionValue): string {
       )}] = ${printPlace(instrValue.value)}`;
       break;
     }
+    case "FunctionExpression": {
+      const params = instrValue.params.join(",");
+      const body = generate(instrValue.body).code;
+      value = `Function ${instrValue.name}(${params}){${body}}`;
+      break;
+    }
     default: {
       assertExhaustive(
         instrValue,

compiler/forget/src/HIR/visitors.ts

@@ -89,6 +89,7 @@ export function* eachInstructionValueOperand(
     }
     case "OtherStatement":
     case "Primitive":
+    case "FunctionExpression":
     case "JSXText": {
       break;
     }
@@ -175,6 +176,7 @@ export function mapInstructionOperands(
     }
     case "OtherStatement":
     case "Primitive":
+    case "FunctionExpression":
     case "JSXText": {
       break;
     }

compiler/forget/src/Inference/InferReferenceEffects.ts

@@ -551,6 +551,12 @@ function inferBlock(env: Environment, block: BasicBlock) {
         lvalueEffect = Effect.Store;
         break;
       }
+      case "FunctionExpression": {
+        valueKind = ValueKind.Mutable;
+        effectKind = Effect.Read;
+        lvalueEffect = Effect.Store;
+        break;
+      }
       case "UnaryExpression": {
         // TODO check that value must be a primitive, or make conditional based on the operator
         valueKind = ValueKind.Immutable;

compiler/forget/src/ReactiveScopes/InferReactiveScopeVariables.ts

@@ -173,6 +173,7 @@ function mayAllocate(value: InstructionValue): boolean {
     case "NewExpression":
     case "ObjectExpression":
     case "OtherStatement":
+    case "FunctionExpression":
     case "UnaryExpression": {
       return true;
     }

compiler/forget/src/ReactiveScopes/PropagateScopeDependencies.ts

@@ -313,6 +313,7 @@ function valueKind(value: InstructionValue): DeclKind {
     case "JsxFragment":
     case "NewExpression":
     case "ObjectExpression":
+    case "FunctionExpression":
     case "OtherStatement":
     case "UnaryExpression": {
       return DeclKind.Dynamic;

compiler/forget/src/__tests__/fixtures/hir/simple-function-1.expect.md

@@ -0,0 +1,34 @@
+
+## Input
+
+```javascript
+function component() {
+  let x = function (a) {
+    a.foo();
+  };
+  return x;
+}
+
+```
+
+## Code
+
+```javascript
+function component() {
+  const $ = React.useMemoCache();
+  let x;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    x = function (a) {
+      a.foo();
+    };
+
+    $[0] = x;
+  } else {
+    x = $[0];
+  }
+
+  return x;
+}
+
+```
+      

compiler/forget/src/__tests__/fixtures/hir/simple-function-1.js

@@ -0,0 +1,6 @@
+function component() {
+  let x = function (a) {
+    a.foo();
+  };
+  return x;
+}