Merge pull request #10 from typed-ember/conditional-narrowing

Author: dfreeman

README.md

@@ -301,7 +301,7 @@ export default class MyComponent extends Component<{ message: string }> {
   public static template = (() => {
     let χ!: typeof import('@glint/template');
     return χ.template(function* (𝚪: import('@glint/template').ResolveContext<MyComponent>) {
-      χ.invokeInline(χ.resolveOrReturn(𝚪.args.message));
+      χ.invokeEmit(χ.resolveOrReturn(𝚪.args.message));
     });
   })();
 }

packages/environment-glimmerx/__tests__/helper.test.ts

@@ -1,7 +1,7 @@
 import { helper, fn as fnDefinition } from '@glimmerx/helper';
-import { resolve, invokeInline } from '@glint/environment-glimmerx/types';
+import { resolve } from '@glint/environment-glimmerx/types';
 import { expectTypeOf } from 'expect-type';
-import { NoNamedArgs, ReturnsValue } from '@glint/template/-private';
+import { NoNamedArgs } from '@glint/template/-private';
 
 // Built-in helper: `fn`
 {
@@ -13,29 +13,25 @@ import { NoNamedArgs, ReturnsValue } from '@glint/template/-private';
   // @ts-expect-error: invalid arg
   fn({}, (t: string) => t, 123);
 
-  expectTypeOf(invokeInline(fn({}, () => true))).toEqualTypeOf<() => boolean>();
-  expectTypeOf(invokeInline(fn({}, (arg: string) => arg.length))).toEqualTypeOf<
-    (arg: string) => number
-  >();
-  expectTypeOf(invokeInline(fn({}, (arg: string) => arg.length, 'hi'))).toEqualTypeOf<
-    () => number
-  >();
+  expectTypeOf(fn({}, () => true)).toEqualTypeOf<() => boolean>();
+  expectTypeOf(fn({}, (arg: string) => arg.length)).toEqualTypeOf<(arg: string) => number>();
+  expectTypeOf(fn({}, (arg: string) => arg.length, 'hi')).toEqualTypeOf<() => number>();
 
   let identity = <T>(x: T): T => x;
 
   // Bound type parameters are reflected in the output
-  expectTypeOf(invokeInline(fn({}, identity, 'hi'))).toEqualTypeOf<() => string>();
+  expectTypeOf(fn({}, identity, 'hi')).toEqualTypeOf<() => string>();
 
-  // Unfortunately unbound type parameters degrade to `unknown`; this is a known limitation
-  expectTypeOf(invokeInline(fn({}, identity))).toEqualTypeOf<(x: unknown) => unknown>();
+  // Unbound type parameters survive to the output
+  expectTypeOf(fn({}, identity)).toEqualTypeOf<<T>(x: T) => T>();
 }
 
 // Custom helper: positional params
 {
   let definition = helper(<T, U>([a, b]: [T, U]) => a || b);
   let or = resolve(definition);
 
-  expectTypeOf(or).toEqualTypeOf<<T, U>(args: NoNamedArgs, t: T, u: U) => ReturnsValue<T | U>>();
+  expectTypeOf(or).toEqualTypeOf<<T, U>(args: NoNamedArgs, t: T, u: U) => T | U>();
 
   // @ts-expect-error: extra named arg
   or({ hello: true }, 'a', 'b');
@@ -46,9 +42,9 @@ import { NoNamedArgs, ReturnsValue } from '@glint/template/-private';
   // @ts-expect-error: extra positional arg
   or({}, 'a', 'b', 'c');
 
-  expectTypeOf(invokeInline(or({}, 'a', 'b'))).toEqualTypeOf<string>();
-  expectTypeOf(invokeInline(or({}, 'a', true))).toEqualTypeOf<string | boolean>();
-  expectTypeOf(invokeInline(or({}, false, true))).toEqualTypeOf<boolean>();
+  expectTypeOf(or({}, 'a', 'b')).toEqualTypeOf<string>();
+  expectTypeOf(or({}, 'a', true)).toEqualTypeOf<string | boolean>();
+  expectTypeOf(or({}, false, true)).toEqualTypeOf<boolean>();
 }
 
 // Custom helper: named params
