Référence linguistique

<!-- verified-against: seed-llvm; examples: docs-examples-test -->

Cette page est la référence orientée utilisateur pour le courant seed Spécification linguistique. Les chapitres complets sur la grammaire et la sémantique opérationnelle se trouvent sous compiler/llvm. Pour connaître les limites actuelles et les demandes de fermeture, voir État actuel.

Codage source et noms

.sd les fichiers sont UTF-8. Les commentaires et le contenu des chaînes peuvent contenir du Unicode. string possède valide UTF-8 et str est un fichier emprunté en lecture seule UTF-8 vue pointeur plus longueur d'octet. La longueur du texte est mesurée en octets ; Les opérations scalaires, graphèmes, de normalisation et de paramètres régionaux Unicode appartiennent aux bibliothèques.

Les identifiants de source utilisent intentionnellement l'ASCII :

Genre Règle Exemple
variable, fonction, champ, module [a-z][a-z0-9_]* my_document
struct, enum, union, trait, paramètre générique [A-Z][a-zA-Z0-9]* Document, T
variante d'énumération [A-Z][a-zA-Z0-9]* Some, Ok, Red
constante [A-Z][A-Z0-9_]* MAX_DOCUMENT_SIZE

Le nom du langage formel est seed, toujours en minuscules. Les noms de valeur utilisent la casse du serpent minuscule ; les types nominaux et les variantes d'énumération utilisent UpperCamelCase et correspondent à [A-Z][a-zA-Z0-9]*. Les constantes utilisent la casse supérieure du serpent. _ est la liaison de suppression ; un trait de soulignement de début peut marquer une liaison privée intentionnellement inutilisée.

Les commentaires de ligne commencent par //. Bloquer les commentaires /* ... */ nid. La grammaire propre n'utilise pas # commentaires.

Le chargeur de source valide l'intégralité du fichier comme UTF-8 avant le lexing et rejette les NUL intégrés ; les littéraux de chaîne décodés sont également validés.

Liaisons, constantes et mutation

const MAX_COUNT: usize = 100

fn release(ticket: i64) {}

fn main() -> i64 {
    let answer = 42
    let mut count: usize = 0
    count += 1
    let linear ticket = 7
    release(ticket)
    if count < MAX_COUNT { answer } else { 0 }
}

Le compilateur actuel accepte également les expressions scalaires typées, les tables de constantes fixes privées u32 telles que const TABLE: [4]u32 = [1 as u32, 2 as u32, 3 as u32, 4 as u32], le texte statique, les tuples et les structures. Les lectures indexées et de champ utilisent un stockage statique immuable avec des vérifications de limites ordinaires. Les valeurs agrégées publiques conservent leur représentation récursive dans les versions à source schéma-14.

L'annotation de type constante est facultative et correspond à const_decl = "const", constant_ident, [ ":", type ], "=", expression: une constante non annotée déduit son type de son initialiseur (const MAX_ITEMS = 64 est i64, const OFFSETS = [1, 4, 9] est [3]i64), y compris le texte statique, les tuples, les structures et les constantes nommées. Un initialiseur dont le type ne peut pas être déduit nécessite une annotation explicite et est rejeté avec R037 à la déclaration.

Les liaisons sont immuables sauf si elles sont déclarées mut. L'affectation à une liaison, un champ ou un index via une liaison nécessite que cette liaison soit modifiable. linear crée une obligation unique.

let accepte également les modèles irréfutables : déstructuration de tuples (let (a, b) = pair), déstructuration de structures (let Point { x, y } = origin), caractères génériques (_) et imbrication. Chaque feuille nommée devient une liaison ordinaire déplacée hors du composant de l'initialiseur, de sorte que la propriété, la linéarité et le nettoyage suivent les composants indépendamment. Les modèles réfutables (variantes, littéraux) sont rejetés (error[B043]) ; utilisez match pour ceux-là.

Un let L'annotation accepte tout type valide dans une position de paramètre (tableaux, tranches, tuples, pointeurs, types de fonctions, génériques, noms qualifiés) et est vérifiée par rapport au type d'initialiseur déduit (error[H059] en cas de non-concordance). Requêtes de mise en page au moment de la compilation size_of(type) et align_of(type) sont évalués par rapport à la cible active et sont valides dans des contextes constants - initialiseurs const et longueurs de tableau telles que [size_of(i64)]u8; ailleurs, ils sont rejetés avec error[H129].

