feat: add unity RequireComponent compatibility (#114)

* feat: add RequireComponent class decorator functionally

* feat(transformer): more consistent unity like decorator

* refactor: change decorator to type parameters

Author: iRevolutionDev

src/Shared/diagnostics.ts

@@ -244,6 +244,34 @@ export const errors = {
 		];
 	}),
 
+	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"),
+		];
+	}),
+
+	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"),
+		];
+	}),
+
+	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>()"),
+		];
+	}),
+
+	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"),
+		];
+	}),
+
 	unityMacroTypeArgumentRequired: errorWithContext((methodName: string) => {
 		return [
 			`Macro ${methodName}<T>() requires a type argument at T`,
@@ -252,7 +280,7 @@ export const errors = {
 	}),
 
 	decoratorParamsLiteralsOnly: error(
-		"Airship Behaviour decorators only accept literal `string`, `boolean` or `number` values",
+		"Airship Behaviour decorators only accept literal `string`, `boolean` or `number` values. For RequireComponent, use `typeof(ComponentType)` syntax.",
 	),
 
 	// files

src/TSTransformer/nodes/class/transformClassLikeDeclaration.ts

@@ -615,47 +615,113 @@ function createAirshipProperty(
 	return prop;
 }
 
-export function getClassDecorators(state: TransformState, classNode: ts.ClassLikeDeclaration) {
-	const decorators = ts.hasDecorators(classNode) ? ts.getDecorators(classNode) : undefined;
-	if (decorators) {
-		const items = new Array<AirshipBehaviourClassDecorator>();
+function processRequireComponentDecorator(
+	state: TransformState,
+	classNode: ts.ClassLikeDeclaration,
+	expression: ts.CallExpression,
+): AirshipBehaviourClassDecorator | undefined {
+	const typeChecker = state.typeChecker;
+	const typeArguments = expression.typeArguments;
+	
+	if (!typeArguments || typeArguments.length === 0) {
+		DiagnosticService.addDiagnostic(errors.requiredComponentTypeParameterRequired(classNode, classNode.name?.text || "<anonymous>"));
+		return undefined;
+	}
 
-		for (const decorator of decorators) {
-			const expression = decorator.expression;
-			if (!ts.isCallExpression(expression)) continue;
+	const componentParameters = new Array<AirshipBehaviourFieldDecoratorParameter>();
+	for (const typeArgument of typeArguments) {
+		const type = typeChecker.getTypeFromTypeNode(typeArgument);
 
-			const aliasSymbol = state.typeChecker.getTypeAtLocation(expression).aliasSymbol;
-			if (!aliasSymbol) continue;
+		if (isAirshipBehaviourType(state, type)) {
+			const typeString = typeChecker.typeToString(type);
+			componentParameters.push({
+				type: "AirshipBehaviour",
+				value: typeString,
+			});
+		} else if (isUnityObjectType(state, type)) {
+			const nonNullableType = typeChecker.getNonNullableType(type);
+			const nonNullableTypeString = typeChecker.typeToString(nonNullableType);
+			componentParameters.push({
+				type: "object",
+				value: nonNullableTypeString,
+			});
+		} else {
+			const typeString = typeChecker.typeToString(type);
+			DiagnosticService.addDiagnostic(errors.requiredComponentInvalidType(classNode, classNode.name?.text ?? "<anonymous>", typeString));
+		}
+	}
 
-			const airshipFieldSymbol = state.services.airshipSymbolManager.getSymbolOrThrow("AirshipDecorator");
+	if (componentParameters.length === 0) {
+		return undefined;
+	}
 
-			if (aliasSymbol === airshipFieldSymbol) {
-				items.push({
-					name: expression.expression.getText(),
-					typeParameters: expression.typeArguments?.map(typeNode => {
-						return state.typeChecker.typeToString(state.typeChecker.getTypeFromTypeNode(typeNode));
-					}),
-					parameters: expression.arguments.map((argument, i): AirshipBehaviourFieldDecoratorParameter => {
-						const value = getLiteralFromNode(state, argument);
+	return {
+		name: "RequireComponent",
+		typeParameters: expression.typeArguments?.map(typeNode => {
+			return state.typeChecker.typeToString(state.typeChecker.getTypeFromTypeNode(typeNode));
+		}),
+		parameters: componentParameters,
+	};
+}
 
-						if (value) {
-							return value;
-						} else {
-							DiagnosticService.addDiagnostic(
-								errors.decoratorParamsLiteralsOnly(expression.arguments[i]),
-							);
+function processGenericDecorator(
+	state: TransformState,
+	expression: ts.CallExpression,
+	decoratorName: string,
+): AirshipBehaviourClassDecorator {
+	return {
+		name: decoratorName,
+		typeParameters: expression.typeArguments?.map(typeNode => {
+			return state.typeChecker.typeToString(state.typeChecker.getTypeFromTypeNode(typeNode));
+		}),
+		parameters: expression.arguments.map((argument, i): AirshipBehaviourFieldDecoratorParameter => {
+			const value = getLiteralFromNode(state, argument);
 
-							return { type: "invalid", value: undefined };
-						}
-					}),
-				});
+			if (value) {
+				return value;
+			} else {
+				DiagnosticService.addDiagnostic(
+					errors.decoratorParamsLiteralsOnly(expression.arguments[i]),
+				);
+
+				return { type: "invalid", value: undefined };
 			}
-		}
+		}),
+	};
+}
 
-		return items;
-	} else {
+export function getClassDecorators(state: TransformState, classNode: ts.ClassLikeDeclaration) {
+	const decorators = ts.hasDecorators(classNode) ? ts.getDecorators(classNode) : undefined;
+	if (!decorators) {
 		return [];
 	}
+
+	const items = new Array<AirshipBehaviourClassDecorator>();
+
+	for (const decorator of decorators) {
+		const expression = decorator.expression;
+		if (!ts.isCallExpression(expression)) continue;
+
+		const aliasSymbol = state.typeChecker.getTypeAtLocation(expression).aliasSymbol;
+		if (!aliasSymbol) continue;
+
+		const airshipFieldSymbol = state.services.airshipSymbolManager.getSymbolOrThrow("AirshipDecorator");
+		if (aliasSymbol !== airshipFieldSymbol) continue;
+
+		const decoratorName = expression.expression.getText();
+		
+		if (decoratorName === "RequireComponent") {
+			const processedDecorator = processRequireComponentDecorator(state, classNode, expression);
+			if (processedDecorator) {
+				items.push(processedDecorator);
+			}
+		} else {
+			const processedDecorator = processGenericDecorator(state, expression, decoratorName);
+			items.push(processedDecorator);
+		}
+	}
+
+	return items;
 }
 
 function getPropertyDecorators(
@@ -1056,3 +1122,4 @@ export function transformClassLikeDeclaration(state: TransformState, node: ts.Cl
 
 	return { statements, name: returnVar };
 }
+