wip simple '//' comment token for 'Struct'

naga/src/front/wgsl/error.rs

@@ -299,6 +299,7 @@ impl<'a> Error<'a> {
  Token::Arrow => "->".to_string(),
  Token::Unknown(c) => format!("unknown ('{c}')"),
  Token::Trivia => "trivia".to_string(),
+ Token::Comment(s) => format!("documentation ('{s}')"),
  Token::End => "end".to_string(),
  }
  }

naga/src/front/wgsl/parse/ast.rs

@@ -186,6 +186,8 @@ pub struct StructMember<'a> {
 pub struct Struct<'a> {
  pub name: Ident<'a>,
  pub members: Vec<StructMember<'a>>,
+ // TODO: Make it optional ? Store Span ? Add it to other elements
+ pub comments: Vec<&'a str>,
 }
 
 #[derive(Debug)]

naga/src/front/wgsl/parse/lexer.rs

@@ -22,6 +22,7 @@ pub enum Token<'a> {
  Arrow,
  Unknown(char),
  Trivia,
+ Comment(&'a str),
  End,
 }
 
@@ -81,8 +82,13 @@ fn consume_token(input: &str, generic: bool) -> (Token<'_>, &str) {
  let og_chars = chars.as_str();
  match chars.next() {
  Some('/') => {
- let _ = chars.position(is_comment_end);
- (Token::Trivia, chars.as_str())
+ let og_chars = chars.as_str();
+ let documentation = if let Some(end_position) = chars.position(is_comment_end) {
+ &og_chars[..end_position]
+ } else {
+ og_chars
+ };
+ (Token::Comment(documentation), chars.as_str())
  }
  Some('*') => {
  let mut depth = 1;
@@ -238,7 +244,7 @@ impl<'a> Lexer<'a> {
  loop {
  // Eat all trivia because `next` doesn't eat trailing trivia.
  let (token, rest) = consume_token(self.input, false);
- if let Token::Trivia = token {
+ if let Token::Trivia | Token::Comment(_) = token {
  self.input = rest;
  } else {
  return self.current_byte_offset();
@@ -253,7 +259,27 @@ impl<'a> Lexer<'a> {
  (token, rest)
  }
 
- const fn current_byte_offset(&self) -> usize {
+ pub(in crate::front::wgsl) fn start_byte_offset_and_aggregate_comment(
+ &'a mut self,
+ comments: &mut Vec<Span>,
+ ) -> usize {
+ loop {
+ let start = self.current_byte_offset();
+ // Eat all trivia because `next` doesn't eat trailing trivia.
+ let (token, rest) = consume_token(self.input, false);
+ if let Token::Comment(_) = token {
+ let next = self.current_byte_offset();
+ comments.push(Span::new(start as u32, next as u32));
+ self.input = rest;
+ } else if let Token::Trivia = token {
+ self.input = rest;
+ } else {
+ return self.current_byte_offset();
+ }
+ }
+ }
+
+ pub const fn current_byte_offset(&self) -> usize {
  self.source.len() - self.input.len()
  }
 
@@ -288,7 +314,7 @@ impl<'a> Lexer<'a> {
  let (token, rest) = consume_token(self.input, generic);
  self.input = rest;
  match token {
- Token::Trivia => start_byte_offset = self.current_byte_offset(),
+ Token::Trivia | Token::Comment(_) => start_byte_offset = self.current_byte_offset(),
  _ => {
  self.last_end_offset = self.current_byte_offset();
  return (token, self.span_from(start_byte_offset));

naga/src/front/wgsl/parse/mod.rs

@@ -1,3 +1,5 @@
+use std::ops::Index;
+
 use crate::front::wgsl::error::{Error, ExpectedToken};
 use crate::front::wgsl::parse::lexer::{Lexer, Token};
 use crate::front::wgsl::parse::number::Number;
@@ -2172,6 +2174,9 @@ impl Parser {
  lexer: &mut Lexer<'a>,
  out: &mut ast::TranslationUnit<'a>,
  ) -> Result<(), Error<'a>> {
+ // Save a lexer to be able to backtrack comments if need be.
+ let mut lexer_comments = lexer.clone();
+
  // read attributes
  let mut binding = None;
  let mut stage = ParsedAttribute::default();
@@ -2251,7 +2256,6 @@ impl Parser {
  (_, word_span) => return Err(Error::UnknownAttribute(word_span)),
  }
  }
-
  let attrib_span = self.pop_rule_span(lexer);
  match (bind_group.value, bind_index.value) {
  (Some(group), Some(index)) => {
@@ -2267,13 +2271,27 @@ impl Parser {
 
  // read item
  let start = lexer.start_byte_offset();
- let kind = match lexer.next() {
+ let token_span = lexer.next();
+
+ let kind = match token_span {
  (Token::Separator(';'), _) => None,
  (Token::Word("struct"), _) => {
  let name = lexer.next_ident()?;
 
  let members = self.struct_body(lexer, &mut ctx)?;
- Some(ast::GlobalDeclKind::Struct(ast::Struct { name, members }))
+
+ let mut comments = Vec::new();
+ lexer_comments.start_byte_offset_and_aggregate_comment(&mut comments);
+
+ let comments = comments
+ .into_iter()
+ .map(|comment_span| lexer.source.index(comment_span))
+ .collect();
+ Some(ast::GlobalDeclKind::Struct(ast::Struct {
+ name,
+ members,
+ comments,
+ }))
  }
  (Token::Word("alias"), _) => {
  let name = lexer.next_ident()?;