createParamArg function

Implementation

Expression createParamArg(
  ServerParam param, {
  Expression? defaultExpression,
  Map<String, Expression> customParams = const {},

  /// When true, the field of the class will be referenced instead of creating a
  /// new argument. This only applies if [ServerParam.argument] exists
  /// or [ServerParam.hasDefaultValue]
  bool useField = false,
}) {
  if (impliedArguments[param.type.name] case final expression?) {
    return expression;
  }

  if (impliedArguments[param.type.name.split('<').first]
      case final expression?) {
    return expression;
  }

  if (customParams[param.type.name] case final expression?) {
    return expression;
  }

  if (customParams[param.type.name.split('<').first] case final expression?) {
    return expression;
  }

  final annotation = param.annotations;
  if (!annotation.hasAnnotation &&
      !param.hasDefaultValue &&
      !param.hasArgument) {
    if (!param.type.isPrimitive) {
      if (defaultExpression != null) {
        if (useField) {
          return refer(param.name);
        }

        return defaultExpression;
      }
    }

    if (param.type.isNullable) {
      return literalNull;
    }

    throw ArgumentError(
      'No annotation or default value for param "${param.name}"',
    );
  }

  if (param.argument case final value?) {
    if (useField) {
      return refer(value.parameterName);
    }

    if (value.isInjectable) {
      return createGetFromDi();
    }

    return CodeExpression(Code(value.source));
  }

  if (param.defaultValue case final value? when !annotation.hasAnnotation) {
    if (useField) {
      return refer(param.name);
    }

    return CodeExpression(Code(value));
  }

  if (annotation.dep) {
    if (useField) {
      return refer(param.name);
    }

    return createGetFromDi();
  }

  if (annotation.bind case final bind?) {
    return createArgFromBind(bind, param);
  }

  if (annotation.baseAnnotation case final annotation?) {
    return createArgForParam(annotation, param);
  }

  if (annotation.data) {
    return createArgForParam(const DataAnnotation(), param);
  }

  if (defaultExpression != null) {
    return defaultExpression;
  }

  throw ArgumentError('Unknown annotation for param ${param.name}');
}