@@ -59,9 +55,7 @@ import { NoNamedArgs, ReturnsValue } from '@glint/template/-private';
 
   let repeat = resolve(definition);
 
-  expectTypeOf(repeat).toEqualTypeOf<
-    (args: { word: string; count?: number }) => ReturnsValue<Array<string>>
-  >();
+  expectTypeOf(repeat).toEqualTypeOf<(args: { word: string; count?: number }) => Array<string>>();
 
   // @ts-expect-error: extra positional arg
   repeat({ word: 'hi' }, 123);
@@ -72,6 +66,6 @@ import { NoNamedArgs, ReturnsValue } from '@glint/template/-private';
   // @ts-expect-error: extra named arg
   repeat({ word: 'hello', foo: true });
 
-  expectTypeOf(invokeInline(repeat({ word: 'hi' }))).toEqualTypeOf<Array<string>>();
-  expectTypeOf(invokeInline(repeat({ word: 'hi', count: 3 }))).toEqualTypeOf<Array<string>>();
+  expectTypeOf(repeat({ word: 'hi' })).toEqualTypeOf<Array<string>>();
+  expectTypeOf(repeat({ word: 'hi', count: 3 })).toEqualTypeOf<Array<string>>();
 }

packages/environment-glimmerx/types/globals.d.ts

@@ -1,9 +1,13 @@
 import * as VM from '@glint/template/-private/keywords';
 
 interface Keywords {
+  // the `component` keyword exists but is essentially unusable as GlimmerX
+  // has no string-based resolution and can only resolve statically-invoked
+  // values as components/helpers/etc
+  // component: VM.ComponentKeyword;
   debugger: VM.DebuggerKeyword;
   each: VM.EachKeyword;
-  'has-block': VM.HasBlockParamsKeyword;
+  'has-block': VM.HasBlockKeyword;
   'has-block-params': VM.HasBlockParamsKeyword;
   // the `if` keyword is implemented directly in @glint/transform
   'in-element': VM.InElementKeyword;

packages/environment-glimmerx/types/signatures.d.ts

@@ -1,5 +1,4 @@
 import { NoNamedArgs, CreatesModifier } from '@glint/template/-private';
-import { Invokable, ReturnsValue } from '@glint/template/-private';
 import { ResolutionKey } from '@glint/template/-private';
 import { TemplateContext, AcceptsBlocks } from '@glint/template/-private';
 import GlimmerXComponent from '@glimmerx/component';
@@ -17,7 +16,7 @@ declare module '@glint/template/resolution-rules' {
 
   export interface SignatureResolutions<InvokedValue> {
     [ResolveGlimmerXComponent]: InvokedValue extends Constructor<GlimmerXComponent<infer Args>>
-      ? InvokedValue extends { template: Invokable<infer Signature> }
+      ? InvokedValue extends { template: infer Signature }
         ? Signature
         : (args: Args) => AcceptsBlocks<{ default?: [] }>
       : never;
@@ -41,36 +40,36 @@ declare module '@glimmerx/modifier' {
 declare module '@glimmerx/helper' {
   export function helper<Result, Named = NoNamedArgs, Positional extends unknown[] = []>(
     fn: (positional: Positional, named: Named) => Result
-  ): Invokable<(args: Named, ...positional: Positional) => ReturnsValue<Result>>;
+  ): (args: Named, ...positional: Positional) => Result;
 
   export function fn<Ret, Args extends unknown[]>(
     args: NoNamedArgs,
     f: (...rest: Args) => Ret
-  ): ReturnsValue<(...rest: Args) => Ret>;
+  ): (...rest: Args) => Ret;
   export function fn<A, Ret, Args extends unknown[]>(
     args: NoNamedArgs,
     f: (a: A, ...rest: Args) => Ret,
     a: A
-  ): ReturnsValue<(...rest: Args) => Ret>;
+  ): (...rest: Args) => Ret;
   export function fn<A, B, Ret, Args extends unknown[]>(
     args: NoNamedArgs,
     f: (a: A, b: B, ...rest: Args) => Ret,
     a: A,
     b: B
-  ): ReturnsValue<(...rest: Args) => Ret>;
+  ): (...rest: Args) => Ret;
   export function fn<A, B, C, Ret, Args extends unknown[]>(
     args: NoNamedArgs,
     f: (a: A, b: B, c: C, ...rest: Args) => Ret,
     a: A,
     b: B,
     c: C
-  ): ReturnsValue<(...rest: Args) => Ret>;
+  ): (...rest: Args) => Ret;
   export function fn<A, B, C, D, Ret, Args extends unknown[]>(
     args: NoNamedArgs,
     f: (a: A, b: B, c: C, d: D, ...rest: Args) => Ret,
     a: A,
     b: B,
     c: C,
     d: D
-  ): ReturnsValue<(...rest: Args) => Ret>;
+  ): (...rest: Args) => Ret;
 }

