update TypeMapped ast

Author: xuhuanzy

crates/emmylua_parser/src/grammar/doc/test.rs

@@ -3076,21 +3076,18 @@ Syntax(Chunk)@0..102
     fn test_generic_in() {
         let code: &str = r#"
         ---@alias Pick1<T, K extends keyof T> {
-        ---    [P in K]: T[P];
+        ---  readonly [P in K]+?: T[P];
         ---}
         "#;
         // print_ast(code);
-        // print_ast(r#"
-        // ---@alias Pick1<T: table>
-        // "#);
         let result = r#"
-Syntax(Chunk)@0..101
-  Syntax(Block)@0..101
+Syntax(Chunk)@0..110
+  Syntax(Block)@0..110
     Token(TkEndOfLine)@0..1 "\n"
     Token(TkWhitespace)@1..9 "        "
-    Syntax(Comment)@9..92
+    Syntax(Comment)@9..101
       Token(TkDocStart)@9..13 "---@"
-      Syntax(DocTagAlias)@13..92
+      Syntax(DocTagAlias)@13..101
         Token(TkTagAlias)@13..18 "alias"
         Token(TkWhitespace)@18..19 " "
         Token(TkName)@19..24 "Pick1"
@@ -3112,39 +3109,42 @@ Syntax(Chunk)@0..101
                 Token(TkName)@44..45 "T"
           Token(TkGt)@45..46 ">"
         Token(TkWhitespace)@46..47 " "
-        Syntax(TypeMapped)@47..92
+        Syntax(TypeMapped)@47..101
           Token(TkLeftBrace)@47..48 "{"
           Token(TkEndOfLine)@48..49 "\n"
           Token(TkWhitespace)@49..57 "        "
-          Token(TkDocContinue)@57..64 "---    "
-          Syntax(DocMappedKey)@64..72
-            Token(TkLeftBracket)@64..65 "["
-            Syntax(DocGenericParameter)@65..71
-              Token(TkName)@65..66 "P"
-              Token(TkWhitespace)@66..67 " "
-              Token(TkIn)@67..69 "in"
-              Token(TkWhitespace)@69..70 " "
-              Syntax(TypeName)@70..71
-                Token(TkName)@70..71 "K"
-            Token(TkRightBracket)@71..72 "]"
-          Token(TkColon)@72..73 ":"
-          Token(TkWhitespace)@73..74 " "
-          Syntax(TypeIndexAccess)@74..78
-            Syntax(TypeName)@74..75
-              Token(TkName)@74..75 "T"
-            Token(TkLeftBracket)@75..76 "["
-            Syntax(TypeName)@76..77
-              Token(TkName)@76..77 "P"
-            Token(TkRightBracket)@77..78 "]"
-          Token(TkSemicolon)@78..79 ";"
-          Token(TkEndOfLine)@79..80 "\n"
-          Token(TkWhitespace)@80..88 "        "
-          Token(TkDocContinue)@88..91 "---"
-          Token(TkRightBrace)@91..92 "}"
-    Token(TkEndOfLine)@92..93 "\n"
-    Token(TkWhitespace)@93..101 "        "
+          Token(TkDocContinue)@57..62 "---  "
+          Token(TkDocReadonly)@62..70 "readonly"
+          Token(TkWhitespace)@70..71 " "
+          Syntax(DocMappedKey)@71..79
+            Token(TkLeftBracket)@71..72 "["
+            Syntax(DocGenericParameter)@72..78
+              Token(TkName)@72..73 "P"
+              Token(TkWhitespace)@73..74 " "
+              Token(TkIn)@74..76 "in"
+              Token(TkWhitespace)@76..77 " "
+              Syntax(TypeName)@77..78
+                Token(TkName)@77..78 "K"
+            Token(TkRightBracket)@78..79 "]"
+          Token(TkPlus)@79..80 "+"
+          Token(TkDocQuestion)@80..81 "?"
+          Token(TkColon)@81..82 ":"
+          Token(TkWhitespace)@82..83 " "
+          Syntax(TypeIndexAccess)@83..87
+            Syntax(TypeName)@83..84
+              Token(TkName)@83..84 "T"
+            Token(TkLeftBracket)@84..85 "["
+            Syntax(TypeName)@85..86
+              Token(TkName)@85..86 "P"
+            Token(TkRightBracket)@86..87 "]"
+          Token(TkSemicolon)@87..88 ";"
+          Token(TkEndOfLine)@88..89 "\n"
+          Token(TkWhitespace)@89..97 "        "
+          Token(TkDocContinue)@97..100 "---"
+          Token(TkRightBrace)@100..101 "}"
+    Token(TkEndOfLine)@101..102 "\n"
+    Token(TkWhitespace)@102..110 "        "
 "#;
-
         assert_ast_eq!(code, result);
     }
 }

