feat: Support query union name and location in source code

Author: AmrDeveloper

README.md

@@ -83,6 +83,22 @@ SELECT * FROM globals WHERE is_volatile
 
 ---
 
+<details>
+
+  <summary>Unions table</summary>
+
+  | Name   | Type    | Description             |
+  | ------ | ------- | ----------------------- |
+  | name   | Text    | Union name              |
+  | file   | Text    | File path               |
+  | line   | Integer | Line at the file path   |
+  | column | Integer | Column at the file path |
+  | offset | Integer | Offset at the file path |
+
+</details>
+
+---
+
 <details>
 
   <summary>Functions table</summary>

src/data_provider.rs

@@ -13,6 +13,7 @@ use crate::visitor::class;
 use crate::visitor::enumeration;
 use crate::visitor::function;
 use crate::visitor::global;
+use crate::visitor::unions;
 pub struct ClangAstDataProvider {
     pub paths: Vec<String>,
 }
@@ -69,6 +70,7 @@ fn select_clang_ast_objects(
     match table.as_str() {
         "classes" => select_classes(env, path, fields_names, titles, fields_values),
         "enums" => select_enumss(env, path, fields_names, titles, fields_values),
+        "unions" => select_unions(env, path, fields_names, titles, fields_values),
         "functions" => select_functions(env, path, fields_names, titles, fields_values),
         "globals" => select_variables(env, path, fields_names, titles, fields_values),
         _ => select_values(env, titles, fields_values),
@@ -245,6 +247,70 @@ fn select_enumss(
     Ok(Group { rows })
 }
 
+fn select_unions(
+    env: &mut Environment,
+    path: &str,
+    fields_names: &[String],
+    titles: &[String],
+    fields_values: &[Box<dyn Expression>],
+) -> Result<Group, String> {
+    let mut rows: Vec<Row> = vec![];
+
+    let names_len = fields_names.len() as i64;
+    let values_len = fields_values.len() as i64;
+    let padding = names_len - values_len;
+
+    let ast_unions = unions::select_clang_unions(path);
+    for union_node in ast_unions.iter() {
+        let mut values: Vec<Value> = Vec::with_capacity(fields_names.len());
+
+        for index in 0..names_len {
+            let field_name = &fields_names[index as usize];
+
+            if (index - padding) >= 0 {
+                let value = &fields_values[(index - padding) as usize];
+                if value.as_any().downcast_ref::<SymbolExpression>().is_none() {
+                    let evaluated = evaluate_expression(env, value, titles, &values)?;
+                    values.push(evaluated);
+                    continue;
+                }
+            }
+
+            if field_name == "name" {
+                values.push(Value::Text(union_node.name.to_owned()));
+                continue;
+            }
+
+            if field_name == "file" {
+                values.push(Value::Text(union_node.location.file.to_string()));
+                continue;
+            }
+
+            if field_name == "line" {
+                values.push(Value::Integer(union_node.location.line.into()));
+                continue;
+            }
+
+            if field_name == "column" {
+                values.push(Value::Integer(union_node.location.column.into()));
+                continue;
+            }
+
+            if field_name == "offset" {
+                values.push(Value::Integer(union_node.location.offset.into()));
+                continue;
+            }
+
+            values.push(Value::Null);
+        }
+
+        let row = Row { values };
+        rows.push(row);
+    }
+
+    Ok(Group { rows })
+}
+
 fn select_functions(
     env: &mut Environment,
     path: &str,

src/schema.rs

@@ -69,11 +69,13 @@ pub fn tables_fields_names() -> &'static HashMap<&'static str, Vec<&'static str>
                 "name",
                 "constants_count",
                 "type_literal",
+                "file",
                 "line",
                 "column",
                 "offset",
             ],
         );
+        map.insert("unions", vec!["name", "file", "line", "column", "offset"]);
         map.insert(
             "functions",
             vec![

src/visitor/mod.rs

@@ -3,3 +3,4 @@ pub mod enumeration;
 pub mod function;
 pub mod global;
 pub mod location;
+pub mod unions;

src/visitor/unions.rs

@@ -0,0 +1,71 @@
+extern crate clang_sys;
+
+use clang_sys::*;
+use std::ffi::c_char;
+use std::ffi::c_void;
+use std::ffi::CStr;
+use std::ptr;
+
+use crate::visitor::location;
+pub struct UnionNode {
+    pub name: String,
+    pub location: location::SourceLocation,
+}
+
+pub fn select_clang_unions(path: &str) -> Vec<UnionNode> {
+    let mut unions: Vec<UnionNode> = Vec::new();
+    let data = &mut unions as *mut Vec<UnionNode> as *mut c_void;
+
+    unsafe {
+        let index = clang_createIndex(0, 0);
+        let translation_unit: CXTranslationUnit = clang_parseTranslationUnit(
+            index,
+            path.as_ptr() as *const c_char,
+            ptr::null_mut(),
+            0,
+            ptr::null_mut(),
+            0,
+            0,
+        );
+
+        let cursor = clang_getTranslationUnitCursor(translation_unit);
+        clang_visitChildren(cursor, visit_union_declaration, data);
+
+        // Dispose the translation unit
+        clang_disposeTranslationUnit(translation_unit);
+
+        // Dispose the index
+        clang_disposeIndex(index);
+    }
+
+    unions
+}
+
+extern "C" fn visit_union_declaration(
+    cursor: CXCursor,
+    _parent: CXCursor,
+    data: *mut c_void,
+) -> CXChildVisitResult {
+    unsafe {
+        if clang_Location_isFromMainFile(clang_getCursorLocation(cursor)) == 0 {
+            return CXChildVisit_Continue;
+        }
+
+        let cursor_kind = clang_getCursorKind(cursor);
+        if cursor_kind == CXCursor_UnionDecl {
+            let cursor_name = clang_getCursorSpelling(cursor);
+            let union_name = CStr::from_ptr(clang_getCString(cursor_name)).to_string_lossy();
+            let location = location::visit_source_location(cursor);
+
+            let unions: &mut Vec<UnionNode> = &mut *(data as *mut Vec<UnionNode>);
+            unions.push(UnionNode {
+                name: union_name.to_string(),
+                location,
+            });
+
+            clang_disposeString(cursor_name);
+            return CXChildVisit_Continue;
+        }
+    }
+    CXChildVisit_Recurse
+}