Estoy tratando de manipular AST en Rust. Habrá muchas manipulaciones, y quiero que mis árboles sean inmutables, por lo que para ahorrar tiempo todas las referencias seránRcs.

Los nodos de mi árbol se verán así:

enum Condition {
    Equals(Rc<Expression>, Rc<Expression>),
    LessThan(Rc<Expression>, Rc<Expression>),
    ...
}

enum Expression {
    Plus(Rc<Expression>, Rc<Expression>),
    ...
}

Quiero reemplazar un nodo aleatorio de un tipo dado con otro nodo del mismo tipo. Para realizar operaciones genéricas en árboles, he hecho un rasgo:

trait AstNode {
    fn children(&self) -> Vec<Rc<AstNode>>;
}

Y todos los nodos implementan esto. Esto me permite caminar por el árbol sin tener que desestructurar cada tipo de nodo para cada operación, simplemente llamandochildren().

También quiero clonar un nodo al actualizar solo uno de sus hijos y dejar los otros en su lugar. Suponga que he podido generar nodos del tipo concreto correcto (y estoy feliz de que el programa entre en pánico si me equivoco). Agregaré el siguiente método al rasgo:

trait AstNode {
    fn clone_with_children(&self, new_children: Vec<Rc<AstNode>>) -> Self
        where Self: Sized;
}

Mi plan es llevar a los niños devueltos porchilden(), reemplace uno de ellos y llameclone_with_children() para construir un nodo de la misma variante enum pero con un nodo reemplazado.

Mi problema es como escribirclone_with_children().

Necesito abatirRc<AstNode> aRc<Expression> (o lo que tenga), mientras mantiene el recuento dentro delRc lo mismo, pero ninguna de las bibliotecas de downcasting que he encontrado parece ser capaz de hacer eso.

¿Es posible lo que quiero o debería hacerlo de manera completamente diferente?