crates/emmylua_parser/src/grammar/doc/types.rs

@@ -3,7 +3,7 @@ use crate::{
     grammar::DocParseResult,
     kind::{LuaOpKind, LuaSyntaxKind, LuaTokenKind, LuaTypeBinaryOperator, LuaTypeUnaryOperator},
     lexer::LuaDocLexerState,
-    parser::{CompleteMarker, LuaDocParser, LuaDocParserState, MarkerEventContainer},
+    parser::{CompleteMarker, LuaDocParser, LuaDocParserState, Marker, MarkerEventContainer},
     parser_error::LuaParseError,
 };
 
@@ -142,13 +142,7 @@ fn parse_simple_type(p: &mut LuaDocParser) -> DocParseResult {
 
 fn parse_primary_type(p: &mut LuaDocParser) -> DocParseResult {
     match p.current_token() {
-        LuaTokenKind::TkLeftBrace => {
-            if is_mapped_type_start(p) {
-                parse_mapped_type(p)
-            } else {
-                parse_object_type(p)
-            }
-        }
+        LuaTokenKind::TkLeftBrace => parse_object_or_mapped_type(p),
         LuaTokenKind::TkLeftBracket => parse_tuple_type(p),
         LuaTokenKind::TkLeftParen => parse_paren_type(p),
         LuaTokenKind::TkString
@@ -171,87 +165,45 @@ fn parse_primary_type(p: &mut LuaDocParser) -> DocParseResult {
     }
 }
 
-/// 判断是否是映射类型.
-///
-/// 这里与`TS`保持一致, 即第一个 key 必须为`[]` 且内部必须包含 `in`.
-fn is_mapped_type_start(p: &LuaDocParser) -> bool {
-    let text = p.origin_text();
-    let start = p.current_token_range().end_offset();
-    let rest = match text.get(start..) {
-        Some(value) => value,
-        None => return false,
-    };
-
-    let mut trimmed = rest.trim_start_matches(char::is_whitespace);
-
-    if let Some(after_dashes) = trimmed.strip_prefix("---") {
-        trimmed = after_dashes.trim_start_matches(char::is_whitespace);
-    }
-
-    if !trimmed.starts_with('[') {
-        return false;
-    }
-
-    let after_left_bracket = &trimmed[1..];
-    let rb_pos = match after_left_bracket.find(']') {
-        Some(pos) => pos,
-        None => return false,
-    };
-
-    let content = &after_left_bracket[..rb_pos];
-    let mut seen_identifier = false;
-    let mut token_start: Option<usize> = None;
+// [Property in Type]: Type;
+// [Property in keyof Type]: Type;
+fn parse_mapped_type(p: &mut LuaDocParser, m: Marker) -> DocParseResult {
+    p.set_parser_state(LuaDocParserState::Mapped);
 
-    for (idx, ch) in content.char_indices() {
-        if ch == '_' || ch.is_alphanumeric() {
-            if token_start.is_none() {
-                token_start = Some(idx);
-            }
-            continue;
+    match p.current_token() {
+        LuaTokenKind::TkPlus | LuaTokenKind::TkMinus => {
+            p.bump();
+            expect_token(p, LuaTokenKind::TkDocReadonly)?;
         }
-
-        if let Some(start_idx) = token_start.take() {
-            let token = &content[start_idx..idx];
-            if token == "in" {
-                return seen_identifier;
-            }
-            seen_identifier = true;
+        LuaTokenKind::TkDocReadonly => {
+            p.bump();
         }
-    }
-
-    if let Some(start_idx) = token_start {
-        if &content[start_idx..] == "in" {
-            return seen_identifier;
+        LuaTokenKind::TkLeftBracket => {}
+        _ => {
+            return Err(LuaParseError::doc_error_from(
+                &t!("expect mapped field"),
+                p.current_token_range(),
+            ));
         }
     }
 
-    false
-}
-
-// [Property in Type]: Type;
-// [Property in keyof Type]: Type;
-fn parse_mapped_type(p: &mut LuaDocParser) -> DocParseResult {
-    p.set_parser_state(LuaDocParserState::Mapped);
-    let m = p.mark(LuaSyntaxKind::TypeMapped);
-    p.bump();
-
-    if p.current_token() != LuaTokenKind::TkLeftBracket {
-        return Err(LuaParseError::doc_error_from(
-            &t!("expect mapped field"),
-            p.current_token_range(),
-        ));
-    }
-    // key
     parse_mapped_key(p)?;
-    if p.current_token() == LuaTokenKind::TkDocQuestion {
-        p.bump();
+
+    match p.current_token() {
+        LuaTokenKind::TkPlus | LuaTokenKind::TkMinus => {
+            p.bump();
+            expect_token(p, LuaTokenKind::TkDocQuestion)?;
+        }
+        LuaTokenKind::TkDocQuestion => {
+            p.bump();
+        }
+        _ => {}
     }
+
     expect_token(p, LuaTokenKind::TkColon)?;
 
-    // value
     parse_type(p)?;
 
-    // end
     expect_token(p, LuaTokenKind::TkSemicolon)?;
     expect_token(p, LuaTokenKind::TkRightBrace)?;
 
@@ -281,11 +233,27 @@ fn parse_mapped_key(p: &mut LuaDocParser) -> DocParseResult {
 
 // { <name>: <type>, ... }
 // { <name> : <type>, ... }
-fn parse_object_type(p: &mut LuaDocParser) -> DocParseResult {
-    let m = p.mark(LuaSyntaxKind::TypeObject);
+fn parse_object_or_mapped_type(p: &mut LuaDocParser) -> DocParseResult {
+    p.set_lexer_state(LuaDocLexerState::Mapped);
+    let mut m = p.mark(LuaSyntaxKind::TypeObject);
     p.bump();
+    p.set_lexer_state(LuaDocLexerState::Normal);
 
     if p.current_token() != LuaTokenKind::TkRightBrace {
+        match p.current_token() {
+            LuaTokenKind::TkPlus | LuaTokenKind::TkMinus | LuaTokenKind::TkDocReadonly => {
+                m.set_kind(p, LuaSyntaxKind::TypeMapped);
+                return parse_mapped_type(p, m);
+            }
+            LuaTokenKind::TkLeftBracket => {
+                if is_mapped_type(p) {
+                    m.set_kind(p, LuaSyntaxKind::TypeMapped);
+                    return parse_mapped_type(p, m);
+                }
+            }
+            _ => {}
+        }
+
         parse_typed_field(p)?;
         while p.current_token() == LuaTokenKind::TkComma {
             p.bump();
@@ -301,6 +269,24 @@ fn parse_object_type(p: &mut LuaDocParser) -> DocParseResult {
     Ok(m.complete(p))
 }
 
+/// 判断是否为 mapped type
+fn is_mapped_type(p: &LuaDocParser) -> bool {
+    let mut lexer = p.lexer.clone();
+
+    loop {
+        let kind = lexer.lex();
+        match kind {
+            LuaTokenKind::TkIn => return true,
+            LuaTokenKind::TkLeftBracket | LuaTokenKind::TkRightBracket => return false,
+            LuaTokenKind::TkEof => return false,
+            LuaTokenKind::TkWhitespace
+            | LuaTokenKind::TkDocContinue
+            | LuaTokenKind::TkEndOfLine => {}
+            _ => {}
+        }
+    }
+}
+
 // <name> : <type>
 // [<number>] : <type>
 // [<string>] : <type>

crates/emmylua_parser/src/lexer/lua_doc_lexer.rs

@@ -27,6 +27,7 @@ pub enum LuaDocLexerState {
     Source,
     NormalDescription,
     CastExpr,
+    Mapped,
 }
 
 impl LuaDocLexer<'_> {
@@ -73,6 +74,7 @@ impl LuaDocLexer<'_> {
             LuaDocLexerState::Source => self.lex_source(),
             LuaDocLexerState::NormalDescription => self.lex_normal_description(),
             LuaDocLexerState::CastExpr => self.lex_cast_expr(),
+            LuaDocLexerState::Mapped => self.lex_mapped(),
         }
     }
 
@@ -581,6 +583,24 @@ impl LuaDocLexer<'_> {
             _ => self.lex_normal(),
         }
     }
+
+    fn lex_mapped(&mut self) -> LuaTokenKind {
+        let reader = self.reader.as_mut().unwrap();
+        match reader.current_char() {
+            ch if is_doc_whitespace(ch) => {
+                reader.eat_while(is_doc_whitespace);
+                LuaTokenKind::TkWhitespace
+            }
+            ch if is_name_start(ch) => {
+                let (text, _) = read_doc_name(reader);
+                match text {
+                    "readonly" => LuaTokenKind::TkDocReadonly,
+                    _ => LuaTokenKind::TkName,
+                }
+            }
+            _ => self.lex_normal(),
+        }
+    }
 }
 
 fn to_tag(text: &str) -> LuaTokenKind {

crates/emmylua_parser/src/parser/lua_doc_parser.rs

@@ -91,7 +91,7 @@ impl<'b> LuaDocParser<'_, 'b> {
         }
 
         match self.lexer.state {
-            LuaDocLexerState::Normal | LuaDocLexerState::Version => {
+            LuaDocLexerState::Normal | LuaDocLexerState::Version | LuaDocLexerState::Mapped => {
                 while matches!(
                     self.current_token,
                     LuaTokenKind::TkDocContinue