fn infer_from_call(all_para: &mut ParaMap, call: &syn::ExprCall) {
    //  println!("call: {:#?}", call);
    s(call.span());
    //  For each function call `ExprCall`...    
    //  If this function call `ExprCall.func` is for a Mynewt API...
    //  e.g. `sensor::set_poll_rate_ms(sensor, poll_time) ? ;`
    let func = &call.func;
    //  println!("func: {:#?}", quote!{ #func }.to_string());

    //  `fname` looks like `sensor::set_poll_rate_ms`
    let fname = quote!{ #func }.to_string().replace(" ", "");
    //  println!("fname: {:#?}", fname);

    //  Fetch the Mynewt API function declaration
    //  e.g. `fn sensor::set_poll_rate_ms(&Strn, u32)`
    let decl_list = get_decl(&fname);
    if decl_list.len() == 0 { return };  //  Function declaration not found.
    m(&fname, call.span());

    //  For each argument `arg` in function call `ExprCall.args` e.g. `sensor`, `poll_time`, ...
    let args = &call.args;
    s(args.span());
    for pos in 0 .. args.len() {
        //  Match the identifier `ident` in `arg` (e.g. `sensor`) with the corresponding Mynewt API 
        //  parameter type `decl_type` (e.g. `&Strn`).
        //  TODO: If argument `arg` is not in our list of parameters `all_para`, skip.
        let arg = &args[pos];
        let arg_str = quote!{ #arg }.to_string().replace(" ", "");
        let decl_type = &decl_list[pos][1];
        //  println!("arg: {:#?}", arg);

        //  Remember the inferred type of the identifier...
        //  `sensor` has inferred type `&Strn`
        //  `poll_time` has inferred type `u32`
        all_para.insert(Box::new(arg_str.clone()), Box::new(decl_type.to_string()));

        println!("{}: {} has inferred type {}", get_current_function(), arg_str, decl_type);
        s(arg.span());

        #[cfg(procmacro2_semver_exempt)]  //  For replay log
        {
            let decl_name = &decl_list[pos][0];
            println!("#i {} | {} | {} | {} | {}", get_current_function(), arg_str, fname, decl_name, decl_type);
        }

        /* `arg` looks like:
            Path(
            ExprPath {
                attrs: [],
                qself: None,
                path: Path {
                    leading_colon: None,
                    segments: [
                        PathSegment {
                            ident: Ident {
                                ident: "sensor",
                                span: #0 bytes(0..0),
                            },
                            arguments: None, ...
        */
    }
    s(args.span());
    s(call.span());
}
/// Infer the types of the parameters in `all_para` recursively from the function call `call`
Infer the types of the parameters in `all_para` recursively from the function call `call`
Infer the types of the parameters in ` all_para ` recursively from the function call ` call `
fn infer_from_call(all_para: &mut ParaMap, call: &syn::ExprCall) {
    //  println!("call: {:#?}", call);
    s(call.span());
    //  For each function call `ExprCall`...    
    //  If this function call `ExprCall.func` is for a Mynewt API...
    //  e.g. `sensor::set_poll_rate_ms(sensor, poll_time) ? ;`
    let func = &call.func;
    //  println!("func: {:#?}", quote!{ #func }.to_string());
    //  `fname` looks like `sensor::set_poll_rate_ms`
    let fname = quote!{ #func }.to_string().replace(" ", "");
    //  println!("fname: {:#?}", fname);
    //  Fetch the Mynewt API function declaration
    //  e.g. `fn sensor::set_poll_rate_ms(&Strn, u32)`
    let decl_list = get_decl(&fname);
    if decl_list.len() == 0 { return };  //  Function declaration not found.
    m(&fname, call.span());
    //  For each argument `arg` in function call `ExprCall.args` e.g. `sensor`, `poll_time`, ...
    let args = &call.args;
    s(args.span());
    for pos in 0 .. args.len() {
        //  Match the identifier `ident` in `arg` (e.g. `sensor`) with the corresponding Mynewt API 
        //  parameter type `decl_type` (e.g. `&Strn`).
        //  TODO: If argument `arg` is not in our list of parameters `all_para`, skip.
        let arg = &args[pos];
        let arg_str = quote!{ #arg }.to_string().replace(" ", "");
        let decl_type = &decl_list[pos][1];
        //  println!("arg: {:#?}", arg);
        //  Remember the inferred type of the identifier...
        //  `sensor` has inferred type `&Strn`
        //  `poll_time` has inferred type `u32`
        all_para.insert(Box::new(arg_str.clone()), Box::new(decl_type.to_string()));
        println!("{}: {} has inferred type {}", get_current_function(), arg_str, decl_type);
        s(arg.span());
        #[cfg(procmacro2_semver_exempt)]  //  For replay log
        {
            let decl_name = &decl_list[pos][0];
            println!("#i {} | {} | {} | {} | {}", get_current_function(), arg_str, fname, decl_name, decl_type);
        }
        /* `arg` looks like:
            Path(
            ExprPath {
                attrs: [],
                qself: None,
                path: Path {
                    leading_colon: None,
                    segments: [
                        PathSegment {
                            ident: Ident {
                                ident: "sensor",
                                span: #0 bytes(0..0),
                            },
                            arguments: None, ...
        */
    }
    s(args.span());
    s(call.span());
}
fn infer_from_call ( all_para : & mut ParaMap , call : & syn :: ExprCall ) { //  println!("call: {:#?}", call); s ( call . span ( ) ) ; //  For each function call `ExprCall`...     //  If this function call `ExprCall.func` is for a Mynewt API... //  e.g. `sensor::set_poll_rate_ms(sensor, poll_time) ? ;` let func = & call . func ; //  println!("func: {:#?}", quote!{ #func }.to_string()); //  `fname` looks like `sensor::set_poll_rate_ms` let fname = quote ! { func } . to_string ( ) . replace ( " " , " " ) ; //  println!("fname: {:#?}", fname); //  Fetch the Mynewt API function declaration //  e.g. `fn sensor::set_poll_rate_ms(&Strn, u32)` let decl_list = get_decl ( & fname ) ; if decl_list . len ( ) == 0 { return } ; //  Function declaration not found. m ( & fname , call . span ( ) ) ; //  For each argument `arg` in function call `ExprCall.args` e.g. `sensor`, `poll_time`, ... let args = & call . args ; s ( args . span ( ) ) ; for pos in 0 .. args . len ( ) { //  Match the identifier `ident` in `arg` (e.g. `sensor`) with the corresponding Mynewt API  //  parameter type `decl_type` (e.g. `&Strn`). //  TODO: If argument `arg` is not in our list of parameters `all_para`, skip. let arg = & args [ pos ] ; let arg_str = quote ! { arg } . to_string ( ) . replace ( " " , " " ) ; let decl_type = & decl_list [ pos ] [ 1 ] ; //  println!("arg: {:#?}", arg); //  Remember the inferred type of the identifier... //  `sensor` has inferred type `&Strn` //  `poll_time` has inferred type `u32` all_para . insert ( Box :: new ( arg_str . clone ( ) ) , Box :: new ( decl_type . to_string ( ) ) ) ; println ! ( " " get_current_function ( ) arg_str decl_type ) ; s ( arg . span ( ) ) ; # [ cfg ( procmacro2_semver_exempt ) ] //  For replay log { let decl_name = & decl_list [ pos ] [ 0 ] ; println ! ( " " get_current_function ( ) arg_str fname decl_name decl_type ) ; } /* `arg` looks like:
            Path(
            ExprPath {
                attrs: [],
                qself: None,
                path: Path {
                    leading_colon: None,
                    segments: [
                        PathSegment {
                            ident: Ident {
                                ident: "sensor",
                                span: #0 bytes(0..0),
                            },
                            arguments: None, ...
        */ } s ( args . span ( ) ) ; s ( call . span ( ) ) ; }
Infer the types of the parameters in `all_para` recursively from the function call `call`
Infer the types of the parameters in ` all_para ` recursively from the function call ` call `
all_para
&mut ParaMap
call
&syn::ExprCall
all_para
&mut ParaMap
call
&syn::ExprCall