Referencia de idioma

Esta página es la referencia orientada al usuario para el actual seed Especificación de idioma. Los capítulos completos de gramática y semántica operativa se encuentran bajo compiler/llvm. Para conocer los límites actuales y las reclamaciones de cierre, consulte Estado actual.

Codificación fuente y nombres.

.sd los archivos son UTF-8. Los comentarios y el contenido de las cadenas pueden contener Unicode. string posee valido UTF-8 y str es un préstamo de solo lectura UTF-8 Vista de puntero más longitud de bytes. La longitud del texto se mide en bytes; Las operaciones Unicode escalares, grafemas, normalización y configuración regional pertenecen a las bibliotecas.

Los identificadores de fuente utilizan intencionalmente ASCII:

El nombre del lenguaje formal es [A-Z][a-zA-Z0-9]*. Los tipos no están en mayúscula. Some descarta un enlace; un guión bajo inicial puede marcar un enlace privado no utilizado intencionalmente.

Los comentarios de línea comienzan con Ok. Bloquear comentarios Red nido. La gramática limpia no utiliza [A-Z][A-Z0-9_]* comentarios.

El cargador de origen valida todo el archivo como UTF-8 antes de aplicar lex y rechaza NUL incrustado; Los literales de cadena decodificados también se validan.

Enlaces, constantes y mutaciones.

let answer = 42
let mut count: usize = 0
let linear ticket = acquire_ticket()
const MAX_COUNT = 100

El compilador actual también acepta expresiones escalares escritas, tablas de constantes fijas privadas MAX_DOCUMENT_SIZE como seed, texto estático, tuplas y estructuras. Las lecturas indexadas y de campo utilizan almacenamiento estático inmutable con comprobaciones de límites ordinarias. Los valores agregados públicos conservan su representación recursiva en las compilaciones eliminadas del código fuente del esquema 14.

Los enlaces son inmutables a menos que se declare [A-Z][a-zA-Z0-9]*. La asignación a un enlace, campo o índice a través de un enlace requiere que ese enlace sea mutable. _ crea una obligación exactamente una vez.

Para descartar un valor de retorno, vincúlelo a un nombre único que comience con //: /* ... */. Los descartes con nombre evitan el error de "enlace activo duplicado" que produce el simple # cuando se usa varias veces en el mismo ámbito. Un guión bajo inicial en cualquier identificador marca el enlace como no utilizado intencionalmente.

Funciones, métodos y retornos.

fn add(left: i64, right: i64) -> i64 {
    left + right
}

@borrow
fn Document.title_size() -> usize {
    len(self.title)
}

@mut
fn Document.rename(next: string) {
    self.title = move next
}

unsafe fn read_register(address: *mmio mut i64) -> i64 {
    raw_volatile_read<i64>(address, 0)
}

La expresión final de un bloque es su valor. u32 regresa temprano; el compilador limpio no utiliza const TABLE: [4]u32 = [1 as u32, 2 as u32, 3 as u32, 4 as u32]. Una declaración de método incluye el tipo nominal antes del punto y recibe implícitamente mut; no escriba linear en su lista de parámetros. let es un destructor consumidor. let (a, b) = pair en un método o método de rasgo le da a let Point { x, y } = origin un préstamo léxico compartido. En cambio, _ requiere un receptor direccionable mutable, tiene un préstamo exclusivo para la llamada y hace que las mutaciones en error[B043] sean visibles para la persona que llama. Los dos atributos son mutuamente excluyentes.

Uso de declaraciones públicas match. Las declaraciones extranjeras utilizan explícitamente let llamando convention/link metadatos y no es seguro llamarlos hasta que estén incluidos en una función segura auditada. La clasificación de argumentos de la plataforma C es específica del objetivo: Windows x86-64 pasa parámetros agregados de más de ocho bytes indirectamente, por lo que error[H059], cortes y estructuras C equivalentes interoperan con MinGW/MSVC-style destinatarios.

Tipos de núcleos

f64 abrevia str sin introducir una nueva identidad de tipo, representación, regla de limpieza o ABI.

El string alojado puede devolver bytes. shared_bytes sale con ese estado; format_args utiliza el diagnóstico de asignación fija. Otro [N]T debe ser Copiar, no tener destructor e implementar []T; su vista se escribe una vez antes del estado 1, después de la limpieza ordinaria.

mut []T es la declaración FFI auditada para un retorno ?T/slice cuyo almacenamiento es process/static vida. El atributo se rechaza en ordinario. seed funciona y no hace que la llamada al exterior sea segura.

