Activer la complétion Golo

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

# Activer la complétion Golo

Ce guide montre comment obtenir la complétion, les survols, l'aller-à-la-définition et les marques d'erreur. Il suppose que Turbo Golo est déjà installé.

La complétion vient de **`golo lsp`** — l'interpréteur GoloScript lui-même, démarré en mode serveur de langage. Il n'y a pas de serveur séparé à installer : une machine qui peut exécuter un script Golo peut en compléter un. Turbo Golo n'embarque pas l'interpréteur pour autant : l'édition et la coloration marchent sans lui, et seules la complétion et les marques d'erreur manquent.

## 1. Installer golo

Soit un binaire depuis la [page des releases](https://codeberg.org/TypeUnsafe/golo-script/releases) :

```bash
chmod +x golo-<version>-<plateforme>
sudo mv golo-<version>-<plateforme> /usr/local/bin/golo
golo --version
```

soit une construction depuis les sources, qui donne aussi les deux compilateurs :

```bash
git clone https://codeberg.org/TypeUnsafe/golo-script.git && cd golo-script
./install.sh
```

L'installeur de Turbo Golo fera la seconde pour vous : `scripts/install.sh --with-server`. [Installer GoloScript](install-goloscript.md) donne le détail.

## 2. S'assurer que Turbo Golo le trouve

Turbo Golo regarde d'abord sur le `PATH`, puis dans `/usr/local/bin`, où écrit l'installeur de GoloScript. Vérifiez :

```bash
golo --version
```

```
v0.1.1 | dev.20260802.🤓
```

Si cela dit « command not found » mais que Turbo Golo le trouve quand même, c'est attendu et sans conséquence : l'éditeur a cherché dans `/usr/local/bin` lui-même.

## 3. Ouvrir un script

```bash
cd /chemin/vers/vos/scripts
turbo-golo main.golo
```

Golo n'a pas de manifeste de projet, il n'y a donc rien à chercher : `golo lsp` est démarré dans le répertoire du fichier que vous avez ouvert, et il répond à propos de ce fichier. L'endroit d'où vous lancez l'éditeur ne change rien à la complétion — il décide où s'exécutent les commandes du menu Golo, ce qui est une autre affaire.

## 4. Demander une complétion

Tapez les premières lettres d'un nom et appuyez sur **Ctrl-Espace** :

```golo
prin
```

Une liste se déroule sous le curseur — `print`, `println`, avec leurs signatures. Continuez à taper pour la réduire, **↑ ↓** pour la parcourir, **Entrée** ou **Tab** pour accepter, **Échap** pour l'écarter.

## Ce que contient la liste

`golo lsp` propose quatre sortes de choses :

| Proposé | Exemple |
| --- | --- |
| Les mots-clés | `function`, `foreach`, `augment` |
| Les builtins de l'interpréteur, avec leurs signatures et leur documentation | `println`, `readFile`, `httpGet`, `DynamicObject` |
| Les fonctions et unions déclarées **au premier niveau** du fichier | votre propre `function helper = …` |
| Les symboles apportés par `import` depuis les modules embarqués dans le binaire | `Some`, `None`, `isSome`, `either` après `import gololang.Errors` |

Deux choses n'y sont délibérément **pas**, et toutes deux ressemblent à un serveur cassé quand on ne le sait pas :

- **Une fonction déclarée dans une autre fonction.** Seules les déclarations de premier niveau sont collectées. Sortez-la, ou acceptez qu'elle ne soit pas proposée.
- **Tout ce qui vient d'un fichier `.golo` à vous.** `import` résout les modules intégrés à l'interpréteur — `gololang.Errors`, `gololang.Types`, `gololang.Ui`, `gololang.Testing`, … — et rien sur le disque. Une fonction dans `lib/util.golo` n'est pas vue depuis `main.golo`.

## Vérifier ce que fait le serveur

L'extrémité droite de la barre d'état montre l'état du serveur de langage : `LSP: starting…`, `LSP: ready`, ou la raison pour laquelle il n'y en a pas :

```
LSP: no golo — see https://codeberg.org/TypeUnsafe/golo-script/releases
```

`Run ▸ Language server status` montre la même chose dans une boîte, avec le chemin où le binaire a été trouvé et le répertoire où il a été démarré.

## Variantes

**Vous ne voulez aucun serveur de langage :**

```bash
turbo-golo -no-lsp main.golo
```

**La complétion est morte dans une fenêtre née sans nom.** Une fenêtre « Untitled » n'a aucun fichier à annoncer à `golo lsp` tant qu'elle n'est pas enregistrée — appuyez sur **F2** et donnez-lui un nom en `.golo`. Dès cette sauvegarde, la complétion, le survol et les marques d'erreur fonctionnent dans cette fenêtre ; inutile de quitter et relancer l'éditeur.

**La liste est vide.** `golo lsp` répond pour n'importe quel fichier, y compris un qui ne parse pas — il liste les mots-clés et les builtins quoi qu'il arrive — une liste vide signifie donc presque toujours que le serveur ne tourne pas. Lisez la barre d'état.

**Ctrl-Espace ne fait rien.** tmux, screen et les terminaux des IDE s'approprient fréquemment `Ctrl-Espace` avant que l'éditeur le voie. Utilisez `Run ▸ Completion` à la place.

**Une requête prend trop longtemps.** Chaque requête abandonne après quelques secondes, un serveur bloqué ralentit donc l'éditeur mais ne le fige jamais. La barre d'état signale l'échec.

**Vous avez installé golo à un endroit inhabituel.** L'éditeur cherche sur le `PATH` et dans `/usr/local/bin`, et nulle part ailleurs — aucune variable d'environnement ne nomme un autre répertoire. Mettez le répertoire sur le `PATH`, ou un lien symbolique dans `/usr/local/bin`.

## Ce que le serveur donne d'autre

La complétion est la chose la plus bruyante qu'il fait et la moindre de ce qu'il sait. La même connexion répond à quatre autres questions, toutes dans le menu **Code** — trois à propos du symbole sous le curseur, aucune sélection nécessaire, et une à propos d'un nom que vous tapez.

| Touche | Ce qu'elle fait | Avec `golo lsp` |
| --- | --- | --- |
| **Ctrl-Espace** | La liste de complétion | oui |
| **F1** | Décrire le symbole sous le curseur | oui — pour une fonction que vous avez déclarée, les commentaires `#` écrits juste au-dessus ; pour un builtin, sa signature et un exemple |
| **F12** | Aller là où il est déclaré | oui, dans le fichier |
| **Shift-F12** | Lister tous ses usages | oui, dans le fichier : sa déclaration et chaque appel |
| **Ctrl-T** | Trouver un symbole par son nom dans tout le projet | oui : les fonctions, unions et noms de module de premier niveau de chaque fichier `.golo` sous la racine du projet, ouvert ou non |

Et, sans touche : *Symbol in file…* liste les fonctions et unions de premier niveau du fichier, les variantes de chaque union imbriquées sous elle ; *Problems…* liste tous les diagnostics ; *Find implementations…* répond par la déclaration de la fonction, là où va **F12** — Golo n'a pas d'interfaces, une fonction est sa propre implémentation ; *Go to type definition* répond « rien trouvé ».

La seule qui ne répond rien est la frontière du serveur, pas celle de l'éditeur : `golo lsp` annonce `completion`, `hover`, `definition`, `documentSymbol`, `references`, `implementation` et `workspaceSymbol`, et pas `typeDefinition`. Jusqu'à GoloScript v0.2.0 il n'annonçait que les quatre premiers et ce tableau le disait ; un test de ce dépôt a échoué le jour où le serveur s'est mis à répondre aux trois autres, et c'est ainsi que le tableau a été revu. L'entrée de menu reste parce que la griser selon ce qu'un serveur a dit au démarrage donnerait au menu une forme différente selon la machine, et le même genre de test échoue encore le jour où un futur golo répond aussi à la définition de type.

## Les marques d'erreur

Les problèmes que le serveur trouve arrivent sans qu'on les demande, à l'ouverture et à chaque modification. La première erreur du fichier que vous éditez apparaît à droite de la barre d'état, précédée de `⚠` ; chaque ligne à problème reçoit un `×` dans la gouttière ; et **Code ▸ Problems…** les liste toutes.

`golo lsp` en signale trois sortes :

- **Les erreurs de syntaxe** du lexer et du parseur — une accolade manquante, un token que le parseur n'accepte pas. Les messages du parseur portent une ligne et pas de colonne, la marque tombe donc sur la ligne entière ; un message sans ligne du tout tombe sur la ligne 1.
- **Une confusion `:`/`.`** — `obj.method()` là où Golo veut `obj: method()`.
- **Un commentaire à la C** — `//` ou `/* */`, que Golo n'a pas. Les commentaires Golo sont `#` et `----`.

Un script qui parse puis échoue à l'exécution ne reçoit aucune marque : le serveur parse, il n'exécute jamais rien.

[Interroger le code](ask-about-code.md) parcourt le menu Code.

## Voir aussi

- Pourquoi le serveur est optionnel, et pourquoi l'interpréteur est le serveur : [Coloration et complétion](../explanation/colouring-and-completion.md)
- Installer l'interpréteur : [Installer GoloScript](install-goloscript.md)
- Toutes les touches : [référence du clavier](../reference/keyboard.md)