packages/template/-private/index.d.ts

@@ -1,4 +1,3 @@
-export { Invokable } from './invoke';
-export { AcceptsBlocks, CreatesModifier, ReturnsValue, NoNamedArgs } from './signature';
+export { AcceptsBlocks, CreatesModifier, NoNamedArgs } from './signature';
 export { TemplateContext } from './template';
 export { ResolutionKey } from './resolution';

packages/template/-private/invoke.d.ts

@@ -1,30 +1,18 @@
-import { Return, ReturnsValue, CreatesModifier, AcceptsBlocks, AnySignature } from './signature';
+import { CreatesModifier, AcceptsBlocks } from './signature';
 import { YieldsFromBlock, BlockBodies } from './blocks';
 
 /**
- * This wrapping type indicates a value that may be invoked in a template.
- *
- * At present it's just a no-op type that does nothing but validate that
- * the given type is a valid template signature, as it's otherwise not
- * possible to do anything with function types in TS without losing information
- * about any type parameters they may have.
- */
-export type Invokable<T extends AnySignature> = T;
-
-/**
- * Invokes the given value as an inline invocation. This corresponds to a
- * mustache statement or subexpression, i.e. one of:
+ * Invokes the given value as an inline expression to be emitted to the DOM.
+ * This corresponds to a mustache statement either at the top level or being
+ * passed as an attribute or concatenated into a string:
  *
  *     {{value foo=bar}}
- *     <div data-attr={{value foo=bar}}></div>
- *     <div data-attr={{concat (value foo=bar)}}
- *
- * This form of invocation is the only one in a template that allows for a
- * value to be returned.
+ *     <div data-x={{value foo=bar}}>
+ *     <div data-x="hello {{value foo=bar}}">
  */