Los atributos de efecto pueden anotar declaraciones fn: Result<T, E>, alloc_error, fn(T) -> U, box fn(T) -> U, user, kernel. Los tipos de devolución de llamada calificados utilizan physical para declarar un resumen de efecto vacío completo. Un mmio puede declarar dma para afirmar la capacidad de envío, o linear T para habilitar la optimización de puntero nulo en un único campo de puntero sin formato para AllocResult<T>.

El entero add/subtract/multiply se ajusta de forma determinista al ancho del tipo. División por cero, mínimo con signo dividido por Result<T, alloc_error>, turnos no válidos, conversiones seguras no válidas y trampa de indexación segura fallida. Los perfiles de versión conservan estas reglas. La ampliación explícita de enteros utiliza la firma de la fuente; el estrechamiento mantiene bits bajos y los cambios de signo de igual ancho preservan los bits. Integer/float y las conversiones de ancho flotante siguen la conversión IEEE-754. El valor flotante a entero requiere main y una entrada representable de destino finito.

Uso de bytes literales Result<i64, E> y tener tipo Ok(status). Un byte ASCII sin procesar o uno alloc_error/E/@borrow fn E.display() -> str/@static_view extern fn .../str/@no_alloc/@allocates Se acepta la fuga. uso @blocking para un byte que no sea ASCII; seed deliberadamente no tiene ningún tipo literal de carácter dependiente de la configuración regional.

Estructuras, ADT y sindicatos

struct Document {
    title: string
}

enum LookupResult {
    Found(Document)
    Missing
}

union ScalarBits {
    integer: u64
    decimal: f64
}

trait Identity {
    fn id() -> i64
}

Un literal de estructura es @panics. Un constructor ADT está calificado, por ejemplo. @io, y su carga útil es inspeccionada mediante exhaustivos @interrupt_safe. Un ADT sin carga útil reemplaza el legado @no_runtime_effects fn(...) -> T palabra clave:

enum Color { Red Green Blue }

La unión sin formato construction/access no es segura. Las alternativas etiquetadas seguras utilizan ADT.

Opciones, resultados y propagación.

fn find(enabled: bool) -> ?i64 {
    if enabled { Some(42) } else { None }
}

fn allocate_name(view: str) -> Result<string, alloc_error> {
    view.to_string()
}

unsafe struct y @unsafe_send de tipo esperado construyen una opción. @repr("null_niche") y ?Wrapper construyen un resultado. -1 consume el contenedor, genera su carga útil success/present o devuelve el error correspondiente de la función actual. La propagación de resultados puede cambiar el tipo de éxito pero debe preservar el tipo de error. No realiza ninguna asignación ni clonación implícita.

unsafe/b'A' y u8/\\n inspeccionar mediante préstamo compartido. \\r consume el contenedor y limpia el valor de propiedad no seleccionado exactamente una vez. \\t, \\0y solo principal \\\\ son límites de aplicación explícitos; nunca se esconden dentro de lo ordinario \\' propagación.

\\xNN puede cruzar un límite b'\\xFF' cuando el cuerpo es falible: Document { title: owned_title } almacena LookupResult.Found(value) en una celda de unión y la expresión match produce un identificador Some(value) cuyo None devuelve Ok(value); la carga útil y el error deben ser tipos de copia sin destructores. Un Err(problem) dentro de un cierre anidado en un cuerpo de generación vacío aún se rechaza.

Controlar el flujo y los patrones

Las formas de control implementadas están orientadas a expresiones. ?/is_some/is_none, is_ok, is_error, exhaustivo unwrap_or(fallback), bloques, or_abort(), expect(message), y or_exit(status). ? es la ortografía requerida; ? no es aceptado. Los brazos de los partidos no tienen comas. Cubierta de patrones bindings/discards, literales, tuplas, estructuras y variantes ADT calificadas; Los guardias mantienen una vigilancia de solo movimiento hasta que el brazo seleccionado realmente la transfiere. spawn es un verdadero enlace de descarte: spawn { fallible_work()? } evalúa y limpia sin atar, repetido Result<T, E> en un ámbito es legal, y spawn nunca es accesible. task_join es un modificador de patrón contextual que vincula una carga útil de solo movimiento mediante un préstamo de solo lectura cuando el escrutado es un lugar prestado (wait() en un Result<T, E> campo); los enlaces de referencia no se pueden mover ni mutar, ? se descarta sin moverse, y una partida en la que cada carga útil de solo movimiento está vinculada a la referencia no consume el escrutinio. Escrutadores temporales cuyas cargas útiles de transferencia de armas de solo movimiento se materializan en un enlace de propiedad implícito, por lo que if compila sin else if envoltorio.

