RFC#562 - {{and}}, {{or}}, {{not}} as keywords

Add boolean logic helpers and register them as built-in keywords
so they no longer need to be imported in strict-mode (gjs/gts) templates.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: NullVoxPopuli

packages/@ember/-internals/glimmer/lib/resolver.ts

@@ -18,12 +18,15 @@ import {
   setInternalHelperManager,
 } from '@glimmer/manager';
 import {
+  and,
   array,
   concat,
   fn,
   get,
   hash,
+  not,
   on,
+  or,
   templateOnlyComponent,
   TEMPLATE_ONLY_COMPONENT_MANAGER,
 } from '@glimmer/runtime';
@@ -103,11 +106,14 @@ const BUILTIN_KEYWORD_HELPERS: Record<string, object> = {
 
 const BUILTIN_HELPERS: Record<string, object> = {
   ...BUILTIN_KEYWORD_HELPERS,
+  and,
   array,
   concat,
   fn,
   get,
   hash,
+  not,
+  or,
   'unique-id': uniqueId,
 };
 

packages/@ember/helper/index.ts

@@ -10,6 +10,9 @@ import {
   concat as glimmerConcat,
   get as glimmerGet,
   fn as glimmerFn,
+  and as glimmerAnd,
+  or as glimmerOr,
+  not as glimmerNot,
 } from '@glimmer/runtime';
 import { element as glimmerElement, uniqueId as glimmerUniqueId } from '@ember/-internals/glimmer';
 import { type Opaque } from '@ember/-internals/utility-types';
@@ -511,4 +514,57 @@ export interface ElementHelper extends Opaque<'helper:element'> {}
 export const uniqueId = glimmerUniqueId;
 export type UniqueIdHelper = typeof uniqueId;
 
+/**
+ * The `{{and}}` helper returns the last truthy value if all arguments are
+ * truthy, or the first falsy value.
+ *
+ * ```js
+ * import { and } from '@ember/helper';
+ *
+ * <template>
+ *   {{if (and @isAdmin @isLoggedIn) "Welcome, admin!" "Access denied"}}
+ * </template>
+ * ```
+ *
+ * **NOTE:** In strict-mode (gjs/gts) templates, `and` is available as a
+ * keyword and does not need to be imported.
+ */
+export const and = glimmerAnd as AndHelper;
+export interface AndHelper extends Opaque<'helper:and'> {}
+
+/**
+ * The `{{or}}` helper returns the first truthy value, or the last value if
+ * none are truthy.
+ *
+ * ```js
+ * import { or } from '@ember/helper';
+ *
+ * <template>
+ *   {{if (or @hasAccess @isAdmin) "Welcome!" "No access"}}
+ * </template>
+ * ```
+ *
+ * **NOTE:** In strict-mode (gjs/gts) templates, `or` is available as a
+ * keyword and does not need to be imported.
+ */
+export const or = glimmerOr as OrHelper;
+export interface OrHelper extends Opaque<'helper:or'> {}
+
+/**
+ * The `{{not}}` helper returns the logical negation of its argument.
+ *
+ * ```js
+ * import { not } from '@ember/helper';
+ *
+ * <template>
+ *   {{if (not @isDisabled) "Enabled" "Disabled"}}
+ * </template>
+ * ```
+ *
+ * **NOTE:** In strict-mode (gjs/gts) templates, `not` is available as a
+ * keyword and does not need to be imported.
+ */
+export const not = glimmerNot as NotHelper;
+export interface NotHelper extends Opaque<'helper:not'> {}
+
 /* eslint-enable @typescript-eslint/no-empty-object-type */

packages/@ember/template-compiler/lib/compile-options.ts

@@ -1,4 +1,4 @@
-import { fn } from '@ember/helper';
+import { and, fn, not, or } from '@ember/helper';
 import { on } from '@ember/modifier';
 import { assert } from '@ember/debug';
 import {
@@ -25,8 +25,11 @@ function malformedComponentLookup(string: string) {
 export const RUNTIME_KEYWORDS_NAME = '__ember_keywords__';
 
 export const keywords: Record<string, unknown> = {
+  and,
   fn,
+  not,
   on,
+  or,
 };
 
 function buildCompileOptions(_options: EmberPrecompileOptions): EmberPrecompileOptions {

packages/@ember/template-compiler/lib/plugins/auto-import-builtins.ts

@@ -30,11 +30,29 @@ export default function autoImportBuiltins(env: EmberASTPluginEnvironment): ASTP
         if (isFn(node, hasLocal)) {
           rewriteKeyword(env, node, 'fn', '@ember/helper');
         }
+        if (isAnd(node, hasLocal)) {
+          rewriteKeyword(env, node, 'and', '@ember/helper');
+        }
+        if (isOr(node, hasLocal)) {
+          rewriteKeyword(env, node, 'or', '@ember/helper');
+        }
+        if (isNot(node, hasLocal)) {
+          rewriteKeyword(env, node, 'not', '@ember/helper');
+        }
       },
       MustacheStatement(node: AST.MustacheStatement) {
         if (isFn(node, hasLocal)) {
           rewriteKeyword(env, node, 'fn', '@ember/helper');
         }
+        if (isAnd(node, hasLocal)) {
+          rewriteKeyword(env, node, 'and', '@ember/helper');
+        }
+        if (isOr(node, hasLocal)) {
+          rewriteKeyword(env, node, 'or', '@ember/helper');
+        }
+        if (isNot(node, hasLocal)) {
+          rewriteKeyword(env, node, 'not', '@ember/helper');
+        }
       },
     },
   };
@@ -68,3 +86,24 @@ function isFn(
 ): node is (AST.MustacheStatement | AST.SubExpression) & { path: AST.PathExpression } {
   return isPath(node.path) && node.path.original === 'fn' && !hasLocal('fn');
 }
+
+function isAnd(
+  node: AST.MustacheStatement | AST.SubExpression,
+  hasLocal: (k: string) => boolean
+): node is (AST.MustacheStatement | AST.SubExpression) & { path: AST.PathExpression } {
+  return isPath(node.path) && node.path.original === 'and' && !hasLocal('and');
+}
+
+function isOr(
+  node: AST.MustacheStatement | AST.SubExpression,
+  hasLocal: (k: string) => boolean
+): node is (AST.MustacheStatement | AST.SubExpression) & { path: AST.PathExpression } {
+  return isPath(node.path) && node.path.original === 'or' && !hasLocal('or');
+}
+
+function isNot(
+  node: AST.MustacheStatement | AST.SubExpression,
+  hasLocal: (k: string) => boolean
+): node is (AST.MustacheStatement | AST.SubExpression) & { path: AST.PathExpression } {
+  return isPath(node.path) && node.path.original === 'not' && !hasLocal('not');
+}

packages/@glimmer-workspace/integration-tests/test/keywords/and-or-not-runtime-test.ts

@@ -0,0 +1,150 @@
+import { jitSuite, RenderTest, test } from '@glimmer-workspace/integration-tests';
+
+import { template } from '@ember/template-compiler/runtime';
+
+class KeywordAndOrNotRuntime extends RenderTest {
+  static suiteName = 'keyword helpers: and, or, not (runtime)';
+
+  // --- and (runtime keyword, no explicit import) ---
+
+  @test
+  'and: explicit scope without import'() {
+    const compiled = template('{{if (and a b) "yes" "no"}}', {
+      strictMode: true,
+      scope: () => ({ a: true, b: true }),
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('yes');
+  }
+
+  @test
+  'and: implicit scope (eval)'() {
+    let a = true;
+    let b = 'hello';
+
+    hide(a);
+    hide(b);
+
+    const compiled = template('{{if (and a b) "yes" "no"}}', {
+      strictMode: true,
+      eval() {
+        return eval(arguments[0]);
+      },
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('yes');
+  }
+
+  @test
+  'and: returns falsy when one arg is falsy'() {
+    const compiled = template('{{if (and a b) "yes" "no"}}', {
+      strictMode: true,
+      scope: () => ({ a: true, b: 0 }),
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('no');
+  }
+
+  // --- or (runtime keyword, no explicit import) ---
+
+  @test
+  'or: explicit scope without import'() {
+    const compiled = template('{{if (or a b) "yes" "no"}}', {
+      strictMode: true,
+      scope: () => ({ a: false, b: true }),
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('yes');
+  }
+
+  @test
+  'or: implicit scope (eval)'() {
+    let a = false;
+    let b = 'hello';
+
+    hide(a);
+    hide(b);
+
+    const compiled = template('{{if (or a b) "yes" "no"}}', {
+      strictMode: true,
+      eval() {
+        return eval(arguments[0]);
+      },
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('yes');
+  }
+
+  @test
+  'or: returns no when all falsy'() {
+    const compiled = template('{{if (or a b) "yes" "no"}}', {
+      strictMode: true,
+      scope: () => ({ a: false, b: 0 }),
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('no');
+  }
+
+  // --- not (runtime keyword, no explicit import) ---
+
+  @test
+  'not: explicit scope without import'() {
+    const compiled = template('{{if (not a) "yes" "no"}}', {
+      strictMode: true,
+      scope: () => ({ a: false }),
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('yes');
+  }
+
+  @test
+  'not: implicit scope (eval)'() {
+    let a = false;
+
+    hide(a);
+
+    const compiled = template('{{if (not a) "yes" "no"}}', {
+      strictMode: true,
+      eval() {
+        return eval(arguments[0]);
+      },
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('yes');
+  }
+
+  @test
+  'not: returns no for truthy'() {
+    const compiled = template('{{if (not a) "yes" "no"}}', {
+      strictMode: true,
+      scope: () => ({ a: 'hello' }),
+    });
+
+    this.renderComponent(compiled);
+    this.assertHTML('no');
+  }
+}
+
+jitSuite(KeywordAndOrNotRuntime);
+
+/**
+ * This function is used to hide a variable from the transpiler, so that it
+ * doesn't get removed as "unused". It does not actually do anything with the
+ * variable, it just makes it be part of an expression that the transpiler
+ * won't remove.
+ *
+ * It's a bit of a hack, but it's necessary for testing.
+ *
+ * @param variable The variable to hide.
+ */
+const hide = (variable: unknown) => {
+  new Function(`return (${JSON.stringify(variable)});`);
+};