feat: Remove conditional flattening - all helpers now use StackExpression

- Modified ResolvedCallExpression to always use flattening
- Removed helper functions for checking nested calls (no longer needed)
- Updated StackOperation type to temporarily allow any TupleExpression
- Added fallback in compileStackOperation to handle unflatted expressions

This creates a mixed system where StackExpression can contain both:
- Flattened operations (PushConstant, CallHelper, etc.)
- Nested expressions (Curry, Not, etc.) that delegate back to expr()

Next steps: Incrementally add flattening for each expression type

Author: wycats

packages/@glimmer/compiler/lib/passes/2-encoding/expressions.ts

@@ -236,36 +236,6 @@ export function callArgs(
   return encodeCallArgs(positionalArgs, namedArgs, { insertAtPrefix: false });
 }
 
-// Helper to check if any arguments contain nested helper calls
-function hasNestedHelperCalls(args: mir.Args): boolean {
-  // Check positional arguments
-  if (args.positional.list.isPresent) {
-    for (const arg of args.positional.list.toArray()) {
-      if (isNestedHelperCall(arg)) {
-        return true;
-      }
-    }
-  }
-
-  // Check named arguments
-  if (args.named.entries.isPresent) {
-    for (const entry of args.named.entries.toArray()) {
-      if (isNestedHelperCall(view.get(entry.value))) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-function isNestedHelperCall(expr: mir.ExpressionNode | ASTv2.UnresolvedBinding): boolean {
-  return expr.type === 'ResolvedCallExpression' || expr.type === 'CallExpression';
-}
-
-function shouldFlattenExpression(expr: mir.ResolvedCallExpression): boolean {
-  return hasNestedHelperCalls(expr.args);
-}
 
 function flattenResolvedCallExpression(
   expr: mir.ResolvedCallExpression
@@ -372,9 +342,9 @@ function flattenExpression(
       ) {
         operations.push(encoded as WireFormat.Expressions.StackOperation);
       } else {
-        // For complex expressions we don't support flattening yet,
-        // fall back to not flattening
-        throw new Error(`Cannot flatten expression type with opcode ${opcode}`);
+        // For expressions we don't support flattening yet (like Curry, Not, etc.),
+        // push the encoded expression as-is. The opcode compiler will handle it.
+        operations.push(encoded as WireFormat.Expressions.StackOperation);
       }
     } else {
       // It's a literal value, push it as a constant
@@ -481,17 +451,9 @@ function InterpolateExpression({
 
 function ResolvedCallExpression(
   expr: mir.ResolvedCallExpression
-): WireFormat.Expressions.SomeCallHelper | WireFormat.Expressions.StackExpression {
-  // Check if we should flatten this expression
-  if (shouldFlattenExpression(expr)) {
-    return flattenResolvedCallExpression(expr);
-  }
-
-  return [
-    Op.CallResolved,
-    view.get(expr.callee).symbol,
-    callArgs(expr.args.positional, expr.args.named),
-  ];
+): WireFormat.Expressions.StackExpression {
+  // Always flatten all helper expressions for unified handling
+  return flattenResolvedCallExpression(expr);
 }
 
 function CallExpression({

packages/@glimmer/interfaces/lib/compile/wire-format/api.ts

@@ -232,6 +232,7 @@ export namespace Expressions {
   export type Undefined = [UndefinedOpcode];
 
   // Operations that can appear in a flattened stack expression
+  // TODO: This is transitional - eventually only flat operations will be allowed
   export type StackOperation =
     | PushImmediate
     | PushConstant
@@ -244,7 +245,9 @@ export namespace Expressions {
     | GetLexicalSymbol
     | GetKeyword
     | GetDynamicVar
-    | Undefined;
+    | Undefined
+    // Temporarily allow any expression while we transition to full flattening
+    | TupleExpression;
 
   // For now, keep existing GetPath for backward compatibility
   // and add new flattened form

packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/expr.ts

@@ -129,7 +129,10 @@ function compileStackOperation(
     }
 
     default:
-      exhausted(operation);
+      // For nested expressions that we haven't flattened yet (Curry, Not, etc.),
+      // delegate back to expr() to handle them. This is temporary - once all
+      // expressions are flattened, this case will be removed.
+      expr(encode, operation as WireFormat.Expression);
   }
 }