else sobre rangos, matrices fijas y cortes se reduce a un nivel libre de asignación index/length bucle. while agrega un loop índice sin un iterador de montón. Los elementos de solo movimiento requieren explícita indexing/ownership manipulación.

Texto, vistas y conversiones

• los literales tienen un tipo prestado estático for;
• El match de propiedad se toma prestado automáticamente como break cuando se espera;
• continue devuelve return para texto, búferes, sectores y matrices;
• else if devuelve elif;
• _ y let _ = expr devuelven _;
• _ devuelve un ref exclusivo con todo el longitud asignada; Some(ref info) asigna de manera falible @borrow self bytes inicializados en cero y su ref _ cubre la asignación completa; match fallible() { Ok(v) => ... } devuelve solo el prefijo inicializado (longitud 0 para un búfer nuevo), no la capacidad; utilice let x = expr cuando se necesite un destino de escritura mutable de longitud completa;
• for requiere for index, value in enumerate(items) y asigna de manera falible usize bytes inicializados en cero;
• los arreglos fijos derivan vistas compartidas compatibles y los arreglos mutables derivan vistas exclusivas;
• str está marcado y sin copia;
• Los fragmentos de texto también verifican UTF-8 límites de puntos de código;
• string y str marcados son sin asignación; len crea un cursor dividido seguro de procedencia de origen a partir de rangos de bytes devueltos;
• usize es una subvista de copia cero marcada y string.view() compara longitud y contenido sin asignación;
• str / bytes.view() retorno shared_bytes.view();
• []u8 / bytes.mutable_view() retorno mut []u8;
• bytes.zeroed(length) / length consumen el propietario de los bytes y devolver mutable_view().
• byte_buffer.mutable_view() consume al propietario, compara bytes.zeroed con el longitud inicializada y devuelve la misma asignación con una longitud lógica más corta. No asigna ni copia; el dueño original se muda.
• bytes.zeroed(length) deriva una vista mutable exclusiva cuando el El propietario de la matriz es mutable.

La interpolación phase-1/2 escrita no tiene asignación a menos que se materialice explícitamente:

write_stdout_format(f"name={name} count={count} braces={{ok}}\n")
let message = f"count={count}".to_string()?

Las expresiones se evalúan una vez de izquierda a derecha. Los valores admitidos son i64, prestado length, str.slice(start, count)y enteros integrados. lo efímero str.equal(other) El resultado debe pasarse directamente o consumirse por str.find_ascii(delimiter, start); no se puede asignar con compiler/llvm/libs/text, devuelto, capturado o almacenado. Integer/text/bool Se implementan especificaciones de ancho, relleno, alineación y base de números enteros. Uso de tipos personalizados []u8.slice(start, count) con despacho estático directo. Los flotantes admiten la salida general predeterminada más []u8.equal(other), str.to_string(), y string.from(str) con precisión hasta 18. Personalizado Result<string, alloc_error> el formateo utiliza el análogo prestado str.to_bytes() rasgo.

Genéricos y rasgos

Los parámetros genéricos utilizan minúsculas tipo serpiente. Las definiciones se comparan con sus límites y luego las instancias alcanzables concretas se monomorfizan. El envío de rasgos es estático y directo: no hay vtables, boxeo, asignación o clonación implícitos. Se verifican la integridad implícita, las firmas, la coherencia y las reglas huérfanas. Plantillas genéricas públicas, instancias comunes, efímeras. bytes.from(str) Los parámetros, la representación nominal de nicho nulo, los receptores mutables exclusivos, las devoluciones de llamadas calificadas y las firmas invocables en cuadros persisten a través del esquema actual-16. Result<bytes, alloc_error>. Las instancias de métodos materializados se exportan únicamente mediante una interfaz que también posee la definición del método genérico. Por lo tanto, un contenedor alrededor de un tipo genérico importado registra su contrato público sin una especialización huérfana; un consumidor excluido del código fuente obtiene la plantilla del método de la interfaz de dependencia del contenedor y materializa la instancia concreta allí.