Pour supprimer une valeur de retour, utilisez let _ = expression qui évalue et nettoie la valeur sans créer de liaison ; La répétition de _ dans une seule portée est légale et _ n'est jamais accessible. let _unused = expression avec un trait de soulignement de début marque également une liaison intentionnellement inutilisée mais crée une liaison nommée.

Fonctions, méthodes et retours

struct Document {
    title: string
}

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)
}

L'expression finale d'un bloc est sa valeur. return expression revient tôt; le compilateur propre n'utilise pas ret. Une déclaration de méthode inclut le type nominal avant le point et reçoit des self; n'écris pas self dans sa liste de paramètres. fn TypeName.drop() est un destructeur dévorant. @borrow sur une méthode ou un trait, la méthode donne self un emprunt lexical partagé. @mut à la place, nécessite un récepteur adressable mutable, détient un prêt exclusif pour l'appel et effectue des mutations vers self visible pour l'appelant. Les deux attributs s’excluent mutuellement.

str les retours sont basés sur la provenance et ne se limitent pas aux méthodes : une fonction gratuite peut renvoyer une vue statique ou dérivée d'une entrée. Une vue dérivée d'une propriété locale string/bytes la valeur ne peut pas s'échapper (V001); renvoyer le propriétaire lorsque la propriété doit quitter la fonction. Il n'y a pas de syntaxe à vie.

Utilisation des déclarations publiques pub. Les déclarations étrangères utilisent des extern appeler convention/link métadonnées et il est dangereux de les appeler jusqu'à ce qu'ils soient encapsulés par une fonction sûre auditée. La classification des arguments Platform-C est spécifique à la cible : Windows x86-64 transmet indirectement des paramètres agrégés de plus de huit octets, donc str, les tranches et les structures C équivalentes interagissent avec MinGW/MSVC-style appelés.

Types de base

Catégorie Espèces
contrôle void, never, bool
entier i8, i16, i32, i64, u8, u16, u32, u64, isize, usize; byte pseudonymes u8
flotter f32, f64
text/buffer str, string, bytes, shared_bytes
formatage format_args (éphémère)
aggregate/view [N]T, []T, mut []T, tuples, nominal structs/enums/unions
échec ?T, Result<T, E>, alloc_error
appelable non-propriétaire fn(T) -> U, échappant à box fn(T) -> U
bas niveau pointeurs bruts plus user, kernel, physical, mmio, et dma espaces d'adressage
exactement une fois linear T

AllocResult<T> abrège Result<T, alloc_error> sans introduire de nouvelle identité de type, représentation, règle de nettoyage ou ABI.

Hébergé main peut revenir Result<i64, E>. Ok(status) sort avec ce statut ; alloc_error utilise le diagnostic d'allocation fixe. Un autre E doit être une copie, ne pas avoir de destructeur et implémenter @borrow fn E.display() -> str; sa vue est écrite une fois avant le statut 1, après un nettoyage ordinaire.

@static_view extern fn ... est la déclaration FFI auditée pour un produit retourné str/slice dont le stockage est process/static vie. L'attribut est rejeté de manière ordinaire seed fonctionne et ne sécurise pas l'appel étranger.

Les attributs d'effet peuvent annoter les déclarations fn : @no_alloc, @allocates, @blocking, @panics, @io, @interrupt_safe. Les types de rappel qualifiés utilisent @no_runtime_effects fn(...) -> T pour déclarer un résumé complet des effets vides. Un unsafe struct peut déclarer @unsafe_send pour affirmer la capacité d'envoi, ou @repr("null_niche") pour activer l'optimisation du pointeur nul sur un seul champ de pointeur brut pour ?Wrapper.

L’entier add/subtract/multiply s’enroule de manière déterministe à la largeur du type. Division par zéro, minimum signé divisé par -1, décalages non valides, conversions sécurisées non valides et piège d'indexation sécurisée ayant échoué. Les profils de version conservent ces règles. L'élargissement explicite des entiers utilise la signature de la source ; le rétrécissement conserve les bits faibles et les changements de signature de largeur égale préservent les bits. Integer/float et les conversions en largeur flottante suivent la conversion IEEE-754. La conversion en nombre entier nécessite unsafe et une entrée représentable par destination finie.

