fn infer_from_block(all_para: &mut ParaMap, block: &Block) {
    s(block.span());
    //  For each statement in the block...
    //  e.g. `sensor::set_poll_rate_ms(sensor, poll_time) ?`
    for stmt in &block.stmts {
        //  Look for the expression inside the statement and infer the types from the expression.
        //  println!("stmt: {:#?}", stmt);
        match stmt {
            //  `let x = ...`
            syn::Stmt::Local(local) => {
                s(stmt.span());
                if let Some((_eq, expr)) = &local.init {
                    infer_from_expr(all_para, &expr);
                }
            }
            //  `fname( ... )`
            syn::Stmt::Expr(expr) => { 
                s(stmt.span());
                infer_from_expr(all_para, &expr); 
            }
            //  `fname( ... );`
            syn::Stmt::Semi(expr, _semi) => { 
                s(stmt.span());
                infer_from_expr(all_para, &expr); 
            }
            //  Not interested in item definitions: `fn fname( ... ) { ... }`
            syn::Stmt::Item(_item) => {}
        };
        /* `stmt` looks like:
                Semi(
                    Try(
                        ExprTry {
                            attrs: [],
                            expr: Call(
                                ExprCall {
                                    attrs: [],
                                    func: Path(
                                        ExprPath {
                                            attrs: [],
                                            qself: None,
                                            path: Path {
                                                leading_colon: None,
                                                segments: [
                                                    PathSegment {
                                                        ident: Ident {
                                                            ident: "sensor",
                                                            span: #0 bytes(0..0),
                                                        },
                                                        arguments: None,
                                                    },
                                                    Colon2,
                                                    PathSegment {
                                                        ident: Ident {
                                                            ident: "set_poll_rate_ms",
                                                            span: #0 bytes(0..0),
                                                        },
                                                        arguments: None, ...
        */        
    }
    s(block.span());
}
/// Infer the types of the parameters in `all_para` recursively from the code block `block`
Infer the types of the parameters in `all_para` recursively from the code block `block`
Infer the types of the parameters in ` all_para ` recursively from the code block ` block `
fn infer_from_block(all_para: &mut ParaMap, block: &Block) {
    s(block.span());
    //  For each statement in the block...
    //  e.g. `sensor::set_poll_rate_ms(sensor, poll_time) ?`
    for stmt in &block.stmts {
        //  Look for the expression inside the statement and infer the types from the expression.
        //  println!("stmt: {:#?}", stmt);
        match stmt {
            //  `let x = ...`
            syn::Stmt::Local(local) => {
                s(stmt.span());
                if let Some((_eq, expr)) = &local.init {
                    infer_from_expr(all_para, &expr);
                }
            }
            //  `fname( ... )`
            syn::Stmt::Expr(expr) => { 
                s(stmt.span());
                infer_from_expr(all_para, &expr); 
            }
            //  `fname( ... );`
            syn::Stmt::Semi(expr, _semi) => { 
                s(stmt.span());
                infer_from_expr(all_para, &expr); 
            }
            //  Not interested in item definitions: `fn fname( ... ) { ... }`
            syn::Stmt::Item(_item) => {}
        };
        /* `stmt` looks like:
                Semi(
                    Try(
                        ExprTry {
                            attrs: [],
                            expr: Call(
                                ExprCall {
                                    attrs: [],
                                    func: Path(
                                        ExprPath {
                                            attrs: [],
                                            qself: None,
                                            path: Path {
                                                leading_colon: None,
                                                segments: [
                                                    PathSegment {
                                                        ident: Ident {
                                                            ident: "sensor",
                                                            span: #0 bytes(0..0),
                                                        },
                                                        arguments: None,
                                                    },
                                                    Colon2,
                                                    PathSegment {
                                                        ident: Ident {
                                                            ident: "set_poll_rate_ms",
                                                            span: #0 bytes(0..0),
                                                        },
                                                        arguments: None, ...
        */        
    }
    s(block.span());
}
fn infer_from_block ( all_para : & mut ParaMap , block : & Block ) { s ( block . span ( ) ) ; //  For each statement in the block... //  e.g. `sensor::set_poll_rate_ms(sensor, poll_time) ?` for stmt in & block . stmts { //  Look for the expression inside the statement and infer the types from the expression. //  println!("stmt: {:#?}", stmt); match stmt { //  `let x = ...` syn :: Stmt :: Local ( local ) => { s ( stmt . span ( ) ) ; if let Some ( ( _eq , expr ) ) = & local . init { infer_from_expr ( all_para , & expr ) ; } } //  `fname( ... )` syn :: Stmt :: Expr ( expr ) => { s ( stmt . span ( ) ) ; infer_from_expr ( all_para , & expr ) ; } //  `fname( ... );` syn :: Stmt :: Semi ( expr , _semi ) => { s ( stmt . span ( ) ) ; infer_from_expr ( all_para , & expr ) ; } //  Not interested in item definitions: `fn fname( ... ) { ... }` syn :: Stmt :: Item ( _item ) => { } } ; /* `stmt` looks like:
                Semi(
                    Try(
                        ExprTry {
                            attrs: [],
                            expr: Call(
                                ExprCall {
                                    attrs: [],
                                    func: Path(
                                        ExprPath {
                                            attrs: [],
                                            qself: None,
                                            path: Path {
                                                leading_colon: None,
                                                segments: [
                                                    PathSegment {
                                                        ident: Ident {
                                                            ident: "sensor",
                                                            span: #0 bytes(0..0),
                                                        },
                                                        arguments: None,
                                                    },
                                                    Colon2,
                                                    PathSegment {
                                                        ident: Ident {
                                                            ident: "set_poll_rate_ms",
                                                            span: #0 bytes(0..0),
                                                        },
                                                        arguments: None, ...
        */ } s ( block . span ( ) ) ; }
Infer the types of the parameters in `all_para` recursively from the code block `block`
Infer the types of the parameters in ` all_para ` recursively from the code block ` block `
all_para
&mut ParaMap
block
&Block
all_para
&mut ParaMap
block
&Block