fix: targets returning void should type check

biome.json

@@ -20,6 +20,7 @@
 				"useConst": "off"
 			},
 			"suspicious": {
+				"noConfusingVoidType": "off",
 				"noExplicitAny": "off",
 				"noRedeclare": "off",
 				"useIsArray": "off"

packages/runtime/src/resolve.ts

@@ -1,24 +1,28 @@
-import * as im from "immutable";
+import im from "immutable";
 import * as tg from "./index.ts";
 import type { MaybePromise } from "./util.ts";
 
-export type Unresolved<T extends tg.Value> = MaybePromise<
-	T extends
-		| undefined
-		| boolean
-		| number
-		| string
-		| tg.Object
-		| Uint8Array
-		| tg.Mutation
-		| tg.Template
-		? T
-		: T extends Array<infer U extends tg.Value>
-			? Array<Unresolved<U>>
-			: T extends { [key: string]: tg.Value }
-				? { [K in keyof T]: Unresolved<T[K]> }
-				: never
->;
+export type Unresolved<T extends tg.Value> = MaybePromise<UnresolvedInner<T>>;
+
+export type UnresolvedInner<T extends tg.Value> = T extends
+	| undefined
+	| boolean
+	| number
+	| string
+	| tg.Object
+	| Uint8Array
+	| tg.Mutation
+	| tg.Template
+	? T
+	: T extends Array<infer U extends tg.Value>
+		? Array<Unresolved<U>>
+		: T extends {
+					[key: string]: tg.Value;
+				}
+			? {
+					[K in keyof T]: Unresolved<T[K]>;
+				}
+			: never;
 
 export type Resolved<T extends Unresolved<tg.Value>> = T extends
 	| undefined

packages/runtime/src/target.ts

@@ -1,4 +1,5 @@
 import * as tg from "./index.ts";
+import type { UnresolvedInner } from "./resolve.ts";
 import {
 	type MaybeMutationMap,
 	type MaybeNestedArray,
@@ -14,24 +15,26 @@ export let setCurrentTarget = (target: Target) => {
 
 type FunctionArg<
 	A extends Array<tg.Value> = Array<tg.Value>,
-	R extends tg.Value = tg.Value,
+	R extends void | tg.Value = void | tg.Value,
 > = {
-	function: (...args: A) => tg.Unresolved<R>;
+	function: (
+		...args: A
+	) => MaybePromise<R extends void ? void : UnresolvedInner<Exclude<R, void>>>;
 	module: tg.Module;
 	name: string;
 };
 
 export function target<
 	A extends Array<tg.Value> = Array<tg.Value>,
-	R extends tg.Value = tg.Value,
+	R extends void | tg.Value = void | tg.Value,
 >(arg: FunctionArg): Target<A, R>;
 export function target<
 	A extends Array<tg.Value> = Array<tg.Value>,
-	R extends tg.Value = tg.Value,
+	R extends void | tg.Value = void | tg.Value,
 >(...args: tg.Args<Target.Arg>): Promise<Target<A, R>>;
 export function target<
 	A extends Array<tg.Value> = Array<tg.Value>,
-	R extends tg.Value = tg.Value,
+	R extends void | tg.Value = void | tg.Value,
 >(
 	...args: [FunctionArg<A, R>] | tg.Args<Target.Arg>
 ): MaybePromise<Target<A, R>> {
@@ -70,15 +73,15 @@ export function target<
 
 export interface Target<
 	A extends Array<tg.Value> = Array<tg.Value>,
-	R extends tg.Value = tg.Value,
+	R extends void | tg.Value = void | tg.Value,
 > extends globalThis.Function {
 	(...args: { [K in keyof A]: tg.Unresolved<A[K]> }): Promise<R>;
 }
 
 // biome-ignore lint/suspicious/noUnsafeDeclarationMerging: This is necessary to make targets callable.
 export class Target<
 	A extends Array<tg.Value> = Array<tg.Value>,
-	R extends tg.Value = tg.Value,
+	R extends void | tg.Value = void | tg.Value,
 > extends globalThis.Function {
 	#state: Target.State;
 	#f: Function | undefined;
@@ -116,7 +119,7 @@ export class Target<
 
 	static async new<
 		A extends Array<tg.Value> = Array<tg.Value>,
-		R extends tg.Value = tg.Value,
+		R extends void | tg.Value = void | tg.Value,
 	>(...args: tg.Args<Target.Arg>): Promise<Target<A, R>> {
 		let arg = await Target.arg(...args);
 		let args_ = arg.args ?? [];

packages/runtime/tangram.d.ts

@@ -408,7 +408,9 @@ declare namespace tg {
 	}
 
 	/** Create a symlink. */
-	export let symlink: (arg: tg.Unresolved<tg.Symlink.Arg>) => Promise<tg.Symlink>;
+	export let symlink: (
+		arg: tg.Unresolved<tg.Symlink.Arg>,
+	) => Promise<tg.Symlink>;
 
 	/** A symlink. */
 	export class Symlink {
@@ -546,17 +548,23 @@ declare namespace tg {
 	/** Create a target. */
 	export function target<
 		A extends Array<tg.Value> = Array<tg.Value>,
-		R extends tg.Value = tg.Value,
-	>(function_: (...args: A) => tg.Unresolved<R>): tg.Target<A, R>;
+		R extends void | tg.Value = void | tg.Value,
+	>(
+		function_: (
+			...args: A
+		) => MaybePromise<
+			R extends void ? void : tg.UnresolvedInner<Exclude<R, void>>
+		>,
+	): tg.Target<A, R>;
 	export function target<
 		A extends Array<tg.Value> = Array<tg.Value>,
-		R extends tg.Value = tg.Value,
+		R extends void | tg.Value = void | tg.Value,
 	>(...args: tg.Args<tg.Target.Arg>): Promise<tg.Target<A, R>>;
 
 	/** A target. */
 	export interface Target<
 		A extends Array<tg.Value> = Array<tg.Value>,
-		R extends tg.Value = tg.Value,
+		R extends void | tg.Value = void | tg.Value,
 	> {
 		/** Build this target. */
 		// biome-ignore lint/style/useShorthandFunctionType: interface is necessary .
@@ -566,7 +574,7 @@ declare namespace tg {
 	/** A target. */
 	export class Target<
 		A extends Array<tg.Value> = Array<tg.Value>,
-		R extends tg.Value = tg.Value,
+		R extends void | tg.Value = void | tg.Value,
 	> extends globalThis.Function {
 		/** Get a target with an ID. */
 		static withId(id: tg.Target.Id): tg.Target;
@@ -941,23 +949,29 @@ declare namespace tg {
 	 * ```
 	 */
 	export type Unresolved<T extends tg.Value> = tg.MaybePromise<
-		T extends
-			| undefined
-			| boolean
-			| number
-			| string
-			| tg.Object
-			| Uint8Array
-			| tg.Mutation
-			| tg.Template
-			? T
-			: T extends Array<infer U extends tg.Value>
-				? Array<tg.Unresolved<U>>
-				: T extends { [key: string]: tg.Value }
-					? { [K in keyof T]: tg.Unresolved<T[K]> }
-					: never
+		tg.UnresolvedInner<T>
 	>;
 
+	type UnresolvedInner<T extends tg.Value> = T extends
+		| undefined
+		| boolean
+		| number
+		| string
+		| tg.Object
+		| Uint8Array
+		| tg.Mutation
+		| tg.Template
+		? T
+		: T extends Array<infer U extends tg.Value>
+			? Array<Unresolved<U>>
+			: T extends {
+						[key: string]: tg.Value;
+					}
+				? {
+						[K in keyof T]: Unresolved<T[K]>;
+					}
+				: never;
+
 	/**
 	 * This computed type performs the inverse of `Unresolved`. It takes a type and returns the output of calling `resolve` on a value of that type. Here are some examples:
 	 *

packages/server/src/package/check/tests.rs

@@ -70,6 +70,26 @@ async fn nonexistent_function() -> tg::Result<()> {
 	.await
 }
 
+#[tokio::test]
+async fn no_return_value() -> tg::Result<()> {
+	test(
+		temp::directory! {
+			"tangram.ts" => indoc!(r"
+				export default tg.target(() => {});
+			"),
+		},
+		|_, output| async move {
+			assert_json_snapshot!(output, @r#"
+   {
+     "diagnostics": []
+   }
+   "#);
+			Ok(())
+		},
+	)
+	.await
+}
+
 async fn test<F, Fut>(artifact: temp::Artifact, assertions: F) -> tg::Result<()>
 where
 	F: FnOnce(Server, tg::package::check::Output) -> Fut,