Les littéraux d'octets utilisent b'A' et sont de type u8. Un octet ASCII brut ou un échappement \\n/\\r/\\t/\\0/\\\\/\\'/\\xNN est accepté. Utilisez b'\\xFF' pour un octet non-ASCII ; seed n'a délibérément aucun type littéral de caractères dépendant des paramètres régionaux.

Les littéraux entiers sont décimaux, 0x hexadécimaux ou 0b binaires, avec _ comme séparateur de chiffres facultatif (20_000_000, 0xFF, 0b1010). Chaque forme acceptée atteint codegen partout où un littéral est autorisé, y compris les littéraux de tableau et les littéraux de répétition.

Un littéral de tableau répété remplit un tableau fixe à partir d'un littéral : let slots: [4]usize = [0; 4], [255; 3], [[0; 2]; 3]. Le type d'élément provient de l'annotation ou du type attendu du tableau, donc aucun cast n'est nécessaire. La valeur doit être un littéral (ou une conversion de celui-ci, ou un tableau de ceux-ci) — une valeur de lieu ou d'appel est rejetée comme B048 plutôt que évaluée silencieusement une fois par élément — et le décompte doit être un littéral entier positif (B049) d'au plus 65536 (B050), car les éléments sont matérialisés individuellement ; les remplissages plus grands appartiennent à un tampon de tas ou à une boucle explicite.

Structures, ADT et syndicats

struct Document {
    title: string
}

enum LookupResult {
    Found(Document)
    Missing
}

union ScalarBits {
    integer: u64
    decimal: f64
}

trait Identity {
    fn id() -> i64
}

Un littéral de structure est Document { title: owned_title }. An ADT constructor is qualified, for example LookupResult.Found(value), et sa charge utile est inspectée de manière exhaustive match. Une énumération sans charge utile :

enum Color { Red Green Blue }

L’union brute construction/access n’est pas sûre. Les alternatives sécurisées et étiquetées utilisent des ADT.

Options, résultats et propagation

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

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

Some(value) et None de type attendu construisent une option. Ok(value) et Err(problem) construisent un résultat. ? consomme le conteneur, génère sa charge utile success/present ou renvoie l'échec correspondant de la fonction actuelle. La propagation des résultats peut modifier le type de réussite mais doit conserver le type d'erreur. Il n’effectue aucune allocation ou clonage implicite.

is_some/is_none et is_ok/is_error inspecter par emprunt partagé. unwrap_or(fallback) consomme le conteneur et nettoie la valeur possédée non sélectionnée exactement une fois. or_abort(), expect(message), et principal uniquement or_exit(status) sont des limites d'application explicites ; ils ne se cachent jamais dans l'ordinaire ? propagation.

? peut traverser un spawn limite quand le corps est faillible : spawn { fallible_work()? } magasins Result<T, E> dans une cellule de jointure et le spawn l'expression donne un task_join poignée dont wait() retours Result<T, E>; la charge utile et l'erreur doivent être des types de copie sans destructeurs. Un ? à l'intérieur d'une fermeture imbriquée dans un corps de spawn vide est toujours rejetée.

Contrôler le flux et les modèles

Les formulaires de contrôle implémentés sont orientés expression if/else if/else, while, loop, for, exhaustif match, blocs, break, continue, et return. else if est l'orthographe requise ; elif n’est pas accepté. Les bras de correspondance n'ont pas besoin de virgules sauf si la limite est ambiguë : un bras dont le corps se termine par une expression suivie d'un (/[ le modèle nécessite la virgule (B044). Couverture de motifs bindings/discards, littéraux, tuples, structures et variantes ADT qualifiées ; les gardes conservent un scrutateur de mouvement uniquement jusqu'à ce que le bras sélectionné le transfère réellement. _ est une véritable liaison de suppression : let _ = expr évalue et nettoie sans liaison, répété _ dans un domaine est légal, et _ n'est jamais accessible. ref est un modificateur de modèle contextuel qui lie une charge utile de déplacement uniquement par un emprunt en lecture seule lorsque la personne interrogée est un lieu emprunté (Some(ref info) sur un @borrow self champ); les liaisons ref ne peuvent pas être déplacées ou mutées, ref _ se défausse sans bouger, et un match dont chaque charge utile de mouvement uniquement est liée à la référence ne consomme pas le scrutateur. Les scrutateurs temporaires dont les charges utiles de transfert d'armes uniquement sont matérialisées dans une liaison implicite, donc match fallible() { Ok(v) => ... } compile sans let x = expr emballage.

