Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2023-12-24T22:29:52+01:00Les derniers messages parus sur le forum de Zeste de Savoir.use-after-free of `proc_macro` symbol, Rust, message #2534362023-12-24T22:29:52+01:00jordan.rickman.42/@jordan.rickman.42https://zestedesavoir.com/forums/sujet/16858/use-after-free-of-proc_macro-symbol-rust/?page=1#p253436<h5 id="francais-via-google-translate">Francais (via Google Translate):<a aria-hidden="true" tabindex="-1" href="#francais-via-google-translate"><span class="icon icon-link"></span></a></h5>
<p>Mes excuses, je ne parle pas français et je compte sur Google Translate, j’espère donc que ma réponse sera toujours compréhensible. Mais je voulais apporter de l’aide car j’ai récemment rencontré ce même problème et je pense que je l’ai résolu.</p>
<p>Votre problème est probablement dû au fait que la structure <code>Ident</code> contient une référence à un élément appelé <a href="https://docs.rs/proc-macro2/1.0.71/proc_macro2/struct.Span.html">Span</a>. Les étendues contiennent des informations contextuelles capturées lors de la création du jeton. Lorsque vous écrivez <code>#[extension_parser(B)]</code>, le jeton <code>B</code> est un Ident qui inclut un Span. Il semble que vous stockiez ensuite l’Ident dans une collection <code>EXTENSIONS</code>. Lorsque <code>#[extension_parser(B)]</code> termine son expansion, le Span est supprimé et libéré de la mémoire. La collection <code>EXTENSIONS</code> contient désormais une mauvaise référence.</p>
<p>Plus tard, le compilateur tente d’étendre la macro <code>load_extension_parser!(B)</code>. Ici vous avez un bloc <code>unsafe</code> qui inclut la ligne <code>if EXTENSIONS.contains(&input)</code>. Il est probable que cette méthode <code>contains()</code> accède à l’Ident <code>B</code> que vous avez stocké précédemment afin de faire une comparaison. Cependant, cet Ident <code>B</code> a un Span qui a déjà été supprimé, et il panique donc en essayant d’accéder à cette mémoire.</p>
<p>En d’autres termes, un Ident (ou tout autre jeton) transmis à une macro de procédure ne peut être utilisé que dans cette macro de procédure et ne peut pas être stocké et utilisé ultérieurement. J’ai pu contourner cette limitation en stockant une String à la place. Je pense que si vous faites en sorte que votre collection <code>EXTENSIONS</code> stocke des Strings au lieu d’un Ident, cela résoudra votre problème.</p>
<h5 id="original">Original<a aria-hidden="true" tabindex="-1" href="#original"><span class="icon icon-link"></span></a></h5>
<p>My apologies that I do not speak French and am relying on Google Translate, so hopefully my answer will still be understandable. But I wanted to provide some help as I recently encountered this same problem and I think that I worked it out.</p>
<p>Your problem is likely that the <code>Ident</code> struct contains a reference to a thing called a <a href="https://docs.rs/proc-macro2/1.0.71/proc_macro2/struct.Span.html">Span</a>. Spans contain contextual information that is captured when the token is created. When you write <code>#[extension_parser(B)]</code>, the token <code>B</code> is an Ident which includes a Span. It seems that you are then storing the Ident in an <code>EXTENSIONS</code> collection. When the <code>#[extension_parser(B)]</code> finishes expanding, the Span is dropped and freed from memory. The <code>EXTENSIONS</code> collection now contains a bad reference.</p>
<p>Later on, the compiler tries to expand the <code>load_extension_parser!(B)</code> macro. Here you have an <code>unsafe</code> block which includes the line <code>if EXTENSIONS.contains(&input)</code>. It is likely that this <code>contains()</code> method is accessing the <code>B</code> Ident which you stored earlier in order to do a comparison. However, that <code>B</code> Ident has a Span which was was already dropped, and so it panics while trying to access that memory.</p>
<p>In other words, an Ident (or any other token) that is passed into a proc macro can only be used within that proc macro and cannot be stored and used at a later time. I was able to get around this limitation by storing a string instead. I think that if you make your <code>EXTENSIONS</code> collection store Strings instead of an Ident, this will fix your problem.</p>union rust, message #2525042023-10-18T17:22:41+02:00phigoldratio/@phigoldratiohttps://zestedesavoir.com/forums/sujet/17175/union-rust/?page=1#p252504<p>d’accord je vois. bon ce n’est pas un truc très utile dapres ce que j’ai compris, mais c’est bon à savoir <img src="/static/smileys/svg/smile.svg" alt=":)" class="smiley"> </p>union rust, message #2524952023-10-17T22:21:22+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/17175/union-rust/?page=1#p252495<p>Salut,</p>
<p>Les deux messages précédents ratent complètement le point principal des <code>union</code> en Rust, qui est de faciliter l’interfaçage avec du code C qui manipule des unions en C (qui ressemblent fortement aux unions de Rust). Dans du code Rust normal qui ne s’interface pas avec du C, il est extrêmement rare d’avoir besoin d’utiliser des unions (pour ne pas dire jamais…).</p>
<p>Si on veut manipuler des trames réseaux en Rust, il n’y a pas de raison de s’emmerder avec des unions. On manipulerait plutôt soit un type qui wrappe la trame et donne une API safe autour, soit des types variés pour les différents morceaux des trames qui implémentent correctement la façon de s’écrire dans une trame. (Et probablement les deux, même).</p>
<p>Pour ce qui est de l’exemple de faire du "typage dynamique" (sic), c’est encore plus tiré par les cheveux… <img src="/static/smileys/svg/siffle.svg" alt=":-°" class="smiley"> Une <code>enum</code> remplacerait l’exemple donné (qui n’a rien à voir avec du typage dynamique) de façon beaucoup plus facile et safe à manipuler, et pour faire du typage dynamique on a <code>dyn Trait</code>.</p>union rust, message #2524932023-10-17T19:13:14+02:00minirop/@minirophttps://zestedesavoir.com/forums/sujet/17175/union-rust/?page=1#p252493<p>L’exemple le plus courant (citation needed) est probablement pour avoir une variable au typage dynamique dans un langage au typage statique (comme le C). Un exemple très basique :</p>
<div class="hljs-code-div hljs-code-c"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span></div><pre><code class="hljs language-c"><span class="hljs-class"><span class="hljs-keyword">struct</span> <span class="hljs-title">Type</span> {</span>
<span class="hljs-keyword">int</span> type;
<span class="hljs-class"><span class="hljs-keyword">union</span> {</span>
<span class="hljs-keyword">int</span> i;
<span class="hljs-keyword">char</span>* str;
<span class="hljs-keyword">float</span> f;
};
};
</code></pre></div>
<p>Pourquoi payer l’espace mémoire de 3 types (int, float, et char*) quand il n’y en a qu’un seul d’utilisé à la fois ? Tu mets tout en une union et donc la taille prise est la taille du plus gros élément (plutôt que la somme des trois).
Le champ "type" est là pour savoir quel champ est utilisé.</p>union rust, message #2524912023-10-17T18:09:00+02:00romantik/@romantikhttps://zestedesavoir.com/forums/sujet/17175/union-rust/?page=1#p252491<p>Salut,</p>
<p>Ta question est "à quoi ça sert ?". Doit-on comprendre que tu as compris comment ça fonctionne / son effet ?</p>
<p>L’effet, en bref, c’est que les champs qui composent l’union partage la même zone mémoire, donc si on modifie l’un, les autres champs auront par conséquent changé de valeur. Par exemple, si l’union <code>u</code> est composé d’un i16 <code>i</code> et d’un u16 <code>u</code>, et sa valeur est 2 alors <code>u.i == 2 && u.u == 2</code>. Maintenant j’affecte -1 à i et j’obtiens <code>u.i == -1 && u.u == 65535</code>.<br>
(Je suis resté en textuel car les accès à ces champs en rust est toujours unsafe d’après <a href="https://doc.rust-lang.org/std/keyword.union.html">la doc</a>)</p>
<p>Pour ce qui est de "à quoi ça sert", il est vrai que c’est quand même très particulier. Pour réinterprêter des données on a d’autres outils, comme <code>as</code>.<br>
Il se trouve que l’union est un outil qui existe aussi en C. Et dans ce langage, j’ai eu une utilisation d’union qui me semblais appropriée et qui doit pouvoir aussi se justifier en rust : il s’agissait de trame réseaux.<br>
Les trames réseaux, qui véhiculent les informations de communication, économisent un maximum de bit pour se limiter à ce qui est utile et obtenir ainsi un maximum de débit. Alors lorsqu’un champs ne peut avoir que 4 valeurs par exemple, comme un enum ou un compteur borné, on va lui réserver seulement 2 bits. Mais derrière, l’ordinateur, lui, il sait travailler en groupe d’octet. Dans la mémoire, mes 2 bits sont noyé au milieu d’un octet qui comporte les infos des champs voisins. Donc on peut déclarer des unions entre des groupes d’octets qui contiennent la trame entièrement et des structures décrivant le protocole (généralement composé de <a href="https://en.cppreference.com/w/c/language/bit_field">bit-fields</a> pour pouvoir récupérer mon enum sur 2 bits uniquement) qui servent de "grille de lecture" pour pouvoir exploiter les données de la trame.</p>
<p>C’est la seule utilisation que j’ai expérimenté (et c’était en C) mais rust est un langage qui veut proposer une gestion fine de la mémoire, et les domaines comme la programmation système ou le réseau ont parfois besoin de faire coïncider des zones mémoires.</p>union rust, message #2524902023-10-17T16:12:09+02:00phigoldratio/@phigoldratiohttps://zestedesavoir.com/forums/sujet/17175/union-rust/?page=1#p252490<p>je regardais la documentation de rust, et je voyais un type de donnée appellé union et je n’ai strictement rien capté à quoi ça servait!
des reponses sont bienvenues <img src="/static/smileys/svg/smile.svg" alt=":)" class="smiley"> </p>question sur rust, message #2524552023-10-12T17:46:05+02:00phigoldratio/@phigoldratiohttps://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252455<p>ok super merci a vous deux ! <img src="/static/smileys/svg/smile.svg" alt=":)" class="smiley"> </p>question sur rust, message #2524522023-10-12T16:33:26+02:00romantik/@romantikhttps://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252452<figure><blockquote>
<p>Honnêtement je comprends rien à ce que tu essayes de dire… Il n’y a jamais besoin de <code>unwrap</code> une référence pour accéder à l’objet derrière la référence, et ces dernières sont toujours valides. C’est un des points forts de Rust.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252447">adri1</a></figcaption></figure>
<p>Ok, je vois. Je mélange les concepts.</p>
<figure><blockquote>
<p>Lorsque tous les <code>Rc</code> eux-mêmes sont détruits, plutôt. Un propriétaire d’un <code>Rc</code> pourrait parfaitement choisir de faire fuiter son <code>Rc</code>.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252447">adri1</a></figcaption></figure>
<p>Oui, tout à fait d’accord, si tu veux être plus précis.</p>
<hr>
<figure><blockquote>
<p>mais du coup qui croire entre vous deux ? <img src="/static/smileys/svg/huh.svg" alt=":o" class="smiley"> </p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252451">phigoldratio</a></figcaption></figure>
<p>C’est la réponse d’adri1 qui est bonne. Personnellement ça m’a aussi éclairé. Est-ce que sa réponse est suffisamment claire pour toi aussi <a href="/@phigoldratio" rel="nofollow" class="ping ping-link">@<span class="ping-username">phigoldratio</span></a> ?</p>question sur rust, message #2524512023-10-12T16:19:45+02:00phigoldratio/@phigoldratiohttps://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252451<p>mais du coup qui croire entre vous deux ? <img src="/static/smileys/svg/huh.svg" alt=":o" class="smiley"> </p>question sur rust, message #2524472023-10-12T15:12:57+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252447<blockquote>
<p>pour partager l’accès à une ressource, oui, mais ça ne te garantie pas qu’elle soit présente. Il faut la unwrap. Elle est valide dans le sens où le unwrap pourra te signaler qu’elle n’est plus là.</p>
</blockquote>
<p>Honnêtement je comprends rien à ce que tu essayes de dire… Il n’y a jamais besoin de <code>unwrap</code> une référence pour accéder à l’objet derrière la référence, et ces dernières sont toujours valides. C’est un des points forts de Rust.</p>
<figure><blockquote>
<p>la partie importante dans ce message c’était que la propriété est partagée et que la ressource pointée par Rc est détruite lorsque tout les propriétaires des Rc sont détruits.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252446">romantik</a></figcaption></figure>
<p>Lorsque tous les <code>Rc</code> eux-mêmes sont détruits, plutôt. Un propriétaire d’un <code>Rc</code> pourrait parfaitement choisir de faire fuiter son <code>Rc</code>.</p>question sur rust, message #2524462023-10-12T14:39:23+02:00romantik/@romantikhttps://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252446<figure><blockquote>
<p>Si le type restait le même, l’état d’ownership serait aussi le même…</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252445">adri1</a></figcaption></figure>
<p>En effet, j’ai mal compris ce que disait</p>
<blockquote>
<h4 id="-vs-ref">& vs ref<a aria-hidden="true" tabindex="-1" href="#-vs-ref"><span class="icon icon-link"></span></a></h4>
<ul>
<li>& denotes that your pattern expects a reference to an object. Hence & is a part of said pattern: &Foo matches different objects than Foo does.</li>
<li>ref indicates that you want a reference to an unpacked value. It is not matched against: Foo(ref foo) matches the same objects as Foo(foo).</li>
</ul>
</blockquote>
<p>Si dans le pattern matching ça ne match pas les mêmes objets, c’est de par le fonctionnement du pattern matching et pas à cause du typage.</p>
<figure><blockquote>
<p>pour partager une ressource, on a déjà des références qui sont garanties valides.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252445">adri1</a></figcaption></figure>
<p>pour partager l’accès à une ressource, oui, mais ça ne te garantie pas qu’elle soit présente. Il faut la unwrap. Elle est valide dans le sens où le unwrap pourra te signaler qu’elle n’est plus là.
On peut avoir un design où un manager contrôle la ressource et les autres y ont accès avec des références. C’est un choix de design. Mais osef, la partie importante dans ce message c’était que la propriété est partagée et que la ressource pointée par Rc est détruite lorsque tout les propriétaires des Rc sont détruits.</p>question sur rust, message #2524452023-10-12T12:51:05+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252445<p>Salut,</p>
<blockquote>
<p>ref te permet d’emprunter la variable, tu n’en es donc pas propriétaire, mais le type reste le même, alors que & a un type différent.</p>
</blockquote>
<p>Ça n’a absolument aucun sens. Si le type restait le même, l’état d’ownership serait aussi le même… <img src="/static/smileys/svg/siffle.svg" alt=":-°" class="smiley"> Il n’y a pas de différence entre <code>let u = &c</code> et <code>let ref u = c</code>, dans les deux cas on se retrouve avec <code>u</code> qui est une référence vers <code>c</code>.</p>
<p>Quand on a déjà un binding vers une valeur (comme <code>c</code>) et qu’on veut une référence vers cette valeur, on préfère utiliser <code>&c</code> pour construire la référence (la forme <code>let ref u = c</code> est d’ailleurs levée par <code>clippy</code> comme étant non-idiomatique). <code>ref u</code> est utile lorsqu’on fait du <em>pattern matching</em> plus avancé et qu’on veut directement obtenir une référence à partir d’une valeur <em>owned</em>. Par exemple :</p>
<div class="hljs-code-div hljs-code-rust"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span></div><pre><code class="hljs language-rust"><span class="hljs-keyword">let</span> a = <span class="hljs-literal">Some</span>(<span class="hljs-number">5u8</span>);
<span class="hljs-keyword">if</span> <span class="hljs-keyword">let</span> <span class="hljs-literal">Some</span>(<span class="hljs-keyword">ref</span> b) = a {}
</code></pre></div>
<p>permet d’obtenir <code>b</code> comme une référence <code>&u8</code> vers le <code>5</code> contenu dans <code>a</code>.</p>
<blockquote>
<p>Quant à Rc, il s’agit de partager une ressource. Par exemple, disons que tu as une classe de sortie audio, et que tu as plusieurs classes de source audio, tu ne vas instancier qu’une seule fois ta sortie audio et la partager entre les sources pour qu’ils y aient accès et se partage la propriété. Ainsi, tant qu’une de ces sources existent (autrement dit tant que tu utilises ta sortie audio), l’instance de ta sortie audio existera. Quand toutes les sources seront détruites, ta sortie audio aussi.</p>
</blockquote>
<p>Il n’y a pas de classes en Rust… Ensuite, pour partager une ressource, on a déjà des références qui sont garanties valides. Pour être moins flou, le but de <code>Rc</code> est de déplacer la question de la résolution des <em>lifetimes</em> au <em>runtime</em> plutôt qu’au <em>compile time</em>. On parle parfois de <em>shared owernship</em>, parce que plutôt que d’avoir un seul propriétaire d’une ressource quelconque qui contrôle statiquement sa durée de vie et plein de références simples, on wrappe cette ressource dans un <code>Rc</code> qu’on peut ensuite cloner à loisir. Quand on clone un <code>Rc</code>, on se retrouve en apparence avec une nouvelle valeur qui nous appartient complètement, mais en fait la ressource n’est pas clonée en mémoire. Chaque <code>Rc</code> est un pointeur vers la même zone mémoire, et la résolution de la durée de vie de la ressource pointée se fait au runtime lorsque le dernier <code>Rc</code> disparaît. C’est très utile lorsqu’une ressource est partagée entre plein d’acteurs et qu’avoir un seul propriétaire et des références simples conduirait à un code beaucoup plus compliqué (voire tout simplement impossible à écrire).</p>question sur rust, message #2524432023-10-12T10:09:02+02:00romantik/@romantikhttps://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252443<p>Salut,</p>
<p>De ce que j’en comprend :</p>
<p>ref te permet d’emprunter la variable, tu n’en es donc pas propriétaire, mais le type reste le même, alors que & a un type différent.</p>
<div class="hljs-code-div hljs-code-rust"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span></div><pre><code class="hljs language-rust"><span class="hljs-keyword">let</span> c : <span class="hljs-built_in">String</span> = <span class="hljs-built_in">String</span>::new(<span class="hljs-string">"exemple"</span>);
<span class="hljs-keyword">let</span> u = &c; <span class="hljs-comment">// a un type &String</span>
<span class="hljs-keyword">let</span> <span class="hljs-keyword">ref</span> w = c <span class="hljs-comment">// a un type String</span>
</code></pre></div>
<p>Quant à Rc, il s’agit de partager une ressource. Par exemple, disons que tu as une classe de sortie audio, et que tu as plusieurs classes de source audio, tu ne vas instancier qu’une seule fois ta sortie audio et la partager entre les sources pour qu’ils y aient accès et se partage la propriété. Ainsi, tant qu’une de ces sources existent (autrement dit tant que tu utilises ta sortie audio), l’instance de ta sortie audio existera. Quand toutes les sources seront détruites, ta sortie audio aussi. </p>
<p>Et Arc est la version thread-safe de Rc. ça sert à la même chose, avoir une instance partagée entre plusieurs propriétaires, mais dans un contexte où les propriétaires peuvent être dans dans threads différents et donc avoir potentiellement un accès concurrent à la ressource partagée.</p>question sur rust, message #2524422023-10-12T07:54:33+02:00phigoldratio/@phigoldratiohttps://zestedesavoir.com/forums/sujet/17171/question-sur-rust/?page=1#p252442<p>bonjour, j’avais quelques questions sur 2 points en rust qui me semblent assez obscurs : tout d’abord, j’ai vu quelquefois dans certains codes le mor clef réf. du coup je me demandais quelle est la différence entre ces 2 lignes de code et si il est préférable den utiliser une :
let u = &c
let ref u =c</p>
<p>de plus, si qqn pouvait m’expliquer l’utilité des pointeurs intelligent Rc<> et Arc<> ça serait cool</p>
<p>Merci d’avance !</p>Signification de #[ ] en Rust, message #2524332023-10-11T10:13:22+02:00phigoldratio/@phigoldratiohttps://zestedesavoir.com/forums/sujet/17167/signification-de-en-rust/?page=1#p252433<p>super merci beaucoup <img src="/static/smileys/svg/smile.svg" alt=":)" class="smiley"> </p>Signification de #[ ] en Rust, message #2524322023-10-11T08:30:49+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/17167/signification-de-en-rust/?page=1#p252432<p>Salut,</p>
<p>Ces trucs s’appellent des attributs, et servent à parler au compilateur et outils de développement pour indiquer des choses variées. Je t’invite à consulter <a href="https://doc.rust-lang.org/reference/attributes.html">la référence pour avoir une idée de tout ce qu’on peut faire avec</a>. Les usages les plus courants sont</p>
<ul>
<li>marquer une fonction comme étant un test <code>#[test]</code>, et ne compiler certaines parties du code que lorsqu’on est en train de faire les tests <code>#[cfg(test)]</code> ;</li>
<li>automatiquement implémenter certains traits, avec par exemple <code>#[derive(Clone)]</code> ;</li>
<li>localement changer les diagnostics compilateurs (par exemple <code>#[allow(unused)]</code>) ou de clippy (comme <code>#![warn(clippy::pedantic)]</code>).</li>
</ul>
<p>Il y a d’autres usages plus ou moins communs selon le genre de logiciel que tu développes, par exemple marquer une fonction comme un bon candidat pour l'<em>inlining</em> avec <code>#[inline]</code>, ou encore activer localement certaines fonctionnalités propres à certaines architectures de processeurs comme <code>#[target_feature(enable = "avx2")]</code>. C’est déjà beaucoup plus spécifique et rare comme usage, mais tu peux croiser des choses de ce genre dans la lib standard par exemple.</p>
<p>Et dernière chose, <code>#[...]</code> et <code>#![...]</code> sont très similaires : le premier s’applique à l’élément qui suit l’attribut, et le second à l’élément dans lequel l’attribut existe. Donc</p>
<div class="hljs-code-div hljs-code-rust"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span></div><pre><code class="hljs language-rust"><span class="hljs-meta">#[allow(unused)]</span>
<span class="hljs-function"><span class="hljs-keyword">fn</span> <span class="hljs-title">foo</span></span>(bar: <span class="hljs-built_in">u8</span>) {}
</code></pre></div>
<p>et</p>
<div class="hljs-code-div hljs-code-rust"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span></div><pre><code class="hljs language-rust"><span class="hljs-function"><span class="hljs-keyword">fn</span> <span class="hljs-title">foo</span></span>(bar: <span class="hljs-built_in">u8</span>) {
<span class="hljs-meta">#![allow(unused)]</span>
}
</code></pre></div>
<p>sont la même chose. La seconde forme est peu utilisée en pratique. En général, <code>#![...]</code> est réservé aux attributs d’un module situé à la racine d’un fichier, et aux attributs "globaux" à <code>lib.rs</code>.</p>Signification de #[ ] en Rust, message #2524312023-10-11T07:55:48+02:00phigoldratio/@phigoldratiohttps://zestedesavoir.com/forums/sujet/17167/signification-de-en-rust/?page=1#p252431<p>bonjour,
je code maintenant en rust depuis quelque temps mais je nais toujours pas bien compris à quoi servaient les espèces d’en têtes à dessus de certaines fonctions / struct .
par exemple des choses comme : </p>
<div class="hljs-code-div hljs-code-rust"><pre><code class="hljs language-rust"><span class="hljs-meta">#[cfg()]</span>
</code></pre></div>
<p>des explications seraient la bienvenue sur ce sujet <img src="/static/smileys/svg/hihi.svg" alt="^^" class="smiley"></p>Bug d'ide de rust , il n'y a plus de coloration, message #2521142023-09-15T23:16:13+02:00Gil Cot/@Gil%20Cothttps://zestedesavoir.com/forums/sujet/17145/bug-dide-de-rust-il-ny-a-plus-de-coloration/?page=1#p252114<blockquote>
<p>il y a une crate (qu’une seul crate, j’en ai plusieurs), et il n’y a pas de couleur syntactite (désolé si je le dis mal). Ce qui est etrange, c’est que c’est que dans cette crate là qu’il y a ce bug.</p>
</blockquote>
<p>Quelles sont les étapes exactes pour reproduire le souci ? Histoire de voir si on a le même comportement avec d’autres environnements (et sinon ça fera déjà des billes pour ouvrir un ticket au support de l’éditeur)</p>Bug d'ide de rust , il n'y a plus de coloration, message #2521132023-09-15T22:56:08+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/17145/bug-dide-de-rust-il-ny-a-plus-de-coloration/?page=1#p252113<p>RustRover réutilise le même backend, donc c’est pas très surprenant… <img src="/static/smileys/svg/siffle.svg" alt=":-°" class="smiley"> Par ailleurs, ça change rien au fait qu’on est pas le service après-vente de jetbrains et qu’on peut pas deviner le problème avec le peu d’information que tu nous donnes.</p>Bug d'ide de rust , il n'y a plus de coloration, message #2521112023-09-15T22:16:55+02:00NightProg/@NightProghttps://zestedesavoir.com/forums/sujet/17145/bug-dide-de-rust-il-ny-a-plus-de-coloration/?page=1#p252111<p>c’etait deja sur l’ide de InteliJ IDEA donc ce n’est pas un bug de RustRover specialement</p>Bug d'ide de rust , il n'y a plus de coloration, message #2521102023-09-15T19:55:51+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/17145/bug-dide-de-rust-il-ny-a-plus-de-coloration/?page=1#p252110<p>Salut,</p>
<p>RustRover est bien le truc <em>closed source</em> en développement par jetbrains pour leur IDE commercial à venir? Ça va être difficile de t’aider, à priori la marche à suivre serait plutôt de faire un ticket auprès de leur support…</p>
<p>Cela dit j’ai un peu de mal à comprendre l’intérêt d’utiliser un IDE commercial pour Rust alors que le serveur LSP <a href="https://rust-analyzer.github.io">Rust analyzer</a> est officiel, bien maintenu, open source, et utilisé par quasiment tout le monde. Tu peux le brancher sur n’importe quel éditeur qui implémente LSP, notamment Vim ou VS Code.</p>