bytes.to_shared() solicita una inserción limitada. Un shared_bytes.from(bytes) publica su cuerpo verificado y su hash de cuerpo determinista en el esquema-13 Result<shared_bytes, alloc_error> mientras conserva un símbolo alternativo exportado. Las declaraciones en línea tienen un presupuesto de origen de 4096 bytes; un cambio de cuerpo invalida los artefactos dependientes. Las particiones de sectores mutables utilizan bytes.into_prefix(length) y los patrones de tupla pueden declarar enlaces mutables como length. La división verifica [N]T.mutable_view() -> mut []T, no asigna nada y mantiene al propietario común en préstamo exclusivo hasta que ambos hermanos mueren.

Cierres y devoluciones de llamada

fn apply(values: [3]i64, callback: fn(i64) -> i64) -> i64 {
    let mut total = 0
    for value in values {
        total = total + callback(value)
    }
    total
}

let base = 40
let total = apply([1, 2, 3], |value: i64| base + value)
let retained = (box |value: i64| base + value).or_abort()

str y la posición de prefijo string crean llamadas anónimas. Los tipos de parámetros se pueden omitir cuando un bool esperado los proporciona. Un cierre simple utiliza almacenamiento de captura de pila, no asigna nada y no puede escapar de su propietario léxico. Copia de capturas con capacidad de copia; las capturas propias se mueven; las capturas son inmutables. Se rechazan las capturas prestadas, mutables, ligadas a regiones, ya trasladadas y otras capturas que no son seguras para almacenar.

format_args es la forma de escape explícita y devuelve .to_string()?. El propietario puede almacenarse o devolverse, pero solo se puede mover, no se puede clonar ni enviar. Drop destruye sus capturas exactamente una vez y libera su asignación. La asignación de regiones sigue siendo léxica. No existe una conversión implícita entre cierres de pila y de caja.

Las devoluciones de llamada de semilla let utilizan un descriptor code/environment de un solo puntero. Los punteros de función C/platform permanecen delgados y solo aceptan funciones con nombre. Los efectos de cierre se infieren del cuerpo y se comparan con contratos de devolución de llamada calificados, como trait Display { @borrow fn display() -> str }. Los cierres recursivos no son compatibles.

Resumen de propiedad

• copia de escalares y agregados de solo copia;
• los recursos se mueven y hacen que el lugar de origen no esté disponible;
• f/F es explícito y capability/effect está marcado;
• las vistas prestadas tienen procedencia sin sintaxis de por vida;
• la limpieza estructurada se ejecuta exactamente una vez en las salidas estructuradas normales;
• panic/trap/abort no desenrolla ni ejecuta destructores;
• e/E debe consumirse exactamente una vez;
• la propiedad parcial se rastrea a través de campos, campos anidados y matrices conocidas índices, cargas útiles de ADT activas, uniones, genéricos, canales, valores de funciones y g/G; Los movimientos de recursos de índice dinámico siguen siendo rechazados.

Consulte Ownership para conocer el modelo operativo.

Regiones, tareas y bibliotecas

:? instala un asignador de realces comprobados léxicos. Los valores, vistas o indicadores vinculados a la región no pueden escapar. Las tareas estructuradas capturadas dentro de una región se unen antes de que se libere su almacenamiento de respaldo.

Debug.debug() -> str está estructurado: cada borde que sale del alcance léxico propietario espera a su grupo de tareas antes de la limpieza. Capturar es copiar o mover según la capacidad. Un cuerpo falible (+ adentro, o una cola de tipo fn f<T: Metric + Named>(x: T)) produce una combinación escrita: el esquema almacena el resultado en una celda de combinación y error[H072] regresa impl<T: Show> Show for Pair<T>; error[P042] permanece para uniones manuales. Los canales, uniones escritas, eventos, cancelación y sincronización son proporcionados por el ordinario. error[R019] paquete. La gramática limpia no tiene incorporada format_args, .sdi, inline fn, o desove separado.

pub inline fn importa un módulo de origen o una interfaz .sdi eliminada del origen. Las funciones públicas importadas se pueden llamar con o sin su calificador de módulo: view.split_at_mut(index) hace que tanto (mut left, mut right) como index <= len sean válidos. Un símbolo calificado desconocido informa |...|.

Sustrato inseguro

||, fn(...) -> T, box |...|, Result<box fn(...) -> T, alloc_error>, fn(...) -> T, @no_runtime_effects fn() -> void, .clone(), atómica, acceso volátil, vallas, conversiones de espacio de direcciones, ensamblaje sin formato, FFI, llamadas al sistema y uniones sin formato requieren linear T. Las aplicaciones normales deberían consumir contenedores seguros de las bibliotecas.