if let et while let les formulaires concis sont-ils terminés match: if let Some(x) = found { ... } else { ... } et while let Some(x) = next { ... }. Tous deux se lancent dans un match à deux bras, si contraignant, move/borrow le comportement et le nettoyage sont exactement les règles du match. if let Some(...) nomme son complément None; tout autre modèle de variante conserve un bras générique, et H032 rejette que lorsque le candidat transporte une charge utile de déplacement uniquement - écrivez le match des armes là-bas. Un modèle irréfutable (while let name = value) est rejeté car H029.

for sur les plages, les tableaux fixes et les tranches diminue à un niveau sans allocation index/length boucle. for index, value in enumerate(items) ajoute un usize index sans itérateur de tas. Les éléments de déplacement uniquement nécessitent des indexing/ownership manipulation.

Texte, vues et conversions

L'interpolation typée phase-1/2 est sans allocation, sauf si elle est explicitement matérialisée :

use "file"

fn main() -> Result<i64, alloc_error> {
    let name = "widget"
    let count = 3
    write_stdout_format(f"name={name} count={count} braces={{ok}}\n")
    let message = f"count={count}".to_string()?
    Ok(len(message) as i64)
}

Les expressions sont évaluées une fois de gauche à droite. Les valeurs prises en charge sont str, emprunté string, bool, et les entiers intégrés - en tant qu'expressions arbitraires, pas seulement des noms : les appels, les opérateurs et l'imbrication fonctionnent tous (f"{a + b}", f"{p.distance()}"). L'éphémère format_args le résultat doit être transmis directement ou consommé par .to_string()?; il ne peut pas être attribué avec let, restitués, capturés ou stockés. Integer/text/bool Les spécifications de largeur, de remplissage, d’alignement et de base entière sont implémentées. Utilisation de types personnalisés trait Display { @borrow fn display() -> str } avec expédition statique directe. Les flotteurs prennent en charge la sortie générale par défaut plus f/F, e/E, et g/G avec une précision jusqu'à 18. Personnalisé :? le formatage utilise l'analogue emprunté Debug.debug() -> str trait.

Génériques et traits

Les paramètres génériques utilisent UpperCamelCase. Les définitions sont vérifiées par rapport à leurs limites, puis les instances concrètes accessibles sont monomorphisées. Un paramètre peut déclarer plusieurs limites de trait avec + (fn f<T: Metric + Named>(x: T)); chaque limite doit nommer un trait déclaré, l'argument doit tous les implémenter (error[H072] par limite manquante), et les méthodes de trait se résolvent à travers n'importe quelle limite. Les blocs impl peuvent eux-mêmes être génériques : impl<T: Show> Show for Pair<T> implémente le trait pour chaque instance dont les arguments satisfont aux limites de l'impl ; les arguments cibles doivent être exactement les paramètres de l'impl dans l'ordre (error[P042]), et un impl générique chevauchant un autre impl du même trait pour le même type est rejeté (error[R019]). La répartition des traits est statique et directe : il n'y a pas de tables virtuelles, de boxe, d'allocation ou de clone implicites. L'exhaustivité de l'implément, les signatures, la cohérence et les règles orphelines sont vérifiées. Modèles génériques publics, instances courantes, éphémères format_args les paramètres, la représentation nominale de niche nulle, les récepteurs mutables exclusifs, les rappels qualifiés et les signatures appelables en boîte persistent dans le schéma-17 actuel .sdi. Les instances de méthode matérialisées sont exportées uniquement par une interface qui possède également la définition de méthode générique. Un wrapper autour d'un type générique importé enregistre donc son contrat public sans spécialisation orpheline ; un consommateur élidé par la source obtient le modèle de méthode à partir de l'interface de dépendance du wrapper et y matérialise l'instance concrète.

inline fn demande une inlining limitée. Un pub inline fn publie son corps vérifié et son hachage de corps déterministe dans le schéma 13 .sdi tout en conservant un symbole de secours exporté. Les déclarations en ligne ont un budget source de 4 096 octets ; un changement de corps invalide les artefacts dépendants. Les partitions de tranches mutables utilisent view.split_at_mut(index) et les modèles de tuples peuvent déclarer des liaisons mutables comme (mut left, mut right). Le partage vérifie index <= len, n'attribue rien et maintient le propriétaire commun exclusivement prêté jusqu'au décès des deux frères et sœurs.

