Dado un código fuente de C ++, quiero encontrar los campos de clase que cada función escribe y lee. ¿Cuál es la mejor manera de hacer esto usando la interfaz de Clang?

(No estoy pidiendo una explicación detallada de todos los pasos; sin embargo, un punto de partida para una solución eficiente sería genial).

Hasta ahora intenté analizar las declaraciones usando el RecursiveASTVisitor, pero es difícil hacer un seguimiento de las conexiones de nodos. Además, no puedo entender cómo hacer un seguimiento de algo como a continuación:

int& x = m_int_field;
x++;

Esto modifica claramentem_int_field; pero dado un soloStmt es imposible saber eso; por lo tanto, el recorrido AST por sí solo parece insuficiente.

Una ventaja para mí es poder contar por separado los campos y subcampos (por ejemplo, acceder a tres campos de una estructura de miembro).

Ejemplo:

typedef struct Y {
    int m_structfield1;
    float m_structfield2;
    Y () {
        m_structfield1 = 0;
        m_structfield2 = 1.0f;
    }
} Y;
class X {
    int m_field1;
    std::string m_field2;
    Y m_field3;
public:
    X () : m_field2("lel") {}
    virtual ~X() {}
    void func1 (std::string s) {
        m_field1 += 2;
        m_field2 = s;
    }
    int func2 () {
        return m_field1 + 5;
    }
    void func3 (Y& y) {
        int& i = m_field1;
        y.m_structfield2 = 1.2f + i++;
    }
    int func4 () {
        func3 (m_field3);
        return m_field3.m_structfield1;
    }
};

debería volver

X::X() -> m_field1 (w), m_field3.m_structfield1 (w), m_field3.m_structfield2 (w)
X::func1(std::string) -> m_field1 (r+w), m_field2 (w)
X::func2() -> m_field1 (r)
X::func3(Y&) -> m_field1 (r+w)
X::func4() -> m_field1 (r+w), m_field3.m_structfield2 (w), m_field3.m_structfield1 (r)

Podemos suponer por simplicidad que no hay herencia.