-export declare function invokeInline<T extends ReturnsValue<any>>(
-  value: T
-): ReturnType<T>[typeof Return];
+export declare function invokeEmit<
+  T extends AcceptsBlocks<{}> | string | number | boolean | null | void
+>(value: T): void;
 
 /**
  * Invokes the given value as a modifier. This corresponds to a mustache

packages/template/-private/keywords/component.d.ts

@@ -1,8 +1,7 @@
-import { AnySignature, AnyBlocks, ReturnsValue, AcceptsBlocks } from '../signature';
-import { ResolveSignature } from '../resolution';
-import { Invokable } from '../invoke';
+import { AnyBlocks, AcceptsBlocks } from '../signature';
+import { ResolveSignature, Resolvable } from '../resolution';
 
-type SignatureFor<T> = T extends AnySignature ? T : ResolveSignature<T>;
+type SignatureFor<T> = T extends Resolvable<any> ? ResolveSignature<T> : T;
 
 type ArgsFor<T> = SignatureFor<T> extends (args: infer Args) => unknown ? Args : {};
 
@@ -23,12 +22,8 @@ export default interface ComponentKeyword {
   <Component, GivenArgs extends keyof ArgsFor<Component>>(
     args: { [Arg in GivenArgs]: ArgsFor<Component>[Arg] },
     component: Component
-  ): ReturnsValue<
-    Invokable<
-      (
-        args: Omit<ArgsFor<Component>, GivenArgs> & Partial<Pick<ArgsFor<Component>, GivenArgs>>,
-        ...positional: PositionalFor<Component>
-      ) => AcceptsBlocks<BlocksFor<Component>>
-    >
-  >;
+  ): (
+    args: Omit<ArgsFor<Component>, GivenArgs> & Partial<Pick<ArgsFor<Component>, GivenArgs>>,
+    ...positional: PositionalFor<Component>
+  ) => AcceptsBlocks<BlocksFor<Component>>;
 }

packages/template/-private/keywords/debugger.d.ts

@@ -1,5 +1,5 @@
-import { NoNamedArgs, ReturnsValue } from '../signature';
+import { NoNamedArgs } from '../signature';
 
 export default interface DebuggerKeyword {
-  (args: NoNamedArgs): ReturnsValue<void>;
+  (args: NoNamedArgs): void;
 }

packages/template/-private/keywords/has-block-params.d.ts

@@ -1,5 +1,5 @@
-import { NoNamedArgs, ReturnsValue } from '../signature';
+import { NoNamedArgs } from '../signature';
 
 export default interface HasBlockParamsKeyword {
-  (args: NoNamedArgs, blockName?: string): ReturnsValue<boolean>;
+  (args: NoNamedArgs, blockName?: string): boolean;
 }

packages/template/-private/keywords/has-block.d.ts

@@ -1,5 +1,5 @@
-import { NoNamedArgs, ReturnsValue } from '../signature';
+import { NoNamedArgs } from '../signature';
 
 export default interface HasBlockKeyword {
-  (args: NoNamedArgs, blockName?: string): ReturnsValue<boolean>;
+  (args: NoNamedArgs, blockName?: string): boolean;
 }

packages/template/-private/resolution.d.ts

@@ -3,7 +3,7 @@
  * _template signature_ and _template context_ for various values.
  */
 
-import { ReturnsValue, AnySignature, NoNamedArgs } from './signature';
+import { NoNamedArgs } from './signature';
 import { ContextResolutions, SignatureResolutions } from '../resolution-rules';
 
 export declare const ResolutionKey: unique symbol;
@@ -55,7 +55,7 @@ export declare function resolve<T extends AnyGuard>(item: T): any;
 export declare function resolve<T extends Resolvable<SignatureResolutionKeys>>(
   item: T
 ): ResolveSignature<T>;
-export declare function resolve<T extends AnySignature>(item: T): T;
+export declare function resolve<T extends Function>(item: T): T;
 
 /**
  * A mustache like `{{this.foo}}` might either return a plain value like a string
@@ -70,5 +70,5 @@ export declare function resolveOrReturn<T extends AnyGuard>(item: T): any;
 export declare function resolveOrReturn<T extends Resolvable<SignatureResolutionKeys>>(
   item: T
 ): ResolveSignature<T>;
-export declare function resolveOrReturn<T extends AnySignature>(item: T): T;
-export declare function resolveOrReturn<T>(item: T): (args: NoNamedArgs) => ReturnsValue<T>;
+export declare function resolveOrReturn<T extends Function>(item: T): T;
+export declare function resolveOrReturn<T>(item: T): (args: NoNamedArgs) => T;

packages/template/-private/signature.d.ts

@@ -24,20 +24,13 @@
  */
 
 declare const Modifier: unique symbol;
-declare const Return: unique symbol;
 declare const Blocks: unique symbol;
 
 /** The loosest shape of a "blocks hash" */
 export type AnyBlocks = Record<string, unknown[]>;
 