Fermetures et rappels

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

fn main() -> i64 {
    let base = 40
    let total = apply([1, 2, 3], |value: i64| base + value)
    let retained = (box |value: i64| base + value).or_abort()
    total + retained(1)
}

|...| et la position de préfixe || créent des appels anonymes. Les types de paramètres peuvent être omis lorsqu’un fn(...) -> T attendu les fournit. Une fermeture simple utilise le stockage de capture de pile, n'alloue rien et ne peut pas échapper à son propriétaire lexical. Copie de capture capable de copier ; les captures possédées bougent ; les captures sont immuables. Les captures empruntées, mutables, liées à une région, déjà déplacées et autres captures dangereuses à stocker sont rejetées.

box |...| est la forme d'échappement explicite et renvoie Result<box fn(...) -> T, alloc_error>. Le propriétaire peut être stocké ou restitué, mais il est uniquement déplacé, non clonable et non envoyable. Drop détruit ses captures exactement une fois et libère son allocation. L'attribution des régions reste lexicale. Il n'y a pas de conversion implicite entre les fermetures en pile et en boîte.

Les rappels Seed fn(...) -> T utilisent un descripteur code/environment à un pointeur. Les pointeurs de fonction C/platform restent fins et acceptent uniquement les fonctions nommées. Les effets de fermeture sont déduits du corps et vérifiés par rapport à des contrats de rappel qualifiés tels que @no_runtime_effects fn() -> void. Les fermetures récursives ne sont pas prises en charge.

Résumé de la propriété

Voir Ownership pour le modèle opérationnel.

Régions, tâches et bibliothèques

region(capacity) { body } installe un allocateur de bosses lexicales vérifiées. Les valeurs, vues ou pointeurs liés à la région ne peuvent pas échapper. Les tâches structurées capturées dans une région se joignent avant que son stockage de sauvegarde ne soit libéré.

spawn { body } est structuré : chaque arête quittant la portée lexicale propriétaire attend son groupe de tâches avant d'être nettoyée. La capture est une copie ou un déplacement par capacité. Un corps faillible (? à l'intérieur, ou une queue de type Result<T, E>) génère une jointure typée : le plan stocke le résultat dans une cellule de jointure et handle.wait() retours Result<T, E>; task_result_* reste pour les jointures manuelles. Les canaux, les jointures tapées, les événements, l'annulation et la synchronisation sont fournis par l'ordinaire. compiler/llvm/libs/task paquet. La grammaire propre n'a pas de chan<t>, send, recv, ou spawn détaché.

use "name" importe un module source ou une interface .sdi avec élimination de source. Les fonctions publiques importées peuvent être appelées avec ou sans leur qualificatif de module : use "process" rend environment("HOME") et process.environment("HOME") valides. Un symbole qualifié inconnu signale error[H002]: unknown symbol in module.

Substrat dangereux

raw_try_alloc<t>, raw_null<t>, raw_is_null<t>, raw_read<t>, raw_write<t>, raw_free<t>, raw_slice<t>, atomes, accès volatile, clôtures, conversions d'espace d'adressage, assemblage brut, FFI, appels système et unions brutes nécessitent unsafe. Les applications normales doivent consommer des wrappers sécurisés provenant des bibliothèques.

Lanceur de référentiel

./seed/seed check [--lib] [path|file.sd]
./seed/seed check [--json|--deep] [--report report.json] [--max-ms n] [--max-rss-kib n] [--max-files n] [--max-loc n] [--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 fmt [--check] [file.sd]  # short alias
./seed/seed fmt --write directory/
./seed/seed fmt --check --json [--output file] [file.sd|directory]

With `--check`, a directory recursively checks its `.sd` files; `.git`,
`target`, and `.seed` directories are ignored.
With `--json`, the formatter emits `seed.format.v1` with per-file status and
stable checked/needs-format/error counts; a non-zero status still includes the
complete JSON result.
./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] [--json] [--check-links] [--output file]
./seed/seed lint [--json] [--deny-warnings] [--cache dir] [--no-cache] [--fix] [--output file] [path]
./seed/seed explain [--json] CODE
./seed/seed explain [--json] --list
./seed/seed lsp
./seed/seed repl [--json]
./seed/seed publish --check [--json] [path]
./seed/seed publish --check [path]
./seed/seed mobile android <setup|sign|build|stage|check|package|run|doctor>

