@glint/ember-tsc 1.8.2 → 1.8.4

package/src/config/environment.ts

@@ -2,7 +2,7 @@ import {
   GlintEnvironmentConfig,
   GlintExtensionConfig,
   GlintExtensionsConfig,
-  GlintTagsConfig,
+  GlintTemplateConfig,
   SourceKind,
 } from '@glint/ember-tsc/config-types';
 import * as path from 'node:path';
@@ -20,14 +20,14 @@ export const DEFAULT_EXTENSIONS: GlintExtensionsConfig = {
  * glint environments (e.g. ember-template-imports).
  */
 export class GlintEnvironment {
-  private tagConfig: GlintTagsConfig;
+  private templateConfig: GlintTemplateConfig | undefined;
   private extensionsConfig: GlintExtensionsConfig;
 
   public constructor(
     public readonly names: Array<string>,
     config: GlintEnvironmentConfig,
   ) {
-    this.tagConfig = config.tags ?? {};
+    this.templateConfig = config.template;
     // when is this populated? what is config?
     this.extensionsConfig = config.extensions ?? {};
   }
@@ -58,32 +58,12 @@ export class GlintEnvironment {
       }
     }
 
-    let tags: GlintTagsConfig = {};
     let extensions: GlintExtensionsConfig = { ...DEFAULT_EXTENSIONS };
 
     const envUserConfig = { additionalGlobals, additionalSpecialForms };
 
     let config = emberTemplateImportsEnvironment(envUserConfig) as GlintEnvironmentConfig;
 
-    if (config.tags) {
-      for (let [importSource, specifiers] of Object.entries(config.tags)) {
-        tags[importSource] ??= {};
-        for (let [importSpecifier, tagConfig] of Object.entries(specifiers)) {
-          if (importSpecifier in tags[importSource]) {
-            throw new SilentError(
-              'Multiple configured Glint environments attempted to define behavior for the tag `' +
-                importSpecifier +
-                "` in module '" +
-                importSource +
-                "'.",
-            );
-          }
-
-          tags[importSource][importSpecifier] = tagConfig;
-        }
-      }
-    }
-
     if (config.extensions) {
       for (let [extension, extensionConfig] of Object.entries(config.extensions)) {
         if (extension in extensions) {
@@ -98,7 +78,7 @@ export class GlintEnvironment {
       }
     }
 
-    return new GlintEnvironment(Object.keys(config), { tags, extensions });
+    return new GlintEnvironment(Object.keys(config), { template: config.template, extensions });
   }
 
   public getSourceKind(fileName: string): SourceKind | 'unknown' {
@@ -118,11 +98,12 @@ export class GlintEnvironment {
   }
 
   /**
-   * Returns an array of template tags that should be rewritten according to this
-   * config object, along with an import specifier indicating where the template types
-   * for each tag can be found.
+   * Returns the configuration for the built-in `<template>` form — the types
+   * module its transformed output references, plus the keyword globals and
+   * special forms available inside it. Returns `undefined` if the active
+   * environment defines no template form.
    */
-  public getConfiguredTemplateTags(): GlintTagsConfig {
-    return this.tagConfig;
+  public getTemplateConfig(): GlintTemplateConfig | undefined {
+    return this.templateConfig;
   }
 }

package/src/config/types.cts

@@ -10,7 +10,7 @@ export type GlintConfigInput = {
 };
 
 export type GlintEnvironmentConfig = {
-  tags?: GlintTagsConfig;
+  template?: GlintTemplateConfig;
   extensions?: GlintExtensionsConfig;
 };
 
@@ -72,14 +72,14 @@ export type GlintExtensionsConfig = {
   [extension: string]: GlintExtensionConfig;
 };
 
-export type GlintTagConfig = {
+/**
+ * Configuration for the single, built-in template form (the `<template>` tag in
+ * `.gts`/`.gjs` files). Glint no longer supports user-authored or
+ * environment-registered template tags, so this is internal compiler
+ * configuration rather than a user-facing extension point.
+ */
+export type GlintTemplateConfig = {
   typesModule: string;
   globals?: Array<string>;
   specialForms?: GlintSpecialFormConfig;
 };
-
-export type GlintTagsConfig = {
-  [importSource: string]: {
-    [importSpecifier: string]: GlintTagConfig;
-  };
-};

package/src/environment-ember-template-imports/-private/environment/index.ts

@@ -97,37 +97,42 @@ export default function emberTemplateImportsEnvironment(
   ];
 
   return {
-    tags: {
-      '@glint/ember-tsc/environment-ember-template-imports/-private/tag': {
-        hbs: {
-          typesModule: '@glint/ember-tsc/-private/dsl',
-          specialForms: {
-            globals: {
-              if: 'if',
-              unless: 'if-not',
-              yield: 'yield',
-              component: 'bind-invokable',
-              modifier: 'bind-invokable',
-              helper: 'bind-invokable',
-              ...additionalGlobalSpecialForms,
-            },
-            imports: {
-              '@ember/helper': {
-                array: 'array-literal',
-                hash: 'object-literal',
-                ...additionalSpecialForms.imports?.['@ember/helper'],
-              },
-              ...additionalSpecialForms.imports,
-            },
+    template: {
+      typesModule: '@glint/ember-tsc/-private/dsl',
+      specialForms: {
+        globals: {
+          if: 'if',
+          unless: 'if-not',
+          yield: 'yield',
+          component: 'bind-invokable',
+          modifier: 'bind-invokable',
+          helper: 'bind-invokable',
+          // The RFC 561 `eq`/`neq` keywords are exactly `===`/`!==` at runtime,
+          // so we emit them as the native operators. Beyond matching runtime
+          // semantics, this lets TypeScript's control-flow analysis narrow
+          // discriminated unions — e.g. `{{#if (eq foo.kind "a")}}` narrows
+          // `foo` to the matching variant inside the block, which a
+          // boolean-returning helper type cannot do.
+          ...(hasEmber71BuiltIns()
+            ? ({ eq: '===', neq: '!==' } satisfies GlintSpecialFormConfig['globals'])
+            : {}),
+          ...additionalGlobalSpecialForms,
+        },
+        imports: {
+          '@ember/helper': {
+            array: 'array-literal',
+            hash: 'object-literal',
+            ...additionalSpecialForms.imports?.['@ember/helper'],
           },
-          globals: [
-            ...globalsForEmber,
-            ...(hasEmber71BuiltIns() ? globalsForEmber71 : []),
-            ...Object.keys(additionalGlobalSpecialForms),
-            ...additionalGlobals,
-          ],
+          ...additionalSpecialForms.imports,
         },
       },
+      globals: [
+        ...globalsForEmber,
+        ...(hasEmber71BuiltIns() ? globalsForEmber71 : []),
+        ...Object.keys(additionalGlobalSpecialForms),
+        ...additionalGlobals,
+      ],
     },
     extensions: {
       '.gts': {

package/src/environment-ember-template-imports/-private/environment/preprocess.ts

@@ -1,8 +1,14 @@
 import { GlintExtensionPreprocess } from '@glint/ember-tsc/config-types';
 import { GLOBAL_TAG, PreprocessData, TemplateLocation } from './common.js';
 
-const TEMPLATE_START = `[${GLOBAL_TAG}\``;
-const TEMPLATE_END = '`]';
+// A `<template>` becomes a tagged-template expression `___T`...``. In a class
+// body a bare expression is not a valid member, so there it is wrapped in a
+// computed-property name `[___T`...`]` (rewritten to a static block during
+// transform). In every other position it is emitted bare: that keeps a
+// user-authored array such as `[<template/>]` a single array literal, so it
+// can never be confused with — and collapsed into — the wrapper.
+const TAG_OPEN = `${GLOBAL_TAG}\``;
+const TAG_CLOSE = '`';
 
 import { Preprocessor } from 'content-tag';
 const p = new Preprocessor();
@@ -22,15 +28,24 @@ export const preprocess: GlintExtensionPreprocess<PreprocessData> = (source, pat
 
     contents += source.slice(sourceOffset, startTagOffset);
 
+    let isClassMember = template.type === 'class-member';
+
+    if (isClassMember) contents += '[';
+
+    // `transformedStart`/`transformedEnd` bracket the tag literal itself
+    // (`___T`...``), excluding any class-member `[ ]`, so they line up exactly
+    // with the tagged-template node's `getStart()`/`getEnd()` during transform.
     let transformedStart = contents.length;
-    contents += TEMPLATE_START;
+    contents += TAG_OPEN;
 
     let templateContent = source.slice(startTagEnd, endTagOffset);
     let escapedContent = templateContent.replaceAll('${{', '\\${{').replaceAll('`', '\\`');
     contents += escapedContent;
-    contents += TEMPLATE_END;
+    contents += TAG_CLOSE;
     let transformedEnd = contents.length;
 
+    if (isClassMember) contents += ']';
+
     sourceOffset = endTagEnd;
     templateLocations.push({
       startTagOffset,

package/src/environment-ember-template-imports/-private/environment/transform.ts

@@ -12,7 +12,15 @@ export const transform: GlintExtensionTransform<PreprocessData> = (
   let { templateLocations } = data;
   if (!templateLocations.length) return (sf) => sf;
 
+  // TypeScript 6 changed `getStart()` to require the source file when the node's
+  // parent chain is not yet intact. During transformation, `repairAncestry` runs
+  // *after* `transformNode`, so parent pointers are not set up at the point where
+  // `findTemplateLocation` calls `node.getStart()`. We capture the source file as
+  // we enter it so we can pass it explicitly.
+  let currentSourceFile: ts.SourceFile | undefined;
+
   return function visit(node: ts.Node): ts.Node {
+    if (ts.isSourceFile(node)) currentSourceFile = node;
     let visitedNode = ts.visitEachChild(node, visit, context);
     let transformedNode = transformNode(visitedNode);
     return repairAncestry(transformedNode);
@@ -20,8 +28,29 @@ export const transform: GlintExtensionTransform<PreprocessData> = (
 
   function transformNode(node: ts.Node): ts.Node {
     if (ts.isSourceFile(node)) {
-      // Add `import { hbs as __T } from 'ember-template-imports'` to the file
+      // Prepend a synthetic `import { hbs as ___T } from '...'` so the emitted
+      // `___T`...`` literals have a tag binding. Downstream `resolveTagInfo`
+      // recognizes them as the built-in `<template>` form precisely because
+      // this import is compiler-synthesized (it has no source position); their
+      // types come from the environment's `getTemplateConfig()`. This is not —
+      // and must not be confused with — the unsupported
+      // `ember-template-imports` `hbs`.
       return addTagImport(f, node);
+    } else if (isETITemplateLiteral(ts, node)) {
+      // Correlate every glint tag literal (`___T`...``) back to its original
+      // `<template>` source span. This is the only consumer of the location
+      // table; it is keyed on the literal's exact start offset, so it matches
+      // each real template once and never a surrounding array or expression.
+      let location = findTemplateLocation(templateLocations, node, currentSourceFile);
+      setEmitMetadata(node, {
+        templateLocation: {
+          start: location.startTagOffset,
+          end: location.endTagOffset + location.endTagLength,
+          contentStart: location.startTagOffset + location.startTagLength,
+          contentEnd: location.endTagOffset,
+        },
+      });
+      return node;
     } else if (isETIDefaultTemplate(ts, node)) {
       // Annotate that this template is a default export
       setEmitMetadata(node.expression, { prepend: 'export default ' });
@@ -30,36 +59,12 @@ export const transform: GlintExtensionTransform<PreprocessData> = (
       // Annotate that this template is a default export
       setEmitMetadata(node.expression.expression, { prepend: 'export default ' });
       return node;
-    } else if (isETITemplateExpression(ts, node)) {
-      // Convert '[__T`foo`]' as an expression to just '__T`foo`'
-      let location = findTemplateLocation(templateLocations, node);
-
-      let template = node.elements[0];
-      setEmitMetadata(template, {
-        templateLocation: {
-          start: location.startTagOffset,
-          end: location.endTagOffset + location.endTagLength,
-          contentStart: location.startTagOffset + location.startTagLength,
-          contentEnd: location.endTagOffset,
-        },
-      });
-      return template;
     } else if (isETITemplateProperty(ts, node)) {
-      // Convert '[__T`foo`]' in a class body to 'static { __T`foo` }'
-      let location = findTemplateLocation(templateLocations, node);
+      // Convert '[___T`foo`]' in a class body to 'static { ___T`foo` }'. The
+      // tag literal already carries its `templateLocation` from the branch
+      // above; here we only add the static-block framing.
       let template = node.name.expression;
-
-      setEmitMetadata(template, {
-        prepend: 'static { ',
-        append: ' }',
-        templateLocation: {
-          start: location.startTagOffset,
-          end: location.endTagOffset + location.endTagLength,
-          contentStart: location.startTagOffset + location.startTagLength,
-          contentEnd: location.endTagOffset,
-        },
-      });
-
+      setEmitMetadata(template, { prepend: 'static { ', append: ' }' });
       return buildStaticBlockForTemplate(f, template);
     }
 
@@ -106,10 +111,6 @@ type ETITemplateLiteral = ts.TaggedTemplateExpression & {
   template: ts.NoSubstitutionTemplateLiteral;
 };
 
-type ETITemplateExpression = ts.ArrayLiteralExpression & {
-  elements: [ETITemplateLiteral];
-};
-
 type ETITemplateProperty = ts.PropertyDeclaration & {
   name: ts.ComputedPropertyName & { expression: ETITemplateLiteral };
 };
@@ -162,14 +163,6 @@ function isETITemplateProperty(ts: TSLib, node: ts.Node): node is ETITemplatePro
   );
 }
 
-function isETITemplateExpression(ts: TSLib, node: ts.Node): node is ETITemplateExpression {
-  return (
-    ts.isArrayLiteralExpression(node) &&
-    node.elements.length === 1 &&
-    isETITemplateLiteral(ts, node.elements[0])
-  );
-}
-
 function isETITemplateLiteral(ts: TSLib, node: ts.Node): node is ETITemplateLiteral {
   return (
     ts.isTaggedTemplateExpression(node) &&
@@ -181,9 +174,12 @@ function isETITemplateLiteral(ts: TSLib, node: ts.Node): node is ETITemplateLite
 
 function findTemplateLocation(
   locations: Array<TemplateLocation>,
-  node: ETITemplateExpression | ETITemplateProperty,
+  node: ETITemplateLiteral,
+  sourceFile?: ts.SourceFile,
 ): TemplateLocation {
-  let location = locations.find((loc) => loc.transformedStart === node.getStart());
+  // Every emitted tag literal corresponds to exactly one recorded location, so
+  // a miss here is a genuine construction bug, not an expected "skip this node".
+  let location = locations.find((loc) => loc.transformedStart === node.getStart(sourceFile));
 
   if (!location) {
     throw new Error('Internal error: missing location info for template');

package/src/transform/template/glimmer-ast-mapping-tree.ts

@@ -58,6 +58,14 @@ export default class GlimmerASTMappingTree {
     public children: Array<GlimmerASTMappingTree> = [],
     public sourceNode: MappingSource,
     public codeInformation?: CodeInformation,
+    /**
+     * When set, `toVolarMappings` emits an additional verification-only mapping
+     * covering this node's entire generated span (even when it differs in length
+     * from the source span). This lets diagnostics that TS anchors on synthetic
+     * generated boilerplate — e.g. the `__glintDSL__.resolve(foo)` callee, where
+     * a missing-positional-arg error lands — map back to the template (#1168).
+     */
+    public wideVerification: boolean = false,
   ) {
     children.forEach((child) => (child.parent = this));
   }

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/map-template-contents.ts

@@ -93,8 +93,18 @@ export type Mapper = {
   /**
    * Map all content emitted in the given callback to the span
    * corresponding to the given AST node in the original source.
+   *
+   * When `wideVerification` is set, an extra verification-only mapping covering
+   * the callback's entire generated span is emitted so that diagnostics anchored
+   * on synthetic generated boilerplate within it still map back to the node
+   * (see `GlimmerASTMappingTree#wideVerification`).
    */
-  forNode(node: AST.Node, callback: () => void, codeFeaturesForNode?: CodeInformation): void;
+  forNode(
+    node: AST.Node,
+    callback: () => void,
+    codeFeaturesForNode?: CodeInformation,
+    wideVerification?: boolean,
+  ): void;
   forNodeWithSpan(
     node: AST.Node,
     span: AST.Node['loc'],
@@ -193,6 +203,7 @@ export function mapTemplateContents(
     allowEmpty: boolean,
     callback: () => void,
     codeFeaturesForNode?: CodeInformation,
+    wideVerification = false,
   ): void => {
     let start = offset;
     let mappings: GlimmerASTMappingTree[] = [];
@@ -229,6 +240,7 @@ export function mapTemplateContents(
           // point in the future but by default tends to make the highlighting in gts files look wrong.
           codeFeaturesForNode ??
             augmentCodeFeaturesWithIgnoreDirectivesSupport(codeFeatures.withoutHighlight, hbsRange),
+          wideVerification,
         ),
       );
       segmentsStack[0].push(...segments);
@@ -327,8 +339,20 @@ export function mapTemplateContents(
       let source = new Identifier(value);
       captureMapping(hbsRange, source, true, () => mapper.text(value));
     },
-    forNode(node: AST.Node, callback: () => void, codeFeaturesForNode?: CodeInformation) {
-      captureMapping(mapper.rangeForNode(node), node, false, callback, codeFeaturesForNode);
+    forNode(
+      node: AST.Node,
+      callback: () => void,
+      codeFeaturesForNode?: CodeInformation,
+      wideVerification?: boolean,
+    ) {
+      captureMapping(
+        mapper.rangeForNode(node),
+        node,
+        false,
+        callback,
+        codeFeaturesForNode,
+        wideVerification,
+      );
     },
 
     forNodeWithSpan(

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 };
         }
       }
 
@@ -1051,10 +1061,12 @@ export function templateToTypescript(
         } else if (position === 'top-level') {
           // e.g. top-level mustache `{{someValue}}`
           mapper.text('__glintDSL__.emitContent(');
-          emitResolve(node, hasParams ? 'resolve' : 'resolveOrReturn');
+          // Direct mustache invocations opt into wide verification so a missing
+          // required argument is reported (#1168); see `emitResolve`.
+          emitResolve(node, hasParams ? 'resolve' : 'resolveOrReturn', true);
           mapper.text(')');
         } else {
-          emitResolve(node, hasParams ? 'resolve' : 'resolveOrReturn');
+          emitResolve(node, hasParams ? 'resolve' : 'resolveOrReturn', true);
         }
       });
     }
@@ -1318,17 +1330,45 @@ export function templateToTypescript(
       | AST.BlockStatement
       | AST.ElementModifierStatement;
 
-    function emitResolve(node: CurlyInvocationNode, resolveType: string): void {
+    function emitResolve(
+      node: CurlyInvocationNode,
+      resolveType: string,
+      wideVerification = false,
+    ): void {
       // We use forNode here to wrap the emitted resolve expression here so that when
       // we convert to Volar mappings, we can create a boundary around
       // e.g. "__glintDSL__.resolveOrReturn(expectsAtLeastOneArg)()", which is required because
       // this is where TS might generate a diagnostic error.
       mapper.forNode(node, () => {
-        mapper.text('__glintDSL__.');
-        mapper.text(resolveType);
-        mapper.text('(');
-        emitExpression(node.path);
-        mapper.text(')(');
+        if (wideVerification) {
+          // Wrap just the synthetic callee `__glintDSL__.resolve(<path>)` and
+          // map its whole generated span back to the path. TS anchors an
+          // "Expected N arguments, but got M" diagnostic (raised when a required
+          // positional arg is missing) on this callee rather than on the args;
+          // without a covering mapping Volar drops it and the missing-arg goes
+          // unreported (#1168). Mapping to the tight `path` node (rather than the
+          // whole invocation) keeps `@glint-expect-error` suppression scoped
+          // correctly.
+          mapper.forNode(
+            node.path,
+            () => {
+              mapper.text('__glintDSL__.');
+              mapper.text(resolveType);
+              mapper.text('(');
+              emitExpression(node.path);
+              mapper.text(')');
+            },
+            undefined,
+            true,
+          );
+          mapper.text('(');
+        } else {
+          mapper.text('__glintDSL__.');
+          mapper.text(resolveType);
+          mapper.text('(');
+          emitExpression(node.path);
+          mapper.text(')(');
+        }
         emitArgs(node.params, node.hash);
         mapper.text(')');
       });

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

@@ -307,6 +307,28 @@ export default class TransformedModule {
       });
     };
 
+    // Push a mapping that covers a generated span whose length differs from the
+    // source span it maps back to (via Volar's `generatedLengths`). This lets a
+    // diagnostic anchored anywhere within the generated span translate back to
+    // the source region even though the two aren't the same length. We restrict
+    // it to `verification` so that navigation/completion/hover features (which
+    // are served by the narrower, length-aligned mappings) are unaffected.
+    const pushWide = (
+      sourceOffset: number,
+      sourceLength: number,
+      generatedOffset: number,
+      generatedLength: number,
+      codeInformation: CodeInformation | undefined,
+    ): void => {
+      codeMappings.push({
+        sourceOffsets: [sourceOffset],
+        generatedOffsets: [generatedOffset],
+        lengths: [sourceLength],
+        generatedLengths: [generatedLength],
+        data: { verification: codeInformation?.verification ?? true },
+      });
+    };
+
     let recurse = (span: CorrelatedSpan, mapping: GlimmerASTMappingTree): void => {
       const children = mapping.children;
       let { originalRange, transformedRange } = mapping;
@@ -359,6 +381,26 @@ export default class TransformedModule {
         // Disregard the "null zone" mappings, i.e. cases where TS code maps to empty HBS code
         if (isNonNullMapping) {
           push(hbsEnd, tsEnd, 0, mapping.codeInformation);
+
+          // The boundary mappings above only mark the start/end of this node's
+          // generated output; the synthetic boilerplate in between (e.g. the
+          // `__glintDSL__.resolve(foo)` callee emitted for `{{foo ...}}`) has no
+          // covering mapping. Some TS diagnostics anchor on exactly that span —
+          // notably "Expected N arguments, but got M" for a missing positional
+          // arg, which points at the callee rather than the args. Without a
+          // covering verification mapping, Volar can't translate such a
+          // diagnostic back to the template and silently drops it (#1168).
+          //
+          // Only nodes explicitly flagged for this opt in (see `forNode`'s
+          // `wideVerification` option): a blanket wide mapping on every parent
+          // would re-expose diagnostics suppressed by a narrower
+          // `@glint-expect-error`, since an ancestor spanning multiple directive
+          // regions carries its own (unsuppressed) verification. We push it
+          // *after* the children so the narrower leaf mappings still win for
+          // diagnostics that fall squarely within them.
+          if (mapping.wideVerification) {
+            pushWide(hbsStart, hbsLength, tsStart, tsLength, mapping.codeInformation);
+          }
         }
       } else {
         if (hbsLength === tsLength) {