-/** The loosest shape of a template signature */
-export type AnySignature = (...args: any) => (blocks: any) => any;
-
-/** Denotes that the associated entity returns a value when invoked */
-export type ReturnsValue<T> = () => { [Return]: T };
-
 /** Denotes that the associated entity should be invoked as a modifier */
-export type CreatesModifier = () => { [Modifier]: true };
+export type CreatesModifier = { [Modifier]: true };
 
 // These shenanigans are necessary to get TS to report when named args
 // are passed to a signature that doesn't expect any, because `{}` is

packages/template/-private/template.d.ts

@@ -6,7 +6,6 @@
 
 import { BlockYield } from './blocks';
 import { AcceptsBlocks } from './signature';
-import { Invokable } from './invoke';
 
 /**
  * Determines the type of `this` and any `@arg`s used in a template.
@@ -18,18 +17,16 @@ export type TemplateContext<This, Args> = { this: This; args: Args };
 
 /**
  * Accepts a generator function declaring an expected template context,
- * and returns an appropriate `Invokable` type that accepts the required
+ * and returns an appropriate invokable type that accepts the required
  * named args and a set of blocks as determined by any `BlockYield`s
  * included in the generators iterator type.
  */
 export declare function template<This, Args, Yields extends BlockYield<string, unknown[]>>(
   f: (𝚪: TemplateContext<This, Args>) => IterableIterator<Yields>
-): Invokable<
-  (
-    args: Args
-  ) => AcceptsBlocks<
-    {
-      [K in Yields['to']]?: Extract<Yields, { to: K }>['values'];
-    }
-  >
+): (
+  args: Args
+) => AcceptsBlocks<
+  {
+    [K in Yields['to']]?: Extract<Yields, { to: K }>['values'];
+  }
 >;

packages/template/__tests__/custom-invokable.test.ts

@@ -3,7 +3,6 @@ import SumType from 'sums-up';
 import { resolve, toBlock, invokeBlock } from '@glint/template';
 import { AcceptsBlocks, NoNamedArgs } from '@glint/template/-private/signature';
 import { BlockYield } from '@glint/template/-private/blocks';
-import { Invokable } from '@glint/template/-private/invoke';
 
 ///////////////////////////////////////////////////////////////////////////////
 // This module exercises what's possible when declaring a signature for a
@@ -22,22 +21,20 @@ type SumVariants<T extends SumType<never>> = T extends SumType<infer V> ? V : ne
 // https://github.com/hojberg/sums-up
 // It doesn't (can't) do exhaustiveness checking, but it does plumb through
 // type parameters correctly
-declare const caseOf: Invokable<<T extends SumType<never>>(
+declare const caseOf: <T extends SumType<never>>(
   args: NoNamedArgs,
   value: T
 ) => AcceptsBlocks<{
   default: [
-    Invokable<
-      <K extends keyof SumVariants<T>>(
-        args: NoNamedArgs,
-        key: K
-      ) => AcceptsBlocks<{
-        default: SumVariants<T>[K];
-        inverse?: [];
-      }>
-    >
+    <K extends keyof SumVariants<T>>(
+      args: NoNamedArgs,
+      key: K
+    ) => AcceptsBlocks<{
+      default: SumVariants<T>[K];
+      inverse?: [];
+    }>
   ];
-}>>;
+}>;
 
 /**
  * ```hbs
@@ -75,9 +72,7 @@ expectTypeOf(
 // you do get exhaustiveness checking with this approach (though it's
 // arguable whether that's necessarily a good thing in template-land)
 
-declare const CaseOf: Invokable<<T extends SumType<any>>(args: {
-  value: T;
-}) => AcceptsBlocks<SumVariants<T>>>;
+declare const CaseOf: <T extends SumType<any>>(args: { value: T }) => AcceptsBlocks<SumVariants<T>>;
 
 /**
  * ```hbs