Add support for splitting server/client code (#115)

* Experimental code stripping
* Early return guards
* `@Server`, `@Client` method stripping
* Handle void return functions diff
* Add imports if required, support `--skipPackages`
* Reduce duplicate code output
* Auto strip simple `Game.Is*()` calls
* Refactoring
* Remove old files
* Support guard throws
* Throw on inverse guards
* Nvm support inverse
* Macro changes

Author: Vorlias

src/CLI/commands/build.ts

@@ -1,8 +1,9 @@
 import { findTsConfigPath, getPackageJson, getTsConfigProjectOptions } from "CLI/util/findTsConfigPath";
 import { existsSync } from "fs";
+import path from "path";
 import { buildTypes } from "Project/functions/buildTypes";
 import { cleanup } from "Project/functions/cleanup";
-import { compileFiles } from "Project/functions/compileFiles";
+import { compileFiles, isPackage } from "Project/functions/compileFiles";
 import { copyFiles } from "Project/functions/copyFiles";
 import { copyNodeModules } from "Project/functions/copyInclude";
 import { createPathTranslator } from "Project/functions/createPathTranslator";
@@ -19,7 +20,7 @@ import { ProjectOptions, TypeScriptConfiguration } from "Shared/types";
 import { getRootDirs } from "Shared/util/getRootDirs";
 import { hasErrors } from "Shared/util/hasErrors";
 import { AirshipBuildState, BUILD_FILE, EDITOR_FILE } from "TSTransformer";
-import ts, { TSConfig } from "typescript";
+import ts from "typescript";
 import yargs from "yargs";
 
 interface BuildFlags {
@@ -43,12 +44,20 @@ export = ts.identity<yargs.CommandModule<{}, BuildFlags & Partial<ProjectOptions
 			default: ".",
 			describe: "project path",
 		},
+		skipPackages: {
+			type: "boolean",
+			alias: "P",
+			describe: "Compile only the game's code",
+			boolean: true,
+			default: false,
+		},
 		json: {
 			hidden: true,
 			boolean: true,
 			default: false,
 		},
 		publish: {
+			alias: "D",
 			hidden: true,
 			boolean: true,
 			default: false,
@@ -148,7 +157,15 @@ export = ts.identity<yargs.CommandModule<{}, BuildFlags & Partial<ProjectOptions
 					pathTranslator,
 					new Set(getRootDirs(program.getCompilerOptions(), data.projectOptions)),
 				);
-				const sourceFiles = getChangedSourceFiles(program);
+
+				let sourceFiles = getChangedSourceFiles(program);
+
+				if (projectOptions.skipPackages) {
+					LogService.writeIfVerbose("Filtering out packages from compile");
+					sourceFiles = sourceFiles.filter(
+						sourceFile => !isPackage(path.relative(process.cwd(), sourceFile.fileName)),
+					);
+				}
 
 				if (projectOptions.json) {
 					jsonReporter("startingCompile", { initial: true, count: sourceFiles.length });

src/Project/functions/compileFiles.ts

@@ -11,7 +11,7 @@ import { createTransformerWatcher } from "Project/transformers/createTransformer
 import { getPluginConfigs } from "Project/transformers/getPluginConfigs";
 import { getCustomPreEmitDiagnostics } from "Project/util/getCustomPreEmitDiagnostics";
 import { LogService } from "Shared/classes/LogService";
-import { PathTranslator } from "Shared/classes/PathTranslator";
+import { PathHint, PathTranslator } from "Shared/classes/PathTranslator";
 import { ProjectType } from "Shared/constants";
 import { warnings } from "Shared/diagnostics";
 import { AirshipBuildFile, ProjectData } from "Shared/types";
@@ -20,6 +20,7 @@ import { benchmarkIfVerbose } from "Shared/util/benchmark";
 import {
 	AirshipBuildState,
 	BUILD_FILE,
+	CompliationContext,
 	EDITOR_FILE,
 	MultiTransformState,
 	transformSourceFile,
@@ -46,6 +47,16 @@ function getReverseSymlinkMap(program: ts.Program) {
 	return result;
 }
 
+export function isPackage(relativePath: string) {
+	return relativePath.startsWith("AirshipPackages" + path.sep);
+}
+
+interface FileWriteEntry {
+	sourceFile: ts.SourceFile;
+	source: string;
+	context?: CompliationContext;
+}
+
 /**
  * 'transpiles' TypeScript project into a logically identical Luau project.
  *
@@ -58,7 +69,7 @@ export function compileFiles(
 	buildState: AirshipBuildState,
 	sourceFiles: Array<ts.SourceFile>,
 ): ts.EmitResult {
-	const asJson = data.projectOptions.json;
+	const { json: asJson, publish: isPublish } = data.projectOptions;
 	const compilerOptions = program.getCompilerOptions();
 
 	const watch = compilerOptions.watch ?? false;
@@ -92,7 +103,7 @@ export function compileFiles(
 
 	LogService.writeLineIfVerbose(`Now running TypeScript compiler:`);
 
-	const fileWriteQueue = new Array<{ sourceFile: ts.SourceFile; source: string }>();
+	const fileWriteQueue = new Array<FileWriteEntry>();
 	const fileMetadataWriteQueue = new Map<ts.SourceFile, string>();
 
 	const progressMaxLength = `${sourceFiles.length}/${sourceFiles.length}`.length;
@@ -175,11 +186,24 @@ export function compileFiles(
 		});
 	}
 
+	if (isPublish) {
+		const sharedDirectory = pathTranslator.getOutDir(PathHint.Shared);
+		if (fs.pathExistsSync(sharedDirectory)) fs.removeSync(sharedDirectory);
+
+		const clientDirectory = pathTranslator.getOutDir(PathHint.Client);
+		if (fs.pathExistsSync(clientDirectory)) fs.removeSync(clientDirectory);
+
+		const serverDirectory = pathTranslator.getOutDir(PathHint.Server);
+		if (fs.pathExistsSync(serverDirectory)) fs.removeSync(serverDirectory);
+	}
+
 	for (let i = 0; i < sourceFiles.length; i++) {
 		const sourceFile = proxyProgram.getSourceFile(sourceFiles[i].fileName);
 		assert(sourceFile);
 		const progress = `${i + 1}/${sourceFiles.length}`.padStart(progressMaxLength);
-		benchmarkIfVerbose(`${progress} compile ${path.relative(process.cwd(), sourceFile.fileName)}`, () => {
+		const relativePath = path.relative(process.cwd(), sourceFile.fileName);
+
+		benchmarkIfVerbose(`${progress} compile ${relativePath}`, () => {
 			DiagnosticService.addDiagnostics(ts.getPreEmitDiagnostics(proxyProgram, sourceFile));
 			DiagnosticService.addDiagnostics(getCustomPreEmitDiagnostics(data, sourceFile));
 			if (DiagnosticService.hasErrors()) return;
@@ -200,12 +224,37 @@ export function compileFiles(
 				sourceFile,
 			);
 
-			const luauAST = transformSourceFile(transformState, sourceFile);
-			if (DiagnosticService.hasErrors()) return;
+			if (isPublish && !isPackage(relativePath)) {
+				const serverWriteEntry = transformState.useContext(CompliationContext.Server, context => {
+					const luauAST = transformSourceFile(transformState, sourceFile);
+					if (DiagnosticService.hasErrors()) return;
+					const source = renderAST(luauAST);
+					return { sourceFile, source, context } satisfies FileWriteEntry;
+				});
+
+				if (DiagnosticService.hasErrors() || !serverWriteEntry) return;
 
-			const source = renderAST(luauAST);
+				const clientWriteEntry = transformState.useContext(CompliationContext.Client, context => {
+					const luauAST = transformSourceFile(transformState, sourceFile);
+					if (DiagnosticService.hasErrors()) return;
+					const source = renderAST(luauAST);
+					return { sourceFile, source, context } satisfies FileWriteEntry;
+				});
 
-			fileWriteQueue.push({ sourceFile, source });
+				if (!clientWriteEntry) return;
+
+				if (clientWriteEntry.source !== serverWriteEntry.source) {
+					fileWriteQueue.push(clientWriteEntry);
+					fileWriteQueue.push(serverWriteEntry);
+				} else {
+					fileWriteQueue.push({ ...serverWriteEntry, context: CompliationContext.Shared });
+				}
+			} else {
+				const luauAST = transformSourceFile(transformState, sourceFile);
+				if (DiagnosticService.hasErrors()) return;
+				const source = renderAST(luauAST);
+				fileWriteQueue.push({ sourceFile, source });
+			}
 
 			const airshipBehaviours = transformState.airshipBehaviours;
 
@@ -231,7 +280,8 @@ export function compileFiles(
 					const airshipBehaviourMetadata = behaviour.metadata;
 
 					if (airshipBehaviourMetadata) {
-						assert(!fileMetadataWriteQueue.has(sourceFile));
+						if (fileMetadataWriteQueue.has(sourceFile)) continue;
+
 						fileMetadataWriteQueue.set(sourceFile, JSON.stringify(airshipBehaviourMetadata, null, "\t"));
 					}
 
@@ -263,8 +313,23 @@ export function compileFiles(
 			let writeCount = 0;
 			let metadataCount = 0;
 
-			for (const { sourceFile, source } of fileWriteQueue) {
-				const outPath = pathTranslator.getOutputPath(sourceFile.fileName);
+			for (const { sourceFile, source, context } of fileWriteQueue) {
+				let pathHint: PathHint | undefined;
+				if (context !== undefined) {
+					switch (context) {
+						case CompliationContext.Client:
+							pathHint = PathHint.Client;
+							break;
+						case CompliationContext.Server:
+							pathHint = PathHint.Server;
+							break;
+						case CompliationContext.Shared:
+							pathHint = PathHint.Shared;
+							break;
+					}
+				}
+
+				const outPath = pathTranslator.getOutputPath(sourceFile.fileName, pathHint);
 				const hasMetadata = fileMetadataWriteQueue.has(sourceFile);
 				const metadataPathOutPath = outPath + ".json~";
 

src/Shared/classes/PathTranslator.ts

@@ -37,6 +37,15 @@ class PathInfo {
 	}
 }
 
+export enum PathHint {
+	None,
+	Server,
+	Client,
+	Shared,
+}
+
+type PathInfoDelegate = (pathInfo: PathInfo) => string;
+
 export class PathTranslator {
 	constructor(
 		public readonly rootDir: string,
@@ -46,7 +55,7 @@ export class PathTranslator {
 		public readonly projectOptions: ProjectOptions,
 	) {}
 
-	private makeRelativeFactory(from = this.rootDir, to = this.outDir) {
+	private makeRelativeFactory(from = this.rootDir, to = this.outDir): PathInfoDelegate {
 		return (pathInfo: PathInfo) => path.join(to, path.relative(from, pathInfo.join()));
 	}
 
@@ -63,14 +72,37 @@ export class PathTranslator {
 	// 	return unityPath;
 	// }
 
+	public getOutDir(pathHint = PathHint.None) {
+		if (pathHint === PathHint.Server) {
+			return path.resolve(this.outDir, "../dist/server");
+		} else if (pathHint === PathHint.Client) {
+			return path.resolve(this.outDir, "../dist/client");
+		} else if (pathHint === PathHint.Shared) {
+			return path.resolve(this.outDir, "../dist/shared");
+		} else {
+			return this.outDir;
+		}
+	}
+
 	/**
 	 * Maps an input path to an output path
 	 * - `.tsx?` && !`.d.tsx?` -> `.lua`
 	 * 	- `index` -> `init`
 	 * - `src/*` -> `out/*`
 	 */
-	public getOutputPath(filePath: string) {
-		const makeRelative = this.makeRelativeFactory();
+	public getOutputPath(filePath: string, pathHint = PathHint.None) {
+		let makeRelative: PathInfoDelegate;
+
+		if (pathHint === PathHint.Server) {
+			makeRelative = this.makeRelativeFactory(undefined, path.resolve(this.outDir, "../dist/server"));
+		} else if (pathHint === PathHint.Client) {
+			makeRelative = this.makeRelativeFactory(undefined, path.resolve(this.outDir, "../dist/client"));
+		} else if (pathHint === PathHint.Shared) {
+			makeRelative = this.makeRelativeFactory(undefined, path.resolve(this.outDir, "../dist/shared"));
+		} else {
+			makeRelative = this.makeRelativeFactory();
+		}
+
 		filePath = path.join(filePath);
 
 		const pathInfo = PathInfo.from(filePath);

src/Shared/constants.ts

@@ -52,6 +52,7 @@ export const DEFAULT_PROJECT_OPTIONS: ProjectOptions = {
 	usePolling: false,
 	json: false,
 	verbose: false,
+	skipPackages: false,
 	noInclude: false,
 	logTruthyChanges: false,
 	incremental: undefined,

src/Shared/diagnostics.ts

@@ -244,31 +244,41 @@ export const errors = {
 		];
 	}),
 
+	invalidServerMacroUse: error("invalid"),
+
 	requiredComponentTypeParameterRequired: errorWithContext((className: string) => {
 		return [
 			`@RequireComponent decorator on class '${className}' requires at least one type parameter`,
-			suggestion("Use @RequireComponent<ComponentType>() where ComponentType is a Unity component or AirshipBehaviour"),
+			suggestion(
+				"Use @RequireComponent<ComponentType>() where ComponentType is a Unity component or AirshipBehaviour",
+			),
 		];
 	}),
 
 	requiredComponentArgumentRequired: errorWithContext((className: string) => {
 		return [
 			`@RequireComponent decorator on class '${className}' requires at least one type parameter`,
-			suggestion("Use @RequireComponent<ComponentType>() where ComponentType is a Unity component or AirshipBehaviour"),
+			suggestion(
+				"Use @RequireComponent<ComponentType>() where ComponentType is a Unity component or AirshipBehaviour",
+			),
 		];
 	}),
 
 	requiredComponentInvalidType: errorWithContext((className: string, typeName: string) => {
 		return [
 			`@RequireComponent decorator on class '${className}' received invalid component type '${typeName}'`,
-			suggestion("Component type must be a Unity component or AirshipBehaviour. Try @RequireComponent<ValidComponentType>()"),
+			suggestion(
+				"Component type must be a Unity component or AirshipBehaviour. Try @RequireComponent<ValidComponentType>()",
+			),
 		];
 	}),
 
 	requiredComponentInvalidArgument: errorWithContext((className: string, argumentType: string) => {
 		return [
 			`@RequireComponent decorator on class '${className}' received invalid argument of type '${argumentType}'`,
-			suggestion("Use @RequireComponent<ComponentType>() where ComponentType is a Unity component or AirshipBehaviour"),
+			suggestion(
+				"Use @RequireComponent<ComponentType>() where ComponentType is a Unity component or AirshipBehaviour",
+			),
 		];
 	}),
 
@@ -308,6 +318,13 @@ export const errors = {
 		];
 	}),
 
+	directiveServerInvalid: error(
+		"$SERVER is a directive macro and can only be used as a top-level condition in an if statement - e.g. if ($SERVER)",
+	),
+	directiveClientInvalid: error(
+		"$CLIENT is a directive macro and can only be used as a top-level condition in an if statement - e.g. if ($CLIENT)",
+	),
+
 	flameworkIdNoType: errorWithContext(() => {
 		return [
 			"Macro Flamework.id<T> requires a type argument at T",

src/Shared/types.ts

@@ -28,6 +28,7 @@ export interface ProjectOptions {
 	watch: boolean;
 	json: boolean;
 	publish: boolean;
+	skipPackages: boolean;
 	writeOnlyChanged: boolean;
 	optimizedLoops: boolean;
 	allowCommentDirectives: boolean;