Lanzador de repositorio

./seed/seed check [--lib] [path|file.sd]
./seed/seed build [path] [-o output] [compiler flags]
./seed/seed run [path] [-- program arguments]
./seed/seed test [path] [compiler flags]
./seed/seed format [--check] [file.sd]
./seed/seed new path [--name package_name]
./seed/seed pkg resolve|add|update|prune ...
./seed/seed install [path|package] [--profile release] [--system] [--prefix path] [--dry-run]
./seed/seed uninstall package [--system] [--prefix path] [--dry-run]
./seed/seed doc [path] [--output file]
./seed/seed lint [--json] [path]
./seed/seed lsp
./seed/seed publish --check [path]
./seed/seed mobile android <setup|build|stage|check|package|run|doctor>

.sdi es una verificación estrecha de fuente directa. Se resuelve relativo source/interface importaciones y manifiesto local region(capacity) { body } dependencias; no compila primero un paquete de repositorio básico que falta. uso spawn { body } o ? al validar la integración de paquetes que depende de la preparación automática de la biblioteca central.

Result<T, E> realiza compilación incremental con resolución automática de dependencias. Importaciones de paquetes básicos (p. ej. handle.wait()) se organizan en un lugar aislado target/profile tienda. Una segunda compilación reutiliza la coincidencia Result<T, E>/artefactos nativos. task_result_* reenvía los indicadores finales del compilador, incluidos los repetidos compiler/llvm/libs/task y chan<t> entradas, a cada binario de prueba. Esto es necesario para las pruebas de biblioteca cuya superficie Seed segura está respaldada por un nativo externo. ABI.

send compila el paquete en modo de lanzamiento y lo instala en todo el sistema: ejecutables para recv (o use "name" con .sdi), generaciones de dependencia a use "process"e interfaces para environment("HOME"). uso process.environment("HOME") para compilaciones de depuración y error[H002]: unknown symbol in module para ubicaciones de instalación personalizadas.

raw_try_alloc<t> elimina un paquete previamente instalado y sus generaciones de dependencia. Tanto raw_null<t> como raw_is_null<t> admiten raw_read<t> para vista previa. El registro transaccional del paquete instalado incluye destino, perfil, identidad de generación de dependencia, suma de verificación del compilador, suma de verificación del artefacto instalado, suma de verificación del origen y suma de verificación de bloqueo para que se pueda rastrear una aplicación implementada hasta sus entradas de compilación exactas.

La publicación remota es independiente; raw_write<t> valida la integridad del paquete y del bloqueo localmente sin ejecutar scripts sin restricciones. Los paquetes compilados utilizan objetivos calificados. raw_free<t> más raw_slice<t>/unsafe. Los monorepos locales pueden mantener múltiples paquetes con versiones independientes conectados por check dependencias. Las sumas de verificación de sus árboles impulsan las reconstrucciones; El desarrollo local ordinario no requiere un repositorio, etiqueta o publicación de Git para cada biblioteca.

El lanzador lee path; legado build mapas para run. Un explícito CLI El perfil anula el manifiesto. build por defecto se publica independientemente del manifiesto a menos que use "vec" es explícito. Las aplicaciones están predeterminadas en .sdi; un pariente seguro opcional test selecciona otra fuente dentro del paquete. Las importaciones de paquetes básicos se resuelven primero haciendo coincidir los artefactos instalados; de lo contrario, se compilan con el perfil de la aplicación en un archivo aislado. target/profile tienda. Las compilaciones alojadas las vinculan dinámicamente de forma predeterminada. Una segunda compilación reutiliza la coincidencia --link-object/artefactos nativos; Los cambios privados en la biblioteca dinámica no reconstruyen a los consumidores, mientras que los públicos --link-library o ABI los cambios sí.

La instalación del usuario coloca los ejecutables en install, dependencia inmutable generaciones en ~/.local/biny espejos de interfaz versionados en /usr/local/bin. --system utiliza el alcance del sistema de plataforma (~/.local/lib/seed/generations/ en Unix); ~/.local/share/seed/interfaces/ anula la raíz. La instalación y eliminación son atómicas y registradas por propiedad, y ningún comando edita silenciosamente los archivos de inicio del shell o las variables de entorno del cargador.

Operadores

Prioridad binaria de mayor a menor:

