Simplify handle_function_macro for clang 4.0+

Author: kulp

src/ir/var.rs

@@ -149,52 +149,27 @@ fn default_macro_constant_type(ctx: &BindgenContext, value: i64) -> IntKind {
     }
 }
 
-/// Determines whether a set of tokens from a CXCursor_MacroDefinition
-/// represent a function-like macro. If so, calls the func_macro callback
-/// and returns `Err(ParseError::Continue)` to signal to skip further
-/// processing. If conversion to UTF-8 fails (it is performed only where it
-/// should be infallible), then `Err(ParseError::Continue)` is returned as well.
+/// Parses tokens from a CXCursor_MacroDefinition pointing into a function-like
+/// macro, and calls the func_macro callback.
 fn handle_function_macro(
     cursor: &clang::Cursor,
-    tokens: &[ClangToken],
     callbacks: &dyn crate::callbacks::ParseCallbacks,
-) -> Result<(), ParseError> {
-    // TODO: Hoist the `is_macro_function_like` check into this function's
-    // caller, and thus avoid allocating the `tokens` vector for non-functional
-    // macros.
-    let is_functional_macro = cursor.is_macro_function_like();
-
-    if !is_functional_macro {
-        return Ok(());
-    }
-
+) {
     let is_closing_paren = |t: &ClangToken| {
         // Test cheap token kind before comparing exact spellings.
         t.kind == clang_sys::CXToken_Punctuation && t.spelling() == b")"
     };
-    let boundary = tokens.iter().position(is_closing_paren);
-
-    let mut spelled = tokens.iter().map(ClangToken::spelling);
-    // Add 1, to convert index to length.
-    let left = spelled
-        .by_ref()
-        .take(boundary.ok_or(ParseError::Continue)? + 1);
-    let left = left.collect::<Vec<_>>().concat();
-    let left = String::from_utf8(left).map_err(|_| ParseError::Continue)?;
-    let right = spelled;
-    // Drop last token with LLVM < 4.0, due to an LLVM bug.
-    //
-    // See:
-    //   https://bugs.llvm.org//show_bug.cgi?id=9069
-    let len = match (right.len(), crate::clang_version().parsed) {
-        (len, Some((v, _))) if len > 0 && v < 4 => len - 1,
-        (len, _) => len,
-    };
-    let right: Vec<_> = right.take(len).collect();
-    callbacks.func_macro(&left, &right);
-
-    // We handled the macro, skip future macro processing.
-    Err(ParseError::Continue)
+    let tokens: Vec<_> = cursor.tokens().iter().collect();
+    if let Some(boundary) = tokens.iter().position(is_closing_paren) {
+        let mut spelled = tokens.iter().map(ClangToken::spelling);
+        // Add 1, to convert index to length.
+        let left = spelled.by_ref().take(boundary + 1);
+        let left = left.collect::<Vec<_>>().concat();
+        if let Ok(left) = String::from_utf8(left) {
+            let right: Vec<_> = spelled.collect();
+            callbacks.func_macro(&left, &right);
+        }
+    }
 }
 
 impl ClangSubItemParser for Var {
@@ -207,8 +182,6 @@ impl ClangSubItemParser for Var {
         use clang_sys::*;
         match cursor.kind() {
             CXCursor_MacroDefinition => {
-                let tokens: Vec<_> = cursor.tokens().iter().collect();
-
                 if let Some(callbacks) = ctx.parse_callbacks() {
                     match callbacks.will_parse_macro(&cursor.spelling()) {
                         MacroParsingBehavior::Ignore => {
@@ -217,10 +190,14 @@ impl ClangSubItemParser for Var {
                         MacroParsingBehavior::Default => {}
                     }
 
-                    handle_function_macro(&cursor, &tokens, callbacks)?;
+                    if cursor.is_macro_function_like() {
+                        handle_function_macro(&cursor, callbacks);
+                        // We handled the macro, skip macro processing below.
+                        return Err(ParseError::Continue);
+                    }
                 }
 
-                let value = parse_macro(ctx, &tokens);
+                let value = parse_macro(ctx, &cursor);
 
                 let (id, value) = match value {
                     Some(v) => v,
@@ -387,14 +364,11 @@ impl ClangSubItemParser for Var {
 /// Try and parse a macro using all the macros parsed until now.
 fn parse_macro(
     ctx: &BindgenContext,
-    tokens: &[ClangToken],
+    cursor: &clang::Cursor,
 ) -> Option<(Vec<u8>, cexpr::expr::EvalResult)> {
     use cexpr::expr;
 
-    let cexpr_tokens: Vec<_> = tokens
-        .iter()
-        .filter_map(ClangToken::as_cexpr_token)
-        .collect();
+    let cexpr_tokens = cursor.cexpr_tokens();
 
     let parser = expr::IdentifierParser::new(ctx.parsed_macros());