route_controller 0.2.0

A procedural macro for generating Axum routers from controller-style implementations with support for route prefixing and middleware
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//! Parameter analysis for route handlers

use proc_macro_error::emit_call_site_warning;
use syn::{FnArg, Pat, Type};

use super::extractor_types::ExtractorType;

#[derive(Clone)]
pub struct ParamInfo {
  pub pat: Pat,
  pub ty: Type,
  pub extractor_type: ExtractorType,
}

/// Analyzes function parameters using explicit extractor mappings from route attributes
pub fn analyze_params(
  sig: &syn::Signature,
  extractor_map: &std::collections::HashMap<String, ExtractorType>,
) -> Vec<ParamInfo> {
  let mut params = Vec::new();
  let mut seen_params = std::collections::HashSet::new();

  for input in &sig.inputs {
    if let FnArg::Typed(pat_type) = input {
      let pat = (*pat_type.pat).clone();
      let ty = (*pat_type.ty).clone();

      // Extract parameter name
      let param_name = if let Pat::Ident(pat_ident) = &pat {
        pat_ident.ident.to_string()
      } else {
        // For complex patterns, try to extract the first identifier
        emit_call_site_warning!(
          "Complex pattern in function parameter. Extractor mapping may not work correctly"
        );
        "unknown".to_string()
      };

      // Check for duplicate parameter names
      if !seen_params.insert(param_name.clone()) {
        emit_call_site_warning!(
          "Duplicate parameter name '{}' found in function signature",
          param_name
        );
      }

      // Get extractor type from the map, default to None
      let extractor_type = extractor_map
        .get(&param_name)
        .cloned()
        .unwrap_or_else(|| {
          // Warn about parameters without extractors
          if param_name != "unknown" {
            emit_call_site_warning!(
              "Parameter '{}' has no extractor specified. It will not receive any data from the request",
              param_name
            );
          }
          ExtractorType::None
        });

      params.push(ParamInfo {
        pat,
        ty,
        extractor_type,
      });
    }
  }

  // Check for extractors without matching parameters
  for (extractor_name, extractor_type) in extractor_map {
    if !seen_params.contains(extractor_name) {
      emit_call_site_warning!(
        "Extractor specified for parameter '{}' ({:?}) but no parameter with that name exists in the function signature",
        extractor_name,
        extractor_type
      );
    }
  }

  params
}