check est une vérification de source directe et étroite qui gère l'ensemble du pipeline sémantique, y compris toutes les preuves de sécurité obligatoires (propriété, provenance, effets, nettoyage, prêts, simultanéité) ; la réutilisation d’un HIR mis en cache ne contourne aucun d’entre eux. check --deep ajoute uniquement la passe didactique de charpie après la réussite de la vérification sémantique ; cela ne remplace jamais une preuve. Il résout les importations relatives source/interface et les dépendances du manifeste local path ; il ne compile pas d'abord un package de référentiel nu manquant. Utilisez build ou run lors de la validation de l'intégration de packages qui dépend du transfert automatique de la bibliothèque centrale.

check --report report.json écrit un déterministe seed.check-report.v1 résumé avec la source, file/LOC décomptes, indicateur de mode profond, résultat, temps total écoulé et phases distinctes de résolution source, de vérification sémantique et (sur demande) de peluches profondes. Sur les hôtes POSIX, il enregistre également peak_child_rss_kib pour le compiler/lint sous-processus. Si le filtrage profond échoue, le rapport marque à la fois la phase de filtrage profond et le résultat global comme fail et comprend son error/warning compte. Le rapport inclut également les timings des phases internes du compilateur et le pic RSS lorsque le LLVM un profileur est disponible. --max-ms et --max-rss-kib ajouter des budgets CI explicites ; ce sont des vérifications post-exécution : le sous-processus du compilateur s'exécute jusqu'à la fin, puis l'outillage juge le temps de mur (à partir du démarrage de l'outil) et le pic RSS de l'enfant par rapport aux plafonds. Les budgets dépassés sont enregistrés dans le rapport et échouent à la commande après l'émission d'une sortie structurée (budgets.violations plus le distinct check budget exceeded erreur). --max-files et --max-loc appliquez la même politique à la taille de la source accessible.

