{"meta":{"title":"Opciones y pasos de compilación de CodeQL para lenguajes compilados","intro":"Obtenga información sobre cómo CodeQL compila lenguajes compilados, incluidos los modos de compilación disponibles y el comportamiento de autocompilación específico del lenguaje para C/C++, C#, Go, Java, Kotlin, Rust y Swift.","product":"Seguridad y calidad del código","breadcrumbs":[{"href":"/es/code-security","title":"Seguridad y calidad del código"},{"href":"/es/code-security/reference","title":"Referencia"},{"href":"/es/code-security/reference/code-scanning","title":"Análisis de código"},{"href":"/es/code-security/reference/code-scanning/codeql","title":"CodeQL"},{"href":"/es/code-security/reference/code-scanning/codeql/build-options-for-compiled-languages","title":"Opciones de construcción para lenguajes compilados"}],"documentType":"article"},"body":"# Opciones y pasos de compilación de CodeQL para lenguajes compilados\n\nObtenga información sobre cómo CodeQL compila lenguajes compilados, incluidos los modos de compilación disponibles y el comportamiento de autocompilación específico del lenguaje para C/C++, C#, Go, Java, Kotlin, Rust y Swift.\n\n## Adición de pasos de Autobuild para lenguajes compilados\n\n```\n          Los ejecutores hospedados or GitHub siempre se ejecutan con el software necesario para `autobuild`.\n```\n\nSi usa ejecutores autohospedados para GitHub Actions, es posible que tenga que instalar software adicional para usar el proceso `autobuild`. Adicionalmente, si tu repositorio requiere de una versión específica de una herramienta de compilación, tal vez necesites instalarla manualmente.\n\n> \\[!NOTE]\n> Si en el flujo de trabajo se usa una matriz `language`, `autobuild` intenta compilar cada uno de los lenguajes compilados enumerados en la matriz. Sin una matriz, `autobuild` intentará compilar el lenguaje compilado compatible que tenga más archivos de código fuente en el repositorio. Con la excepción de Go, el análisis de otros lenguajes compilados en tu repositorio siempre fallará a menos de que proporciones comandos de compilación específicos.\n\n## Compilación de C/C++\n\nCodeQLadmite los modos `none``autobuild`de compilación o `manual` para el código de C/C++.\n\nCuando se habilita la configuración predeterminada para un repositorio que contiene código de C/C++, el modo de compilación se establece en `none` automáticamente.\n\n### No hay ninguna compilación para C/C++\n\nCodeQL deducirá las unidades de compilación de C/C++ a través de extensiones de archivo de origen. Para cada archivo de origen encontrado, las marcas de compilación y las rutas de acceso de inclusión se deducen inspeccionando el código base sin necesidad de un comando de compilación en funcionamiento.\n\n#### Precisión del análisis sin compilación para C/C++\n\nLa creación de una CodeQL base de datos de C/C++ sin una compilación puede producir resultados menos precisos que usar `autobuild` o pasos de compilación manuales en algunos casos; por ejemplo, si:\n\n* El código depende en gran medida de macros/defines personalizados que no están disponibles en las cabeceras existentes.\n* El código base tiene muchas dependencias externas.\n\nPara garantizar un análisis más preciso, siga estos pasos:\n\n* Coloque macros personalizadas y defina en los archivos de encabezado que se incluyen en los archivos de código fuente pertinentes.\n* Asegúrese de que las dependencias externas (encabezados) están disponibles en los directorios include del sistema o en el área de trabajo.\n* Ejecute la extracción en la plataforma de destino. Por ejemplo, elija un runner de Windows para analizar proyectos de Windows que permitan acceder a los encabezados y compiladores específicos de la plataforma.\n\n### Resumen de compilación automática para C/C++\n\n| Tipo de sistema compatible | Nombre del sistema                                                                                                                                  |\n| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Sistema operativo          | Windows, macOS y Linux                                                                                                                              |\n| Sistema de compilación     | Windows: MSbuild y scripts de compilación<br/>Linux y macOS: Autoconf, Make, CMake, qmake, Meson, Waf, SCons, Linux Kbuild y scripts de compilación |\n\nEl comportamiento del paso `autobuild` varía en función del sistema operativo en el que se ejecute la extracción.\n\n### detección automática de Windows\n\nEn Windows, el paso `autobuild` intenta detectar automáticamente un método de compilación adecuado para C/C++ mediante el siguiente enfoque:\n\n1. Se invoca `MSBuild.exe` en el archivo de solución (`.sln`) o proyecto (`.vcxproj`) más cercano a la raíz.\n   Si `autobuild` detecta varios archivos de solución o del proyecto en la misma profundidad (la más corta) con respecto al directorio de nivel superior, intentará compilarlos todos.\n2. Invoque un script similar a un script de compilación:*build.bat*, *build.cmd\\_\\_y build.exe* (en ese orden).\n\n### Detección automática de Linux y macOS\n\nEn Linux y macOS, el paso `autobuild` revisa los archivos presentes en el repositorio para determinar el sistema de compilación que usar:\n\n1. Busca un sistema de compilación en el directorio raíz.\n2. Si no se encuentra ninguno, busca un directorio único en los subdirectorios, el cual cuente con un sistema de compilación para C/C++.\n3. Ejecuta un comando adecuado para configurar el sistema.\n\n#### Requisitos del ejecutor para C/C++\n\nEn los ejecutores de Ubuntu Linux, `autobuild` puede intentar instalar automáticamente las dependencias necesarias para los pasos de configuración y compilación detectados. De forma predeterminada, este comportamiento está habilitado en los ejecutores hospedados por GitHub y está deshabilitado en ejecutores autohospedados. Puedes habilitar o deshabilitar esta característica explícitamente estableciendo `CODEQL_EXTRACTOR_CPP_AUTOINSTALL_DEPENDENCIES` en `true` o `false` en el entorno. Para obtener más información sobre cómo definir variables de entorno, consulte [Almacenamiento de información en variables](/es/actions/how-tos/write-workflows/choose-what-workflows-do/use-variables#defining-environment-variables-for-a-single-workflow).\n\nEn el caso de los ejecutores autohospedados, a menos que la instalación automática de dependencias esté habilitada, es probable que tenga que instalar el compilador `gcc` y es posible que proyectos específicos también necesiten acceso a los archivos ejecutables `clang` o `msvc`. También deberás instalar el sistema de compilación (por ejemplo `msbuild`, `make`, `cmake`, `bazel`) y utilidades (como `python`, `perl`, `lex` y `yacc`) de los que dependen los proyectos.\nSi habilita la instalación automática de dependencias, debe asegurarse de que el ejecutor usa Ubuntu y que se puede ejecutar `sudo apt-get` sin necesidad de una contraseña.\n\nLos ejecutores de Windows demandan que `powershell.exe` esté en `PATH`.\n\n## Compilación de C\\#\n\nCodeQLadmite los modos `none``autobuild` de compilación o `manual` para el código de C#.\n\nCuando se habilita la configuración predeterminada para un repositorio que contiene código de C#, el modo de compilación se establece en `none` automáticamente.\n\n### No hay ninguna compilación para C\\#\n\nCodeQL restaura las dependencias y genera algunos archivos de origen adicionales, para proporcionar resultados más precisos, antes de crear una base de datos a partir de todos los archivos de origen y dependencias.\n\nLas dependencias se restauran mediante varias heurísticas y estrategias. Los archivos siguientes son el origen principal de la información: `*.csproj`, `*.sln`, `nuget.config`, `packages.config`, `global.json` y `project.assets.json`.\nSi se define una fuente privada de NuGet para la organización, también se utiliza. Consulte [Configuración predeterminada del análisis de código para acceder a registros privados](/es/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries#code-scanning-default-setup-access-to-private-registries) y [Determinación de si la configuración predeterminada de análisis de código utiliza algún registro privado](/es/code-security/reference/code-scanning/code-scanning-logs#diagnostic-information-for-private-package-registries).\n\nLos siguientes archivos de origen generados son opcionales, pero aumentan significativamente la corrección de la CodeQL base de datos:\n\n* ```\n            Directivas de `global` generadas `using` para controlar la característica implícita `using` de MSbuild.\n  ```\n* Archivos de vista de ASP.NET Core, los archivos `.cshtml` se convierten en archivos `.cs`.\n\nLa información de los nombres de ensamblado de dependencias, los archivos de origen generados, las dependencias almacenadas en fuentes privadas y los archivos de origen del repositorio se compilan y se usan para crear una base de datos CodeQL.\n\n#### Precisión del análisis de no compilación para C\\#\n\nLa creación de una CodeQL base de datos sin compilar el código completo se basa en poder restaurar dependencias y poder compilar juntos los archivos de origen en el repositorio. Cuando hay problemas para restaurar dependencias o compilar el código fuente, esto puede afectar a la precisión de la CodeQL base de datos y code scanning los resultados del análisis.\n\nPara garantizar un análisis más preciso, siga estos pasos:\n\n* Proporcione acceso a la red pública de Internet o asegúrese de que el acceso a una fuente privada de NuGet está disponible, consulte [Examen de código de acceso predeterminado de configuración a registros](/es/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries#code-scanning-default-setup-access-to-private-registries) privados.\n* Compruebe si el repositorio requiere varias versiones de la misma dependencia de NuGet.\n  CodeQL solo puede usar una versión y normalmente elige la versión más reciente donde hay varias versiones. Este enfoque puede no funcionar para todos los repositorios.\n* Compruebe si se hace referencia a varias versiones de .NET, por ejemplo, `net48`, `net5.0` y `netstandard1.6`.\n  CodeQL solo puede usar una versión y esto puede afectar a la precisión.\n* Evite la colisión de nombres de clase; de lo contrario, esto puede provocar que falten destinos de llamada de método, lo que tiene un impacto en el análisis del flujo de datos.\n\n### Resumen de la compilación automática para C\\#\n\n| Tipo de sistema compatible | Nombre del sistema                              |\n| -------------------------- | ----------------------------------------------- |\n| Sistema operativo          | Windows, macOS y Linux                          |\n| Sistema de compilación     | .NET y MSbuild, así como scripts de compilación |\n\n#### detección automática de Windows\n\nEl proceso `autobuild` intenta detectar de forma automática un método de compilación adecuado para C# mediante el enfoque siguiente:\n\n1. Se invoca `dotnet build` en el archivo de solución (`.sln`) o proyecto (`.csproj`) más cercano a la raíz.\n2. Se invoca `MSBuild.exe` en el archivo de solución o proyecto más cercano a la raíz.\n   Si `autobuild` detecta varios archivos de solución o del proyecto en la misma profundidad (la más corta) con respecto al directorio de nivel superior, intentará compilarlos todos.\n3. Invoque un script similar a un script de compilación: `build.bat`, `build.cmd`, y `build.exe` (en ese orden).\n\n#### Requisitos de ejecutor para C# en Windows\n\nPara el desarrollo de aplicaciones .NET Core en ejecutores autohospedados, es necesario el SDK de .NET (para `dotnet`).\n\nPara el desarrollo de aplicaciones de .NET Framework, necesitará Microsoft Build Tools (para `msbuild`) y la CLI de NuGet (para `nuget`).\n\nLos ejecutores de Windows demandan que `powershell.exe` esté en `PATH`.\n\nSi planea crear CodeQL bases de datos mediante `build-mode: none`, también debe proporcionar acceso a la red pública de Internet, o debe asegurarse de que el acceso a una fuente privada de NuGet esté disponible.\n\n#### Detección automática de Linux y macOS\n\n1. Se invoca `dotnet build` en el archivo de solución (`.sln`) o proyecto (`.csproj`) más cercano a la raíz.\n2. Se invoca `MSbuild` en el archivo de solución o proyecto más cercano a la raíz.\n   Si `autobuild` detecta varios archivos de solución o del proyecto en la misma profundidad (la más corta) con respecto al directorio de nivel superior, intentará compilarlos todos.\n3. Invoque un script similar a un script de compilación: `build` y `build.sh` (en ese orden).\n\n#### Requisitos de ejecutor para C# en Linux y macOS\n\nPara el desarrollo de aplicaciones .NET Core en ejecutores autohospedados, es necesario el SDK de .NET (para `dotnet`).\n\nPara el desarrollo de aplicaciones de .NET Framework, necesitará Mono Runtime (para ejecutar `mono`, `msbuild` o `nuget`).\n\nSi planea crear CodeQL bases de datos mediante `build-mode: none`, también debe proporcionar acceso a la red pública de Internet, o debe asegurarse de que el acceso a una fuente privada de NuGet esté disponible.\n\n### Marcas del compilador de C# insertadas por CodeQL para compilaciones manuales\n\nEl trazador CodeQL permite extraer todos los lenguajes compilados al interceptar los procesos de compilación y transmitir información a los extractores de lenguaje pertinentes CodeQL. El rastreador inyecta determinadas marcas en la llamada del compilador de C# para asegurarse de que todos los componentes se compilan e incluyen en la base de datos CodeQL, lo que puede hacer que el código de C# se compile de una manera diferente a la que espera durante el análisis de CodeQL.\n\n#### `/p:MvcBuildViews=true`\n\nCuando esta opción se establece en `true`, las vistas de ASP.NET proyectos model-view-controller (MVC) se precompilan como parte del proceso de compilación, lo que puede ayudar a detectar errores y mejorar el rendimiento. El rastreador inyecta esta marca para garantizar que CodeQL encuentre y resalte los problemas de seguridad que pueden implicar el flujo de datos a través del código generado desde estas vistas. Para obtener más información, consulte [Adición de una vista a una aplicación MVC](https://learn.microsoft.com/en-us/aspnet/mvc/overview/getting-started/introduction/adding-a-view) en Microsoft Learn.\n\n#### `/p:UseSharedCompilation=false`\n\nEstablecer esta opción en `false` deshabilita el uso de la característica de compilación compartida, lo que puede dar lugar a tiempos de compilación más lentos. Cuando `/p:UseSharedCompilation=false`**no** se especifica, `msbuild` inicia un proceso de servidor del compilador y toda la compilación la llevará a cabo ese único proceso. Sin embargo, el rastreador de CodeQL depende de inspeccionar los argumentos de los procesos recién creados.\n\n#### `/p:EmitCompilerGeneratedFiles=true`\n\nAl establecer esta opción en `true`, se emitirán archivos generados por el compilador durante el proceso de compilación. Esta opción hace que el compilador genere archivos de código fuente adicionales que se usan para admitir características como la compatibilidad mejorada con expresiones regulares, la serialización y la generación de vistas de aplicaciones web. Normalmente el compilador no escribe estos artefactos generados en el disco, sino que establecer la opción en `true` fuerza la escritura de los archivos en el disco, por lo que el extractor puede procesar los archivos.\n\nPara algunos proyectos antiguos y proyectos que usan archivos `.sqlproj`, es posible que vea que la propiedad `/p:EmitCompilerGeneratedFiles=true` inyectada provoca problemas inesperados con `msbuild`. Para obtener más información sobre la solución de problemas, consulte [Errores inesperados del compilador de C#](/es/code-security/reference/code-scanning/troubleshoot-analysis-errors/c-sharp-compiler-unexpectedly-failing).\n\n## Compilación de Go\n\nCodeQL admite modos `autobuild` de compilación o `manual` para código de Go.\n\n### Resumen de compilación automática para Go\n\n| Tipo de sistema compatible | Nombre del sistema                                                                                    |\n| -------------------------- | ----------------------------------------------------------------------------------------------------- |\n| Sistema operativo          | Windows, macOS y Linux                                                                                |\n| Sistema de compilación     | Módulos de Go, `dep` y Glide, así como scripts de compilación, incluidos scripts de Makefiles y Ninja |\n\n### Detección automática para Go\n\nEl proceso `autobuild` intenta detectar automáticamente una forma adecuada de instalar las dependencias necesarias para un repositorio de Go antes de extraer todos los archivos `.go`:\n\n1. Invoca `make`, `ninja``./build` o `./build.sh` (en ese orden) hasta que uno de estos comandos se complete correctamente y otro comando `go list ./...` posterior también lo haga, lo que indica que las dependencias necesarias se han instalado.\n2. Si ninguno de esos comandos se completa correctamente, busca `go.mod`, `Gopkg.toml` o `glide.yaml` y ejecuta `go get` (a menos que se use el traslado al directorio \"vendor\"), `dep ensure -v` o `glide install` respectivamente para intentar instalar las dependencias.\n3. Por último, si no hay forma de encontrar los archivos de configuración de estos administradores de dependencias, reorganiza la estructura de directorios del repositorio adecuada para la adición a `GOPATH` y usa `go get` para instalar las dependencias. La estructura de directorios vuelve a su estado normal después de que se complete la extracción.\n4. Extrae todo el código de Go en el repositorio, similar a ejecutar `go build ./...`.\n\n> \\[!NOTE]\n> Si usa la configuración predeterminada, buscará un `go.mod` archivo para instalar automáticamente una versión compatible del idioma Go.\n\n### Opciones de extractor para Go\n\nDe manera predeterminada, no se analiza el código de prueba (código en archivos que terminan en `_test.go`). Puede invalidar esto con la opción `--extractor-option extract_tests=true` al usar CodeQL CLI, o estableciendo la variable de entorno `CODEQL_EXTRACTOR_GO_OPTION_EXTRACT_TESTS` a `true`.\n\nAdemás, `vendor` los directorios se excluyen del análisis de CodeQL Go de forma predeterminada. Para invalidar esto, pase la opción `--extractor-option extract_vendor_dirs=true` al usar CodeQL CLI o estableciendo la variable de entorno `CODEQL_EXTRACTOR_GO_OPTION_EXTRACT_VENDOR_DIRS` en `true`.\n\n## Construcción de Java y Kotlin\n\nCodeQL admite los siguientes modos de compilación.\n\n* Java: `none`, `autobuild` o `manual`\n* Kotlin: `autobuild` o `manual`\n\nCuando se activa por primera vez la configuración predeterminada para un repositorio, si solo se detecta código Java, el modo de compilación se establece en `none`. Si se detecta Kotlin o una combinación de Java y código de Kotlin, el modo de compilación se establece en `autobuild`.\n\nSi posteriormente agrega código kotlin a un repositorio que usa el `none` modo de compilación, CodeQL el análisis notifica un mensaje de advertencia que explica que No se admite Kotlin. Tendrá que deshabilitar la configuración predeterminada y volver a habilitarla. Al volver a habilitar la configuración predeterminada, el modo de compilación cambiará a `autobuild` para que se puedan analizar ambos lenguajes. Como alternativa, puede cambiar a una configuración avanzada. Para obtener más información, vea [Advertencia: se detectaron X archivos Kotlin en el proyecto que no se pudieron procesar sin una compilación](/es/code-security/reference/code-scanning/troubleshoot-analysis-errors/kotlin-detected-in-no-build).\n\n### No hay ninguna compilación para Java\n\nCodeQL intentará ejecutar Gradle o Maven para extraer información de dependencia precisa (pero no invocar una compilación), antes de crear una base de datos a partir de todos los archivos de Java presentes. Cada archivo de proyecto de Maven o Gradle raíz (un script de compilación sin ningún script de compilación presente en un directorio antecesor) se consulta para obtener información de dependencia y se prefieren versiones de dependencia más recientes si hay un conflicto. Para obtener información sobre los requisitos del ejecutor para ejecutar Maven o Gradle, consulte [Runner requirements for Java](#runner-requirements-for-java).\n\nSi se define un registro privado de Maven para la organización, también se utiliza, consulte [Configuración predeterminada del análisis de código para acceso a registros privados](/es/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries#code-scanning-default-setup-access-to-private-registries) y [Comprobar si la configuración predeterminada del análisis de código utilizó registros privados](/es/code-security/reference/code-scanning/code-scanning-logs#diagnostic-information-for-private-package-registries).\n\n#### Precisión del análisis sin compilación para Java\n\nLa creación de una base de datos CodeQL Java sin una compilación puede producir resultados menos precisos que usar `autobuild` o pasos de compilación manuales si:\n\n* Los scripts de compilación de Gradle o Maven no se pueden consultar para obtener información de dependencia y las estimaciones de dependencia (basadas en nombres de paquete Java) son inexactas.\n* Normalmente, el repositorio genera código durante el proceso de compilación. Esto se analizaría si la base de datos CodeQL se creó utilizando un modo diferente.\n\nPara garantizar un análisis más preciso, siga estos pasos:\n\n* Proporcione acceso a la red pública de Internet o asegúrese de que el acceso a un repositorio de artefactos privado está disponible, consulte [Examen de código de acceso predeterminado de configuración a registros](/es/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries#code-scanning-default-setup-access-to-private-registries) privados.\n* Compruebe si el repositorio requiere varias versiones de la misma dependencia.\n  CodeQL solo puede usar una versión y normalmente elige la versión más reciente donde hay varias versiones. Este enfoque puede no funcionar para todos los repositorios.\n* Compruebe si se requiere más de una versión de la API de JDK por diferentes archivos de Java de origen. Cuando se vean varias versiones, CodeQL usará la versión más alta requerida por cualquier script de compilación. Esto puede significar que algunos archivos que necesiten una versión inferior del JDK se analizarán parcialmente. Por ejemplo, si algunos archivos requieren JDK 8, pero se encuentra un requisito de JDK 17 en uno o varios scripts de compilación, CodeQL usará JDK 17. Se analizarán parcialmente todos los archivos que necesiten JDK 8 y no se hayan podido compilar mediante JDK 17.\n* Evite la colisión de nombres de clase (por ejemplo, varios archivos que definan `org.myproject.Test`); de lo contrario, esto puede provocar que falten destinos de llamada de método, lo que afecta al análisis del flujo de datos.\n\n### Resumen de la compilación automática para Java\n\n| Tipo de sistema compatible | Nombre del sistema                       |\n| -------------------------- | ---------------------------------------- |\n| Sistema operativo          | Windows, macOS y Linux (sin restricción) |\n| Sistema de compilación     | Gradle, Maven y Ant                      |\n\n### Detección automática de Java\n\nEl proceso `autobuild` intenta determinar el sistema de compilación para bases de código Java aplicando esta estrategia:\n\n1. Busca un archivo de compilación en el directorio raíz. Busca a Gradle en Maven y luego Ant compila los archivos.\n2. Ejecuta el primer archivo de compilación que encuentre. Si tanto los archivos de Gradle como los de Maven están presentes, se utiliza el archivo de Gradle.\n3. De lo contrario, busca los archivos de compilación en los subidrectorios directos del directorio raíz. Si solo un subdirectorio contiene archivos de compilación, ejecuta el primer archivo identificado en este subdirectorio (utilizando la misma preferencia que para 1). Si más de un subdirectorio contiene archivos de compilación, reporta un error.\n\n### Requisitos del ejecutor para Java\n\nSi usa ejecutores autohospedados, las versiones necesarias de Java deben estar presentes:\n\n* Si el ejecutor se usará para analizar repositorios que necesitan una sola versión de Java, debe instalarse la versión de JDK adecuada y debe estar presente en la variable PATH (de modo que se pueda encontrar `java` y `javac`).\n\n* Si el ejecutor se usará para analizar repositorios que necesitan varias versiones de Java, es necesario instalar las versiones de JDK adecuadas y se puede especificar a través del archivo `toolchains.xml`. Se trata de un archivo de configuración, que normalmente usa Apache Maven, que permite especificar la ubicación de las herramientas, la versión de las herramientas y cualquier configuración adicional necesaria para usarlas. Para obtener más información, consulte [Guía para usar cadenas de herramientas](https://maven.apache.org/guides/mini/guide-using-toolchains.html) en la documentación de Apache Maven.\n\nEs probable que los siguientes ejecutables sean necesarios para un intervalo de proyectos de Java y deben estar presentes en la variable PATH, pero no serán esenciales en todos los casos:\n\n* `mvn` (Apache Maven)\n* `gradle` (Gradle)\n* `ant` (Apache Ant)\n\nTambién deberás instalar el sistema de compilación (por ejemplo `make`, `cmake`, `bazel`) y utilidades (como `python`, `perl`, `lex` y `yacc`) de los que dependen los proyectos.\n\nLos ejecutores de Windows demandan que `powershell.exe` esté en `PATH`.\n\n## Creación de Rust\n\nCodeQL admite el modo `none` de compilación para el código de Rust.\n\n### No hay ninguna compilación para Rust\n\nCodeQL usa `rust-analyzer` para compilar y ejecutar scripts de compilación (`build.rs` archivos) y compilar código de macro, pero no invoca una compilación completa. Se crea una base de datos a partir de todos los archivos de Rust presentes. Un archivo `Cargo.toml` o `rust-project.json` debe estar presente.\n\n### Requisitos del ejecutor para Rust\n\nEl análisis de Rust requiere que `rustup` y `cargo` estén instalados.\n\n## Compilación de Swift\n\nCodeQL admite modos `autobuild` de compilación o `manual` para código Swift.\n\n### Resumen de la compilación automática para Swift\n\n| Tipo de sistema compatible | Nombre del sistema |\n| -------------------------- | ------------------ |\n| Sistema operativo          | macOS              |\n| Sistema de compilación     | Xcode              |\n\nEl proceso `autobuild` intenta compilar el destino más grande desde un proyecto o área de trabajo de Xcode.\n\nEl examen de código de Swift usa ejecutores de macOS de forma predeterminada.\nDado que los ejecutores de macOS hospedados por GitHub son más caros que los de Linux y Windows, se recomienda compilar solo el código que desea analizar. Para obtener más información sobre los precios de los ejecutores hospedados por GitHub, consulte [facturación de Acciones de GitHub](/es/billing/concepts/product-billing/github-actions).\n\nCode scanning El código Swift no es compatible con los agentes de ejecución que pertenecen a un Actions Runner Controller (ARC), ya que los agentes de ejecución de ARC solo utilizan Linux y Swift requiere agentes de ejecución de macOS. Sin embargo, puedes tener una combinación de ejecutores de ARC y ejecutores de macOS autohospedados. Para más información, consulta [Controlador del ejecutor de acciones](/es/actions/concepts/runners/actions-runner-controller).\n\n### Personalización de la compilación de Swift en Flujo de trabajo de análisis de CodeQL\n\n`xcodebuild` y `swift build` son compatibles con compilaciones de Swift. Se recomienda trabajar con una sola arquitectura durante la compilación. Por ejemplo, `ARCH=arm64` para `xcodebuild` o `--arch arm64` para `swift build`.\n\nPuedes pasar las opciones `archive` y `test` a `xcodebuild`. Sin embargo, se recomienda el comando estándar `xcodebuild` , ya que debe ser el más rápido y debe ser todo lo que CodeQL requiere para un examen correcto.\n\nPara el análisis de Swift, siempre debe instalar de manera explícita las dependencias gestionadas por CocoaPods o Carthage antes de generar la CodeQL base de datos."}