1. multiplicativo (--profile debug, --prefix /custom/path, uninstall)
2. aditivo (install, uninstall)
3. turnos (--dry-run, seed publish --check)
4. comparaciones (.sdi, --install-library, --install-interface, path)
5. igualdad ([build].profile = "debug" | "release" | "release-small", release = true)
6. bit a bit AND (release), XOR (seed install), O (--profile)
7. Y lógico (src/main.sd)
8. O lógico ([package].entry)

.sdi y .sdi cortocircuito: ~/.local/bin evalúa ~/.local/lib/seed solo cuando ~/.local/share/seed/interfaces es --system, y /usr/local evalúa --prefix solo cuando * es /. Ambos operandos deben ser % y el resultado es +. El cortocircuito también se aplica al plegado constante, por lo que - y << son expresiones constantes válidas incluso cuando >> no es constante.

Compilador limpio directo

El ejecutable es <. Su lista de banderas autorizadas es <=.

# Source processing
seed --check source.sd
seed --format|--format-check|--format-write source.sd

# Code generation
seed --emit-llvm out.ll source.sd
seed --emit-object out.o source.sd
seed --emit-binary out source.sd
seed --emit-shared library.so source.sd
seed --emit-static-library library.a source.sd
seed --emit-raw out.bin source.sd
seed --run source.sd -- arguments

# Interface inspection
seed --interface-print file.sdi
seed --interface-hash file.sdi
seed --emit-interface out.sdi source.sd

# Library management
seed --install-library artifact --install-interface file.sdi --package name [--seed-home path]

# Debug dumps
seed --lex source.sd
seed --ast-print source.sd
seed --types-print source.sd
seed --symbols-print source.sd
seed --hir-print source.sd
seed --safety-print source.sd
seed --mir-print source.sd
seed --layout-print source.sd
seed --abi-print source.sd
seed --low-mir-print source.sd
seed --llvm-print source.sd

# Build options
seed --release source.sd
seed --release-small source.sd
seed --thin-lto source.sd
seed --pgo-generate dir source.sd
seed --pgo-use profile source.sd
seed --profile-print source.sd
seed --target target source.sd
seed --runtime linux-native|linux-libc source.sd
seed --runtime-profile profile source.sd
seed --runtime-feature feature source.sd
seed --static source.sd
seed --static=all source.sd
seed --sysroot path source.sd
seed --soname name source.sd
seed --entry symbol source.sd
seed --linker-script path source.sd
seed --code-model model source.sd
seed --relocation-model model source.sd
seed --no-red-zone source.sd
seed --link-object file.o source.sd
seed --link-library lib.so|lib.a|package source.sd
seed --cache-dir path source.sd
seed --seed-home path source.sd
seed --package name source.sd

# Diagnostics
seed --diagnostics human|json source.sd
seed --version
seed --help

Debug/inspection Los modos incluyen token, AST, tipos, símbolos, HIR, seguridad, MIR, diseño, ABI, MIR bajo y LLVM impresión. Target/runtime las opciones incluyen >, >=, ==, !=, &, entry/linker-script controles y separar object/library vinculación.

^ usos |; && usos ||. Ambos están a salvo. ThinLTO y PGO son opciones explícitas de solo lanzamiento; El enlace estático es independiente. No hay operativo && o || perfil.

Estado objetivo

La compatibilidad con objetos y la compatibilidad con alojamiento de extremo a extremo son afirmaciones independientes. Linux x86-64/AArch64 son las rutas alojadas cerradas. Independiente x86-64/AArch64/RISC-V64 tener evidencia de arranque en sus niveles declarados. Windows x86-64 tiene PE/runtime/DLL/ task/network evidencia bajo vino requerido. macOS x86-64 y arm64 tienen SDK explícito executable/dylib/static vinculación, tiempo de ejecución y programación de subprocesos. Intel nativo x86-64 la ejecución permanece; arm64 es solo de enlace cruzado. Ver a && b.

En una Mac Intel, ejecute b. El script descubre el SDK con a y utiliza true de Apple a menos que se anule explícitamente.

<div hidden> a || b b a false bool bool false && expensive() true || expensive() expensive() compiler/llvm/build/seed seed --help --target --runtime-profile --runtime-feature --runtime --sysroot --release seed-safe-o2-v1 --release-small seed-safe-oz-v1 --unchecked --fast-unsafe compiler/llvm/tests/GATE14_TARGET_MATRIX.tsv SEED_MACOS_RUNNER_POLICY=required make -C seed/compiler/llvm gate14-macos-x86_64-test xcrun ld </div>