Les échecs du compilateur se répartissent en deux classes. Un échec sémantique est une violation de programme signalée sous forme de diagnostics spécifiques (codes tels que S001, H022) avec des travées, des notes et de l'aide. Une panne d'infrastructure (mémoire insuffisante du compilateur ou violation du contrat de la chaîne d'outils) est signalée comme suit : error[I-code]: detail (I900 fallback) ou le message générique « le compilateur a manqué de mémoire ou a violé un contrat d'infrastructure », sans qu'aucun artefact de sortie ne soit publié. Le côté programme non plus alloc_error, qui est un type de résultat d'exécution récupérable dans les programmes générés (voir le chapitre sur la propriété).

check --json émet les diagnostics lisibles par machine du compilateur ainsi que les source et une écurie summary avec error/warning compte. Il peut être combiné avec --deep pour inclure le seed.lint.v1 charge utile à peluches profondes ; ajouter --deny-warnings pour que les avertissements du compilateur et des peluches profondes échouent à la vérification tout en émettant le message complet JSON enveloppe. --output file écrit que JSON atomiquement et garde la sortie standard propre, y compris lorsque la vérification échoue.

doc --json émet un index de documentation seed.doc.v1 contenant des déclarations publiques, du Markdown rendu, des dépendances d'interface uniquement et des diagnostics de liens structurés. doc --check-links transforme les liens non résolus en état d'échec. De la même manière, lint --deny-warnings transforme les avertissements de charpie en un état d'échec sans modifier le comportement d'avertissement par défaut ; lint --output file écrit le résultat JSON ou le texte de manière atomique, y compris en cas d'échec d'une exécution de charpie. Les résultats Lint sont réutilisés par défaut à partir d'un cache par source adressé par contenu sous .seed/cache/lint ; --cache dir ou SEED_LINT_CACHE le remplace et --no-cache force un essai à froid. --prune-days N supprime les anciennes entrées de cache et signale le décompte. SEED_BUILD_JOBS contrôle les vérifications de sources parallèles limitées tout en préservant l’ordre des diagnostics. Les entrées du cache utilisent l'enveloppe seed.lint-cache.v1 ; les entrées mal formées ou plus anciennes sont reconstruites et signalées comme cache.invalidated. Les diagnostics L001 de documentation uniquement sont mis en cache indépendamment par déclaration publique, afin que les modifications non liées puissent les réutiliser ; la vérification sémantique reste entièrement source. --fix applique uniquement des correctifs de commentaires de documentation sécurisés et désactive la réutilisation du cache pour cette exécution.

Le cache HIR vérifié du compilateur peut être géré explicitement avec --cache-prune-days N avec --cache-dir dir. Il supprime uniquement les anciens fichiers d'identité .hci classiques de ce répertoire ; les fichiers sans rapport, les liens symboliques, les publications temporaires et les entrées récentes sont préservés. L'élagage est consultatif et ne contourne jamais la compilation ou la vérification de sécurité.

explain --json CODE émet un enregistrement seed.explain.v1 contenant le titre, la signification, un exemple non valide et des conseils de réparation pour un code de diagnostic. Sans --json, il conserve l'explication longue orientée vers l'humain. explain --list énumère le catalogue disponible ; Le mode JSON émet seed.explain-catalog.v1 avec les enregistrements structurés complets.

repl est une session orientée ligne de vérification uniquement. Chaque ligne saisie est validée dans le cadre du courant fn main région avant d’être accepté. Utilisation des régions multilignes :begin et :end transactionnellement ; :check, :show, :reset, :undo, :help, et :quit gérer la séance. :show imprime uniquement la région acceptée, à l'exclusion de toute transaction ouverte. Il n’exécute pas de code et n’affaiblit pas les règles de propriété. La complétion LSP suit la grammaire actuelle, y compris return, loop, break, et continue; les orthographes héritées supprimées ne sont pas suggérées. repl --json en émet un seed.repl-event.v1 JSON objet par événement pour l'éditeur et les consommateurs d'automatisation, y compris les lignes de transaction en attente et la sortie de session. check --max-files N et check --max-loc N rejeter les projets qui dépassent les budgets explicites à l'échelle des sources accessibles et enregistrer les violations dans le rapport de contrôle et JSON enveloppe de diagnostic. Le JSON l'enveloppe expose également observé metrics pour les fichiers accessibles, LOC, les millisecondes écoulées et le pic RSS enfant. Le result le champ est explicitement pass ou fail, y compris les échecs budgétaires. Avec --report, JSON Le mode intègre également le rapport de phase complet lors de l’écriture atomique du fichier de rapport demandé.

publish --check --json émet seed.publish-check.v1 avec le package, la version et pass/fail résultat pour les intégrations CI ; --output file l'écrit de manière atomique. Les échecs de validation renvoient toujours un statut différent de zéro après l'émission du résultat structuré. Les enveloppes d'échec incluent la stabilité error_code et le résolu project, les consommateurs n'ont donc pas besoin d'analyser le texte d'une erreur humaine. Les classes connues incluent PUBLISH_MANIFEST, PUBLISH_LICENSE, PUBLISH_DEPENDENCY, PUBLISH_PLATFORM, et PUBLISH_FFI_INSTALL.

build effectue une compilation incrémentielle avec résolution automatique des dépendances. Importations de packages nus (par ex. use "vec") sont mis en scène dans un endroit isolé target/profile magasin. Une deuxième version réutilise la correspondance .sdi/Artefacts natifs. test transmet les indicateurs de fin du compilateur, y compris les répétitions --link-object et --link-library entrées, à chaque binaire de test. Ceci est requis pour les tests de bibliothèque dont la surface Seed sécurisée est soutenue par un natif externe. ABI.

install compile le package en mode release et l'installe à l'échelle du système : exécutables sur ~/.local/bin (ou /usr/local/bin avec --system), générations de dépendance à ~/.local/lib/seed/generations/, et des interfaces avec ~/.local/share/seed/interfaces/. Utiliser --profile debug pour les versions de débogage et --prefix /custom/path pour les emplacements d'installation personnalisés.

uninstall supprime un package précédemment installé et ses générations de dépendances. install et uninstall prennent en charge --dry-run pour l'aperçu. L'enregistrement transactionnel du package installé comprend la cible, le profil, l'identité de génération de dépendances, la somme de contrôle du compilateur, la somme de contrôle de l'artefact installé, la somme de contrôle source et la somme de contrôle du verrouillage afin qu'une application déployée puisse être retracée jusqu'à ses entrées de construction exactes.

La publication à distance est distincte ; seed publish --check valide l'intégrité du package et du verrou localement sans exécuter de scripts sans restriction. Les packages compilés utilisent la qualification cible .sdi plus --install-library/--install-interface. Paquets déclarant extern fn doit également fournir INSTALL.md décrivant la configuration native requise pour leurs plates-formes déclarées ; le fichier doit être lisible UTF-8 et non vide. Les monorepos locaux peuvent conserver plusieurs packages versionnés indépendamment connectés par rapport path dépendances. Les sommes de contrôle de leurs arbres entraînent des reconstructions ; le développement local ordinaire ne nécessite pas de référentiel, de balise ou de publication Git pour chaque bibliothèque.

Le lanceur lit [build].profile = "debug" | "release" | "release-small"; héritage release = true cartes à release. Un explicite CLI le profil remplace le manifeste. seed install par défaut, il est publié quel que soit le manifeste, sauf si --profile est explicite. Les applications sont par défaut src/main.sd; un parent sûr facultatif [package].entry sélectionne une autre source dans le package. Les importations de packages nus sont d'abord résolues en fonction des artefacts installés correspondants ; sinon, ils sont compilés avec le profil d'application dans un fichier isolé. target/profile magasin. Les builds hébergés les lient dynamiquement par défaut. Une deuxième version réutilise la correspondance .sdi/artefacts indigènes ; les modifications apportées aux bibliothèques dynamiques privées ne reconstruisent pas les consommateurs, tandis que les modifications apportées aux bibliothèques dynamiques privées ne reconstruisent pas les consommateurs, tandis que les modifications apportées aux bibliothèques dynamiques privées ne reconstruisent pas les consommateurs, tandis .sdi ou ABI les changements le font.

L'installation de l'utilisateur place les exécutables dans ~/.local/bin, générations de dépendance immuables dans ~/.local/lib/seed, et les miroirs d'interface versionnés sous ~/.local/share/seed/interfaces. --system utilise la portée du système de plateforme (/usr/local sous Unix); --prefix remplace la racine. L'installation et la suppression sont enregistrées par la propriété et atomiques, et aucune commande ne modifie silencieusement les fichiers de démarrage du shell ou les variables d'environnement du chargeur.

Opérateurs

Priorité binaire du plus élevé au plus bas :

  1. multiplicatif (*, /, %)
  2. additif (+, -)
  3. changements de vitesse (<<, >>)
  4. comparaisons (<, <=, >, >=)
  5. égalité (==, !=)
  6. ET au niveau du bit (&), XOR (^), OU (|)
  7. ET logique (&&)
  8. OU logique (||)

&& et || court-circuit : a && b évalue b seulement quand a est true, et a || b évalue b seulement quand a est false. Les deux opérandes doivent être bool et le résultat est bool. Le court-circuit s'applique également au pliage constant, donc false && expensive() et true || expensive() sont des expressions constantes valides même lorsque expensive() n'est pas constante.

Compilateur de nettoyage direct

L'exécutable est compiler/llvm/build/seed. Sa liste de drapeaux faisant autorité est seed --help.

# 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 les modes incluent le jeton, l'AST, les types, les symboles, le HIR, la sécurité, le MIR, la disposition, ABI, faible MIR, et LLVM impression. Target/runtime les options incluent --target, --runtime-profile, --runtime-feature, --runtime, --sysroot, entry/linker-script commandes et séparer object/library lien.

--release utilise seed-safe-o2-v1; --release-small utilise seed-safe-oz-v1. Les deux sont en sécurité. ThinLTO et PGO sont des options explicites réservées à la version ; la liaison statique est indépendante. Il n'y a pas de fonctionnement --unchecked ou --fast-unsafe profil.

Statut cible

La prise en charge des objets et la prise en charge hébergée de bout en bout sont des revendications distinctes. Linux x86-64/AArch64 sont les chemins hébergés fermés. Autonome x86-64/AArch64/RISC-V64 avoir des preuves de démarrage à leurs niveaux déclarés. Windows x86-64 a PE/runtime/DLL/ task/network preuve sous le vin requis. macOS x86-64 et arm64 ont un SDK explicite executable/dylib/static liaison, exécution et planification de pthread. Intel natif x86-64 l'exécution demeure; arm64 est uniquement à liaison croisée. Voir compiler/llvm/tests/GATE14_TARGET_MATRIX.tsv.

Sur un Mac Intel, exécutez SEED_MACOS_RUNNER_POLICY=required make -C seed/compiler/llvm gate14-macos-x86_64-test. Le script découvre le SDK avec xcrun et utilise le ld d'Apple, sauf s'il est explicitement remplacé.