# Suporte a Rust no Maguyva: Contexto Seguro para Mudanças Assistidas por IA

Canonical source: https://maguyva.ai/pt-br/languages/rust

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

O Maguyva oferece suporte a Rust com parsing de AST e extração de símbolos, permitindo que agentes de IA naveguem por módulos, blocos impl, construtores e caminhos de dependência antes de alterar código rigoroso e voltado à segurança.

## Panorama de suporte

- Nível: Suporte a AST e símbolos
- Programação
- Extensões: .rs
- Parsing real de AST para busca com consciência de sintaxe e contexto estrutural.
- Símbolos nomeados alimentam a busca semântica e as referências cruzadas. A navegação por grafo fica disponível quando a extração de relações está habilitada.
- Esta linguagem fornece símbolos e relações para a busca orientada por grafo; os tipos de aresta compatíveis variam de acordo com seus construtos nativos.
- A análise de AST e a extração de símbolos estão disponíveis.

## Uso ideal

- Repositórios de sistemas, plataforma ou CLI em que Rust é escolhido porque correção e segurança nas mudanças realmente importam.
- Equipes que querem ajuda de IA para explorar um codebase Rust antes de editar lógica sensível a ownership ou de baixo nível.
- Repositórios em que módulos, tipos gerados, macros e ferramentas ao redor tornam o raciocínio de um único arquivo pouco confiável.

## Fluxos de trabalho de agente

- Rastrear onde uma struct ou componente é construído antes de mudar seu comportamento.
- Comparar padrões de módulos e formatos de implementação em vez de inventar um novo.
- Encontrar os caminhos que dependem de um tipo ou helper antes de pedir ao agente que o refatore.

## Por que mudanças em Rust exigem mais do que autocomplete

Rust é um dos casos mais claros em que a IA deveria navegar primeiro e editar depois. A linguagem geralmente é escolhida porque correção importa, não porque a equipe quer mais geração especulativa de mudanças. Então o padrão para "suporte a Rust" deveria ser alto: o agente consegue entender limites de módulo, blocos impl, construção de tipos concretos e o contexto ao redor antes de propor uma refatoração?

Esse é o verdadeiro limiar de valor. A geração de sintaxe não é a parte interessante.

## O que o Maguyva realmente extrai em Rust

O Maguyva captura funções e blocos de implementação Rust como conceitos estruturais distintos, e trata expressões de struct como instanciações reais. Isso dá ao grafo uma visão útil de onde tipos concretos são construídos, não apenas onde são nomeados.

A configuração também filtra uma grande quantidade de ruído de macros e de stdlib, o que é importante em Rust, porque código rico em macros pode, de outra forma, inundar o grafo com coisas que são chamadas tecnicamente válidas, mas pouco úteis quando você está tentando entender o comportamento do repositório.

## Fluxos de trabalho com MCP úteis para repositórios Rust

Os padrões iniciais mais úteis são:

- `find_symbol` para a struct, enum ou função pertencente a um módulo que você está prestes a mudar.
- `dependency_search` antes de refatorar um tipo central, para saber quais caminhos de código dependem dele.
- `get_task_context` para prompts conceituais como "rastrear a lógica de retry em torno do client HTTP" quando o caminho atravessa vários módulos.

## Onde esta página é mais relevante

Use esta página se você quiser assistência de IA em Rust sem abrir mão do fluxo de trabalho cauteloso que torna Rust vantajoso de usar. Se o repositório é mais orientado a serviços do que a sistemas, [Go](/pt-br/languages/go) é a comparação mais próxima. Se Rust é apenas uma parte de um parque maior, a história multilíngue na [página de stack](/pt-br/stack) importa mais do que a checklist do parser.

## Detalhes do motor

- `impl_item` e `function_item` são capturados de forma distinta, o que ajuda a separar funções concretas de blocos de implementação.
- Expressões de struct contam como instanciações, então o grafo consegue seguir onde os tipos são de fato construídos.
- Macros e construtores comuns da stdlib são filtrados de forma agressiva para o grafo de relações permanecer focado no código do repositório.

## Pontos de entrada MCP úteis

- `find_symbol`: Comece pela struct, enum ou função de módulo que te interessa e expanda a partir daí.
- `dependency_search`: Use antes de mexer num tipo ou módulo central para ver quais partes do código o utilizam, não só as referências locais.
- `get_task_context`: Útil quando a tarefa é conceitual, como rastrear lógica de retry ou ciclos de vida de recurso entre módulos.