@glint/ember-tsc 1.8.1 → 1.8.3

package/src/transform/template/inlining/tagged-strings.ts

@@ -2,7 +2,7 @@ import {
   GlintEmitMetadata,
   GlintSpecialForm,
   GlintSpecialFormConfig,
-  GlintTagConfig,
+  GlintTemplateConfig,
 } from '@glint/ember-tsc/config-types';
 import type ts from 'typescript';
 import { GlintEnvironment } from '../../../config/index.js';
@@ -66,10 +66,10 @@ export function calculateTaggedTemplateSpans(
       suffix: script.contents.slice(templateLocation.contentEnd, templateLocation.end),
     };
 
-    let preamble = [];
-    if (!info.importedBinding.synthetic) {
-      preamble.push(`${tag.text};`);
-    }
+    // The `<template>` form's backing import is always compiler-synthesized
+    // (see `resolveTagInfo`), so there is never a user-written tag binding to
+    // reference in a preamble.
+    let preamble: Array<string> = [];
 
     let specialForms = collectSpecialForms(importedBindings, info.tagConfig.specialForms ?? {});
 
@@ -164,22 +164,28 @@ function resolveTagInfo(
   importedBindings: ImportedBindings,
   tag: ts.Identifier,
   environment: GlintEnvironment,
-): { importedBinding: ImportedBinding; tagConfig: GlintTagConfig } | undefined {
+): { importedBinding: ImportedBinding; tagConfig: GlintTemplateConfig } | undefined {
   let importedBinding = importedBindings[tag.text];
   if (!importedBinding) {
     return;
   }
 
-  for (let [importSource, tags] of Object.entries(environment.getConfiguredTemplateTags())) {
-    for (let [importSpecifier, tagConfig] of Object.entries(tags)) {
-      if (
-        importSource === importedBinding.source &&
-        importSpecifier === importedBinding.specifier
-      ) {
-        return { importedBinding, tagConfig };
-      }
-    }
+  // Only the compiler-generated `<template>` form is processed. Its backing
+  // import is synthesized by the gts/gjs transform (see `addTagImport` in
+  // `environment-ember-template-imports/-private/environment/transform.ts`) and
+  // therefore has no position in the original source. User-authored tagged
+  // templates (`hbs`...``) have a real import and are deliberately ignored —
+  // Glint no longer supports tagged-string templates.
+  if (!importedBinding.synthetic) {
+    return;
   }
+
+  let tagConfig = environment.getTemplateConfig();
+  if (!tagConfig) {
+    return;
+  }
+
+  return { importedBinding, tagConfig };
 }
 
 type ImportedBinding = { specifier: string; source: string; synthetic: boolean };

package/src/transform/template/rewrite-module.ts

@@ -160,12 +160,12 @@ function calculateCorrelatedSpans(
   ts.transform(ast, [
     (context) =>
       function visit<T extends ts.Node>(node: T): T {
-        // Here we look for ```hbs``` tagged template expressions, originally introduced
-        // in the now-removed GlimmerX environment. We can consider getting rid of this, but
-        // then again there are still some use cases in the wild (e.g. Glimmer Next / GXT)
-        // where have tagged templates closing over outer scope is desirable:
-        // https://github.com/lifeart/glimmer-next/tree/master/glint-environment-gxt
-        // https://discord.com/channels/480462759797063690/717767358743183412/1259061848632721480
+        // The gts/gjs preprocessor rewrites every `<template>` into a tagged
+        // template expression using a compiler-synthesized tag (see
+        // `environment-ember-template-imports/-private/environment/{preprocess,transform}.ts`).
+        // We look for those tagged templates here and hand them to
+        // `calculateTaggedTemplateSpans`, which only processes the synthesized
+        // tag — user-authored `hbs`...`` tagged strings are not supported.
         if (ts.isTaggedTemplateExpression(node)) {
           let meta = emitMetadata.get(node);
           let result = calculateTaggedTemplateSpans(ts, node, meta, script, environment);

package/src/transform/template/template-to-typescript.ts

@@ -553,7 +553,17 @@ export function templateToTypescript(
           let isGlobal = globals ? globals.includes(name) : true;
           let form = specialForms[name];
 
-          return { name, form, requiresConsumption: !isGlobal };
+          // Operator special forms (`===`, `!==`, `&&`, `||`, `!`) emit only the
+          // operator expression — never a reference to the keyword itself. For a
+          // documented global keyword (e.g. `eq`/`neq`) that would drop hover
+          // docs and go-to-definition, so we still emit a discarded reference to
+          // it. Narrowing is preserved: the keyword is emitted as the throwaway
+          // first operand of a comma expression whose value is the operator
+          // expression (`(noop(eq), (a === b))`).
+          let isOperatorForm =
+            form === '===' || form === '!==' || form === '&&' || form === '||' || form === '!';
+
+          return { name, form, requiresConsumption: !isGlobal || isOperatorForm };
         }
       }
 

package/types/-private/dsl/globals.d.ts

@@ -4,14 +4,7 @@ import * as VM from '@glint/template/-private/keywords';
 
 import { ActionKeyword } from '../intrinsics/action';
 import { ArrayHelper, HashHelper } from '../intrinsics/array-hash';
-import {
-  EqHelper,
-  GtHelper,
-  GteHelper,
-  LtHelper,
-  LteHelper,
-  NeqHelper,
-} from '../intrinsics/comparison';
+import { GtHelper, GteHelper, LtHelper, LteHelper } from '../intrinsics/comparison';
 import { EachKeyword } from '../intrinsics/each';
 import { EachInKeyword } from '../intrinsics/each-in';
 import { ElementHelper } from '../intrinsics/element';
@@ -331,7 +324,8 @@ interface KeywordsForEmber71Members {
    *
    * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/eq
    */
-  eq: EqHelper;
+  // `{{eq}}` is emitted as the native `===` operator in `ember-tsc`.
+  eq: void;
 
   /**
    * `{{fn}}` is a helper that receives a function and some arguments, and
@@ -459,7 +453,8 @@ interface KeywordsForEmber71Members {
    *
    * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/neq
    */
-  neq: NeqHelper;
+  // `{{neq}}` is emitted as the native `!==` operator in `ember-tsc`.
+  neq: void;
 
   /**
    * The `{{not}}` helper returns the logical negation of its argument using

package/types/-private/intrinsics/array-hash.d.ts

@@ -5,7 +5,7 @@ import { DirectInvokable } from '@glint/template/-private/integration';
  * Built-in keyword in ember-source >= 7.1 (RFC 1000).
  */
 export type ArrayHelper = DirectInvokable<{
-  <T extends unknown[]>(...args: T): T;
+  <const T extends unknown[]>(...args: T): T;
 }>;
 
 /**
@@ -13,5 +13,5 @@ export type ArrayHelper = DirectInvokable<{
  * Built-in keyword in ember-source >= 7.1 (RFC 999).
  */
 export type HashHelper = DirectInvokable<{
-  <T extends Record<string, unknown>>(args: T): T;
+  <const T extends Record<string, unknown>>(args: T): T;
 }>;

package/types/-private/intrinsics/comparison.d.ts

@@ -1,19 +1,12 @@
 import { DirectInvokable } from '@glint/template/-private/integration';
 
-/**
- * `(eq a b)` — strict equality of two values. Built-in keyword in
- * ember-source >= 7.1 (RFC 561). The result is narrowed when both sides are
- * literal types so templates such as `{{#if (eq this.kind "primary")}}` get
- * accurate type information.
- */
-export type EqHelper = DirectInvokable<{
-  <A, B>(a: A, b: B): [A] extends [B] ? ([B] extends [A] ? true : boolean) : boolean;
-}>;
-
-/** `(neq a b)` — strict inequality. Built-in keyword in ember-source >= 7.1. */
-export type NeqHelper = DirectInvokable<{
-  <A, B>(a: A, b: B): [A] extends [B] ? ([B] extends [A] ? false : boolean) : boolean;
-}>;
+// NOTE: `eq`/`neq` (RFC 561) are not represented here. Because their runtime is
+// exactly `left === right` / `left !== right`, they are emitted as the native
+// `===`/`!==` operators (see the `ember-template-imports` environment's
+// `specialForms`) — which, unlike a boolean-returning helper type, lets
+// TypeScript narrow discriminated unions in `{{#if (eq foo.kind "a")}}`. The
+// `lt`/`lte`/`gt`/`gte` keywords below have no narrowing benefit and remain
+// ordinary helpers.
 
 /** `(lt a b)` — numeric less-than. Built-in keyword in ember-source >= 7.1. */
 export type LtHelper = DirectInvokable<{

package/types/-private/intrinsics/element.d.ts

@@ -6,8 +6,28 @@ import { DirectInvokable } from '@glint/template/-private/integration';
  * name. Built-in keyword in ember-source >= 7.1 (RFC 389).
  */
 export type ElementHelper = DirectInvokable<{
-  (tagName: string): ComponentLike<{
-    Element: Element;
+  // `const K` preserves the literal tag name (e.g. `"video"`) through Glint's
+  // `resolve()` inference; without it TypeScript widens the argument to `string`
+  // and narrowing collapses to the base `Element`. The `string & {}` member lets
+  // a genuinely dynamic (non-literal) tag name still match and fall back to
+  // `Element`, covering both HTML and SVG.
+  <const K extends keyof HTMLElementTagNameMap | keyof SVGElementTagNameMap | (string & {})>(
+    tagName: K,
+  ): ComponentLike<{
+    // A known HTML or SVG tag name narrows to the corresponding element type.
+    // When a name exists in both maps (e.g. `a`, `script`, `style`, `title`)
+    // the HTML element wins, matching the default (non-SVG) namespace at
+    // runtime. An empty string renders the block without a wrapping element, so
+    // there is no element to receive attributes (`null`, which makes applying
+    // any attribute a type error). Any other (dynamic) tag name falls back to
+    // the base `Element`, covering both HTML and SVG.
+    Element: K extends keyof HTMLElementTagNameMap
+      ? HTMLElementTagNameMap[K]
+      : K extends keyof SVGElementTagNameMap
+        ? SVGElementTagNameMap[K]
+        : K extends ''
+          ? null
+          : Element;
     Args: Record<string, unknown>;
     Blocks: { default: [] };
   }>;

package/types/-private/intrinsics/get.d.ts

@@ -1,12 +1,16 @@
 import { DirectInvokable } from '@glint/template/-private/integration';
 import ObjectProxy from '@ember/object/proxy';
-import '@ember/object/-private/types';
 
 // This hack lets us support both the stable/preview types from `ember-source`
 // and the classic types still live on DefinitelyTyped. If using the DT types,
-// this acts as a declaration merge for a module which is then integrated via
-// the rest of the DT types. If using the stable/preview types, this ends up
-// being a no-op.
+// the `declare module` below acts as a declaration merge for a module which is
+// then integrated via the rest of the DT types. If using the stable/preview
+// types, the module does not exist and this ends up being a no-op.
+//
+// Note: we intentionally do *not* add a side-effect `import '@ember/object/-private/types'`
+// here. TypeScript 6.0 errors (TS2882) on a side-effect import of a module that
+// cannot be resolved, which is exactly the no-op (ember-source) case above. The
+// `declare module` augmentation still merges into the DT module when it exists.
 declare const GetSetMarker: unique symbol;
 declare module '@ember/object/-private/types' {
   interface ComputedPropertyMarker<Get, Set = Get> {

package/types/-private/intrinsics/truth-helpers.d.ts

@@ -1,32 +1,49 @@
 import { DirectInvokable } from '@glint/template/-private/integration';
 
-import type { FirstFalsy, FirstTruthy, MaybeTruthy, TruthConvert } from './truth-convert';
+import type { Falsy, FirstFalsy, FirstTruthy, MaybeTruthy } from './truth-convert';
 
 /**
  * `(and a b ...)` — short-circuit logical AND. Returns the first falsy
  * positional argument or the last argument. Available as a built-in keyword
  * in ember-source >= 7.1 (RFC 560).
+ *
+ * The runtime requires **at least two** arguments (it throws otherwise), so the
+ * signature pins two leading positionals before the rest.
  */
 export type AndHelper = DirectInvokable<{
-  <T extends MaybeTruthy[]>(...args: T): FirstFalsy<T>;
+  <A extends MaybeTruthy, B extends MaybeTruthy, Rest extends MaybeTruthy[]>(
+    a: A,
+    b: B,
+    ...rest: Rest
+  ): FirstFalsy<[A, B, ...Rest]>;
 }>;
 
 /**
  * `(or a b ...)` — short-circuit logical OR. Returns the first truthy
  * positional argument or the last argument. Available as a built-in keyword
  * in ember-source >= 7.1 (RFC 560).
+ *
+ * The runtime requires **at least two** arguments (it throws otherwise), so the
+ * signature pins two leading positionals before the rest.
  */
 export type OrHelper = DirectInvokable<{
-  <T extends MaybeTruthy[]>(...args: T): FirstTruthy<T>;
+  <A extends MaybeTruthy, B extends MaybeTruthy, Rest extends MaybeTruthy[]>(
+    a: A,
+    b: B,
+    ...rest: Rest
+  ): FirstTruthy<[A, B, ...Rest]>;
 }>;
 
 /**
- * `(not value)` — boolean negation using truthy semantics matching the rest
- * of Ember's template-side helpers. Built-in keyword in ember-source >= 7.1
- * (RFC 560).
+ * `(not value)` — boolean negation using Handlebars truthiness semantics.
+ * Built-in keyword in ember-source >= 7.1 (RFC 560).
+ *
+ * Typed as a type predicate over Ember's `Falsy` type so that using it as a
+ * condition narrows the operand: in `{{#if (not value)}}` the operand is
+ * narrowed to its falsy members, and in the `{{else}}` branch to its truthy
+ * members. (As a predicate its *value* is `boolean` rather than a `true`/
+ * `false` literal — narrowing in conditions is the more useful guarantee.)
  */
 export type NotHelper = DirectInvokable<{
-  <T>(
-    value: T,
-  ): TruthConvert<T> extends true ? false : TruthConvert<T> extends false ? true : boolean;
+  <T>(value: T): value is Extract<T, Falsy>;
 }>;