Skip to main content

libperl_macrogen/
parser.rs

1//! C言語パーサー
2//!
3//! tinyccのparser部分に相当。再帰下降パーサーで実装。
4
5use std::collections::{HashMap, HashSet};
6
7use crate::ast::*;
8use crate::error::{CompileError, ParseError, Result};
9use crate::intern::{InternedStr, StringInterner};
10use crate::macro_infer::detect_assert_kind;
11use crate::preprocessor::Preprocessor;
12use crate::lexer::{Lexer, LookupOnly};
13use crate::source::{FileId, SourceLocation};
14use crate::token::{MacroBeginInfo, MacroInvocationKind, Token, TokenId, TokenKind};
15use crate::token_source::{TokenSliceRef, TokenSource};
16
17/// マクロ展開コンテキスト
18///
19/// パース中のマクロ展開状態を追跡する。
20/// MacroBegin マーカーを見つけたらプッシュし、MacroEnd を見つけたらポップする。
21#[derive(Debug, Default)]
22pub struct MacroContext {
23    /// 現在のマクロ展開スタック（外側から内側へ）
24    stack: Vec<MacroBeginInfo>,
25}
26
27impl MacroContext {
28    /// 新しいコンテキストを作成
29    pub fn new() -> Self {
30        Self { stack: Vec::new() }
31    }
32
33    /// マクロ展開を開始
34    pub fn push(&mut self, info: MacroBeginInfo) {
35        self.stack.push(info);
36    }
37
38    /// マクロ展開を終了
39    pub fn pop(&mut self) -> Option<MacroBeginInfo> {
40        self.stack.pop()
41    }
42
43    /// 現在マクロ展開中かどうか
44    pub fn is_in_macro(&self) -> bool {
45        !self.stack.is_empty()
46    }
47
48    /// 現在のマクロ展開情報から MacroExpansionInfo を構築
49    pub fn build_macro_info(&self, interner: &StringInterner) -> Option<MacroExpansionInfo> {
50        if self.stack.is_empty() {
51            return None;
52        }
53
54        let mut info = MacroExpansionInfo::new();
55        for begin_info in &self.stack {
56            let args = match &begin_info.kind {
57                crate::token::MacroInvocationKind::Object => None,
58                crate::token::MacroInvocationKind::Function { args } => {
59                    // トークン列を文字列に変換
60                    Some(args.iter().map(|arg_tokens| {
61                        arg_tokens.iter()
62                            .map(|t| t.kind.format(interner))
63                            .collect::<Vec<_>>()
64                            .join(" ")
65                    }).collect())
66                }
67            };
68            info.push(MacroInvocation {
69                name: begin_info.macro_name,
70                call_loc: begin_info.call_loc.clone(),
71                args,
72            });
73        }
74        Some(info)
75    }
76
77    /// 展開スタックの深さ
78    pub fn depth(&self) -> usize {
79        self.stack.len()
80    }
81}
82
83/// パーサー
84///
85/// 汎用のトークンソースからC言語をパースする。
86/// `S` は `TokenSource` トレイトを実装する任意の型。
87pub struct Parser<'a, S: TokenSource> {
88    source: &'a mut S,
89    current: Token,
90    /// typedef名のセット
91    typedefs: HashSet<InternedStr>,
92    /// マクロ展開コンテキスト
93    macro_ctx: MacroContext,
94    /// マクロマーカーを処理するか（emit_markers=true の場合に true にする）
95    handle_macro_markers: bool,
96    /// do-while 文の末尾セミコロンを省略可能にするフラグ
97    allow_missing_semi: bool,
98    /// パース中に検出した関数呼び出しの数
99    pub function_call_count: usize,
100    /// パース中に検出したポインタデリファレンスの数
101    pub deref_count: usize,
102    /// マクロ仮引数の辞書（マクロ本体パース時のみ使用）
103    /// key: 仮引数名, value: パラメータインデックス
104    generic_params: HashMap<InternedStr, usize>,
105    /// パース中に型として使用が検出された generic param
106    detected_type_params: HashSet<InternedStr>,
107}
108
109/// Preprocessor 専用の後方互換コンストラクタ
110impl<'a> Parser<'a, Preprocessor> {
111    /// 新しいパーサーを作成（Preprocessor専用）
112    pub fn new(pp: &'a mut Preprocessor) -> Result<Self> {
113        Self::from_source(pp)
114    }
115
116    /// ストリーミング形式でパース
117    ///
118    /// 各宣言をパースするたびにコールバックを呼び出す。
119    /// パースエラーが発生した場合はコールバックを呼ばずにエラーを返す。
120    /// コールバックが `ControlFlow::Break(())` を返した場合はループを終了。
121    pub fn parse_each<F>(&mut self, mut callback: F) -> Result<()>
122    where
123        F: FnMut(&ExternalDecl, &crate::source::SourceLocation, &std::path::Path, &StringInterner) -> std::ops::ControlFlow<()>,
124    {
125        while !self.is_eof() {
126            let loc = self.current.loc.clone();
127            let decl = self.parse_external_decl()?;
128            let path = self.source.files().get_path(loc.file_id);
129            let interner = self.source.interner();
130            if callback(&decl, &loc, path, interner).is_break() {
131                break;
132            }
133        }
134        Ok(())
135    }
136
137    /// ストリーミング形式でパース（Preprocessor アクセス付き）
138    ///
139    /// `parse_each` と同様だが、コールバックに Preprocessor への可変参照も渡す。
140    /// マクロ呼び出しコールバック（MacroCallWatcher など）にアクセスする場合に使用。
141    /// パースエラーが発生した場合はコールバックを呼ばずにエラーを返す。
142    pub fn parse_each_with_pp<F>(&mut self, mut callback: F) -> Result<()>
143    where
144        F: FnMut(&ExternalDecl, &crate::source::SourceLocation, &std::path::Path, &mut Preprocessor) -> std::ops::ControlFlow<()>,
145    {
146        while !self.is_eof() {
147            let loc = self.current.loc.clone();
148            let decl = self.parse_external_decl()?;
149            let path = self.source.files().get_path(loc.file_id).to_path_buf();
150            if callback(&decl, &loc, &path, self.source).is_break() {
151                break;
152            }
153        }
154        Ok(())
155    }
156}
157
158/// 汎用のトークンソースに対するパーサー実装
159impl<'a, S: TokenSource> Parser<'a, S> {
160    /// トークンソースからパーサーを作成
161    pub fn from_source(source: &'a mut S) -> Result<Self> {
162        // GCC builtin types を事前登録
163        let mut typedefs = HashSet::new();
164        typedefs.insert(source.interner_mut().intern("__builtin_va_list"));
165
166        let mut parser = Self {
167            source,
168            current: Token::default(),
169            typedefs,
170            macro_ctx: MacroContext::new(),
171            handle_macro_markers: false,
172            allow_missing_semi: false,
173            function_call_count: 0,
174            deref_count: 0,
175            generic_params: HashMap::new(),
176            detected_type_params: HashSet::new(),
177        };
178        // マーカーをスキップして最初のトークンを取得
179        parser.current = parser.inner_next_token()?;
180
181        Ok(parser)
182    }
183
184    /// トークンソースからパーサーを作成（既存のtypedef情報を引き継ぐ）
185    pub fn from_source_with_typedefs(source: &'a mut S, typedefs: HashSet<InternedStr>) -> Result<Self> {
186        let mut parser = Self {
187            source,
188            current: Token::default(),
189            typedefs,
190            macro_ctx: MacroContext::new(),
191            handle_macro_markers: false,
192            allow_missing_semi: false,
193            function_call_count: 0,
194            deref_count: 0,
195            generic_params: HashMap::new(),
196            detected_type_params: HashSet::new(),
197        };
198        // マーカーをスキップして最初のトークンを取得
199        parser.current = parser.inner_next_token()?;
200
201        Ok(parser)
202    }
203
204    /// マクロマーカー処理を有効にする
205    ///
206    /// Note: 既に current にマーカートークンがある場合はスキップする
207    pub fn set_handle_macro_markers(&mut self, enabled: bool) -> Result<()> {
208        self.handle_macro_markers = enabled;
209
210        // 既に current にマーカートークンがある場合はスキップ
211        if enabled {
212            while matches!(
213                self.current.kind,
214                TokenKind::MacroBegin(_) | TokenKind::MacroEnd(_)
215            ) {
216                match &self.current.kind {
217                    TokenKind::MacroBegin(info) => {
218                        self.macro_ctx.push((**info).clone());
219                    }
220                    TokenKind::MacroEnd(_) => {
221                        self.macro_ctx.pop();
222                    }
223                    _ => {}
224                }
225                self.current = self.source.next_token()?;
226            }
227        }
228        Ok(())
229    }
230
231    /// StringInterner への参照を取得
232    pub fn interner(&self) -> &crate::intern::StringInterner {
233        self.source.interner()
234    }
235
236    /// typedef名のセットを取得
237    pub fn typedefs(&self) -> &HashSet<InternedStr> {
238        &self.typedefs
239    }
240
241    /// 翻訳単位をパース
242    pub fn parse(&mut self) -> Result<TranslationUnit> {
243        let mut decls = Vec::new();
244
245        while !self.is_eof() {
246            let decl = self.parse_external_decl()?;
247            decls.push(decl);
248        }
249
250        Ok(TranslationUnit { decls })
251    }
252
253    /// 式のみをパース
254    ///
255    /// マクロ本体など、式だけをパースしたい場合に使用
256    pub fn parse_expr_only(&mut self) -> Result<Expr> {
257        self.parse_expr()
258    }
259
260    /// 文をパース（末尾セミコロン省略可能）
261    ///
262    /// マクロ body のパースなど、do-while の末尾セミコロンが
263    /// 省略されている場合に使用する。
264    pub fn parse_stmt_allow_missing_semi(&mut self) -> Result<Stmt> {
265        self.allow_missing_semi = true;
266        let result = self.parse_stmt();
267        self.allow_missing_semi = false;
268        result
269    }
270
271    /// 外部宣言をパース
272    fn parse_external_decl(&mut self) -> Result<ExternalDecl> {
273        let comments = self.current.leading_comments.clone();
274        let loc = self.current.loc.clone();
275        let is_target = self.source.is_file_in_target(loc.file_id);
276
277        // 宣言指定子をパース
278        let specs = self.parse_decl_specs()?;
279
280        // ; のみの場合（構造体宣言など）
281        if self.check(&TokenKind::Semi) {
282            self.advance()?;
283            return Ok(ExternalDecl::Declaration(Declaration {
284                specs,
285                declarators: Vec::new(),
286                info: NodeInfo::new(loc),
287                comments,
288                is_target,
289            }));
290        }
291
292        // 宣言子をパース
293        let declarator = self.parse_declarator()?;
294
295        // __attribute__ をスキップ
296        self.try_skip_attribute()?;
297
298        // 関数定義かどうかを判定
299        // 関数定義: 宣言子の後に { が来る
300        if self.check(&TokenKind::LBrace) {
301            // 本体パース前のカウントを記録
302            let call_count_before = self.function_call_count;
303            let deref_count_before = self.deref_count;
304
305            let body = self.parse_compound_stmt()?;
306
307            // 差分が関数本体のカウント
308            let function_call_count = self.function_call_count - call_count_before;
309            let deref_count = self.deref_count - deref_count_before;
310
311            return Ok(ExternalDecl::FunctionDef(FunctionDef {
312                specs,
313                declarator,
314                body,
315                info: NodeInfo::new(loc),
316                comments,
317                is_target,
318                function_call_count,
319                deref_count,
320            }));
321        }
322
323        // 宣言の続きをパース
324        let mut declarators = Vec::new();
325
326        // 最初の宣言子（初期化子あり）
327        let init = if self.check(&TokenKind::Eq) {
328            self.advance()?;
329            Some(self.parse_initializer()?)
330        } else {
331            None
332        };
333        declarators.push(InitDeclarator { declarator, init });
334
335        // 追加の宣言子
336        while self.check(&TokenKind::Comma) {
337            self.advance()?;
338            let declarator = self.parse_declarator()?;
339            let init = if self.check(&TokenKind::Eq) {
340                self.advance()?;
341                Some(self.parse_initializer()?)
342            } else {
343                None
344            };
345            declarators.push(InitDeclarator { declarator, init });
346        }
347
348        // GCC拡張: 宣言の最後の __attribute__((...)) をスキップ
349        self.try_skip_attribute()?;
350
351        self.expect(&TokenKind::Semi)?;
352
353        // typedef の場合、名前を登録
354        if specs.storage == Some(StorageClass::Typedef) {
355            for d in &declarators {
356                if let Some(name) = d.declarator.name {
357                    self.typedefs.insert(name);
358                }
359            }
360        }
361
362        Ok(ExternalDecl::Declaration(Declaration {
363            specs,
364            declarators,
365            info: NodeInfo::new(loc),
366            comments,
367            is_target,
368        }))
369    }
370
371    /// 宣言指定子をパース
372    fn parse_decl_specs(&mut self) -> Result<DeclSpecs> {
373        let mut specs = DeclSpecs::default();
374
375        loop {
376            match &self.current.kind {
377                // GCC拡張: __extension__ は無視（TinyCC方式）
378                TokenKind::KwExtension => {
379                    self.advance()?;
380                    continue;
381                }
382                // C11/GCC: _Thread_local, __thread は無視（TinyCC方式）
383                TokenKind::KwThreadLocal | TokenKind::KwThread => {
384                    self.advance()?;
385                    continue;
386                }
387                // ストレージクラス
388                TokenKind::KwTypedef => {
389                    specs.storage = Some(StorageClass::Typedef);
390                    self.advance()?;
391                }
392                TokenKind::KwExtern => {
393                    specs.storage = Some(StorageClass::Extern);
394                    self.advance()?;
395                }
396                TokenKind::KwStatic => {
397                    specs.storage = Some(StorageClass::Static);
398                    self.advance()?;
399                }
400                TokenKind::KwAuto => {
401                    specs.storage = Some(StorageClass::Auto);
402                    self.advance()?;
403                }
404                TokenKind::KwRegister => {
405                    specs.storage = Some(StorageClass::Register);
406                    self.advance()?;
407                }
408                // inline
409                TokenKind::KwInline | TokenKind::KwInline2 | TokenKind::KwInline3 => {
410                    specs.is_inline = true;
411                    self.advance()?;
412                }
413                // 型修飾子
414                TokenKind::KwConst | TokenKind::KwConst2 | TokenKind::KwConst3 => {
415                    specs.qualifiers.is_const = true;
416                    self.advance()?;
417                }
418                TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3 => {
419                    specs.qualifiers.is_volatile = true;
420                    self.advance()?;
421                }
422                TokenKind::KwRestrict | TokenKind::KwRestrict2 | TokenKind::KwRestrict3 => {
423                    specs.qualifiers.is_restrict = true;
424                    self.advance()?;
425                }
426                TokenKind::KwAtomic => {
427                    specs.qualifiers.is_atomic = true;
428                    self.advance()?;
429                }
430                // 型指定子
431                TokenKind::KwVoid => {
432                    specs.type_specs.push(TypeSpec::Void);
433                    self.advance()?;
434                }
435                TokenKind::KwChar => {
436                    specs.type_specs.push(TypeSpec::Char);
437                    self.advance()?;
438                }
439                TokenKind::KwShort => {
440                    specs.type_specs.push(TypeSpec::Short);
441                    self.advance()?;
442                }
443                TokenKind::KwInt => {
444                    specs.type_specs.push(TypeSpec::Int);
445                    self.advance()?;
446                }
447                TokenKind::KwLong => {
448                    specs.type_specs.push(TypeSpec::Long);
449                    self.advance()?;
450                }
451                TokenKind::KwFloat => {
452                    specs.type_specs.push(TypeSpec::Float);
453                    self.advance()?;
454                }
455                TokenKind::KwDouble => {
456                    specs.type_specs.push(TypeSpec::Double);
457                    self.advance()?;
458                }
459                TokenKind::KwSigned | TokenKind::KwSigned2 => {
460                    specs.type_specs.push(TypeSpec::Signed);
461                    self.advance()?;
462                }
463                TokenKind::KwUnsigned => {
464                    specs.type_specs.push(TypeSpec::Unsigned);
465                    self.advance()?;
466                }
467                TokenKind::KwBool | TokenKind::KwBool2 => {
468                    specs.type_specs.push(TypeSpec::Bool);
469                    self.advance()?;
470                }
471                TokenKind::KwComplex => {
472                    specs.type_specs.push(TypeSpec::Complex);
473                    self.advance()?;
474                }
475                // GCC拡張浮動小数点型
476                TokenKind::KwFloat16 => {
477                    specs.type_specs.push(TypeSpec::Float16);
478                    self.advance()?;
479                }
480                TokenKind::KwFloat32 => {
481                    specs.type_specs.push(TypeSpec::Float32);
482                    self.advance()?;
483                }
484                TokenKind::KwFloat64 => {
485                    specs.type_specs.push(TypeSpec::Float64);
486                    self.advance()?;
487                }
488                TokenKind::KwFloat128 => {
489                    specs.type_specs.push(TypeSpec::Float128);
490                    self.advance()?;
491                }
492                TokenKind::KwFloat32x => {
493                    specs.type_specs.push(TypeSpec::Float32x);
494                    self.advance()?;
495                }
496                TokenKind::KwFloat64x => {
497                    specs.type_specs.push(TypeSpec::Float64x);
498                    self.advance()?;
499                }
500                // GCC拡張: 128ビット整数
501                TokenKind::KwInt128 => {
502                    specs.type_specs.push(TypeSpec::Int128);
503                    self.advance()?;
504                }
505                // typeof
506                TokenKind::KwTypeof | TokenKind::KwTypeof2 | TokenKind::KwTypeof3 => {
507                    self.advance()?;
508                    self.expect(&TokenKind::LParen)?;
509                    let expr = self.parse_expr()?;
510                    self.expect(&TokenKind::RParen)?;
511                    specs.type_specs.push(TypeSpec::TypeofExpr(Box::new(expr)));
512                }
513                // 構造体・共用体・列挙
514                TokenKind::KwStruct => {
515                    specs.type_specs.push(self.parse_struct_or_union(true)?);
516                }
517                TokenKind::KwUnion => {
518                    specs.type_specs.push(self.parse_struct_or_union(false)?);
519                }
520                TokenKind::KwEnum => {
521                    specs.type_specs.push(self.parse_enum()?);
522                }
523                // GCC拡張: __attribute__((...)) をスキップ
524                TokenKind::KwAttribute | TokenKind::KwAttribute2 => {
525                    self.skip_attribute()?;
526                }
527                // typedef名 or 検出済みの generic 型パラメータ
528                TokenKind::Ident(id) if self.typedefs.contains(id) || self.detected_type_params.contains(id) => {
529                    let id = *id;
530                    specs.type_specs.push(TypeSpec::TypedefName(id));
531                    self.advance()?;
532                }
533                // それ以外はループ終了
534                _ => break,
535            }
536        }
537
538        Ok(specs)
539    }
540
541    /// 構造体/共用体をパース
542    fn parse_struct_or_union(&mut self, is_struct: bool) -> Result<TypeSpec> {
543        let loc = self.current.loc.clone();
544        self.advance()?; // struct/union
545
546        // GCC拡張: struct __attribute__((...)) name { ... }
547        self.try_skip_attribute()?;
548
549        // 名前（オプション）
550        let name = self.current_ident();
551        if name.is_some() {
552            self.advance()?;
553        }
554
555        // メンバーリスト（オプション）
556        let members = if self.check(&TokenKind::LBrace) {
557            self.advance()?;
558            let mut members = Vec::new();
559            while !self.check(&TokenKind::RBrace) {
560                members.push(self.parse_struct_member()?);
561            }
562            self.expect(&TokenKind::RBrace)?;
563            Some(members)
564        } else {
565            None
566        };
567
568        let spec = StructSpec { name, members, loc };
569        if is_struct {
570            Ok(TypeSpec::Struct(spec))
571        } else {
572            Ok(TypeSpec::Union(spec))
573        }
574    }
575
576    /// 構造体メンバーをパース
577    fn parse_struct_member(&mut self) -> Result<StructMember> {
578        let specs = self.parse_decl_specs()?;
579        let mut declarators = Vec::new();
580
581        loop {
582            let declarator = if self.check(&TokenKind::Colon) {
583                None
584            } else if self.check(&TokenKind::Semi) {
585                None
586            } else {
587                Some(self.parse_declarator()?)
588            };
589
590            // GCC拡張: 宣言子の後の __attribute__ をスキップ
591            self.try_skip_attribute()?;
592
593            let bitfield = if self.check(&TokenKind::Colon) {
594                self.advance()?;
595                Some(Box::new(self.parse_conditional_expr()?))
596            } else {
597                None
598            };
599
600            declarators.push(StructDeclarator { declarator, bitfield });
601
602            if !self.check(&TokenKind::Comma) {
603                break;
604            }
605            self.advance()?;
606        }
607
608        self.expect(&TokenKind::Semi)?;
609
610        Ok(StructMember { specs, declarators })
611    }
612
613    /// 列挙型をパース
614    fn parse_enum(&mut self) -> Result<TypeSpec> {
615        let loc = self.current.loc.clone();
616        self.advance()?; // enum
617
618        // 名前（オプション）
619        let name = self.current_ident();
620        if name.is_some() {
621            self.advance()?;
622        }
623
624        // 列挙子リスト（オプション）
625        let enumerators = if self.check(&TokenKind::LBrace) {
626            self.advance()?;
627            let mut enums = Vec::new();
628            while !self.check(&TokenKind::RBrace) {
629                let eloc = self.current.loc.clone();
630                let ename = self.expect_ident()?;
631                let value = if self.check(&TokenKind::Eq) {
632                    self.advance()?;
633                    Some(Box::new(self.parse_conditional_expr()?))
634                } else {
635                    None
636                };
637                enums.push(Enumerator {
638                    name: ename,
639                    value,
640                    loc: eloc,
641                });
642                if !self.check(&TokenKind::Comma) {
643                    break;
644                }
645                self.advance()?;
646            }
647            self.expect(&TokenKind::RBrace)?;
648            Some(enums)
649        } else {
650            None
651        };
652
653        Ok(TypeSpec::Enum(EnumSpec {
654            name,
655            enumerators,
656            loc,
657        }))
658    }
659
660    /// 宣言子をパース
661    fn parse_declarator(&mut self) -> Result<Declarator> {
662        let loc = self.current.loc.clone();
663        let mut derived = Vec::new();
664
665        // ポインタ
666        while self.check(&TokenKind::Star) {
667            self.advance()?;
668            let qualifiers = self.parse_type_qualifiers()?;
669            derived.push(DerivedDecl::Pointer(qualifiers));
670        }
671
672        // 直接宣言子
673        let (name, inner_derived) = self.parse_direct_declarator()?;
674        derived.extend(inner_derived);
675
676        Ok(Declarator {
677            name,
678            derived,
679            loc,
680        })
681    }
682
683    /// 直接宣言子をパース
684    fn parse_direct_declarator(&mut self) -> Result<(Option<InternedStr>, Vec<DerivedDecl>)> {
685        let mut derived = Vec::new();
686
687        // 識別子または ( declarator )
688        let name = if self.check(&TokenKind::LParen) {
689            self.advance()?;
690            let inner = self.parse_declarator()?;
691            self.expect(&TokenKind::RParen)?;
692            // 内側の派生型を先頭に追加
693            derived = inner.derived;
694            inner.name
695        } else if let Some(id) = self.current_ident() {
696            // 識別子（キーワードはTokenKind::Kw*なのでここには来ない）
697            self.advance()?;
698            Some(id)
699        } else {
700            None
701        };
702
703        // 配列・関数の後置修飾
704        loop {
705            if self.check(&TokenKind::LBracket) {
706                derived.push(self.parse_array_declarator()?);
707            } else if self.check(&TokenKind::LParen) {
708                derived.push(self.parse_function_declarator()?);
709            } else {
710                break;
711            }
712        }
713
714        Ok((name, derived))
715    }
716
717    /// 配列宣言子をパース
718    fn parse_array_declarator(&mut self) -> Result<DerivedDecl> {
719        self.advance()?; // [
720
721        let mut qualifiers = TypeQualifiers::default();
722        let mut is_static = false;
723        let mut is_vla = false;
724
725        // static と型修飾子
726        loop {
727            match &self.current.kind {
728                TokenKind::KwStatic => {
729                    is_static = true;
730                    self.advance()?;
731                }
732                TokenKind::KwConst | TokenKind::KwConst2 | TokenKind::KwConst3 => {
733                    qualifiers.is_const = true;
734                    self.advance()?;
735                }
736                TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3 => {
737                    qualifiers.is_volatile = true;
738                    self.advance()?;
739                }
740                TokenKind::KwRestrict | TokenKind::KwRestrict2 | TokenKind::KwRestrict3 => {
741                    qualifiers.is_restrict = true;
742                    self.advance()?;
743                }
744                _ => break,
745            }
746        }
747
748        // サイズ式
749        let size = if self.check(&TokenKind::RBracket) {
750            None
751        } else if self.check(&TokenKind::Star) {
752            is_vla = true;
753            self.advance()?;
754            None
755        } else {
756            Some(Box::new(self.parse_assignment_expr()?))
757        };
758
759        self.expect(&TokenKind::RBracket)?;
760
761        Ok(DerivedDecl::Array(ArrayDecl {
762            size,
763            qualifiers,
764            is_static,
765            is_vla,
766        }))
767    }
768
769    /// 関数宣言子をパース
770    fn parse_function_declarator(&mut self) -> Result<DerivedDecl> {
771        self.advance()?; // (
772
773        if self.check(&TokenKind::RParen) {
774            self.advance()?;
775            return Ok(DerivedDecl::Function(ParamList {
776                params: Vec::new(),
777                is_variadic: false,
778            }));
779        }
780
781        let mut params = Vec::new();
782        let mut is_variadic = false;
783
784        loop {
785            if self.check(&TokenKind::Ellipsis) {
786                is_variadic = true;
787                self.advance()?;
788                break;
789            }
790
791            let loc = self.current.loc.clone();
792            let specs = self.parse_decl_specs()?;
793            let declarator = if self.check(&TokenKind::Comma) || self.check(&TokenKind::RParen) {
794                None
795            } else {
796                Some(self.parse_declarator()?)
797            };
798
799            // GCC拡張: パラメータ後の __attribute__((...)) をスキップ
800            self.try_skip_attribute()?;
801
802            params.push(ParamDecl {
803                specs,
804                declarator,
805                loc,
806            });
807
808            if !self.check(&TokenKind::Comma) {
809                break;
810            }
811            self.advance()?;
812        }
813
814        self.expect(&TokenKind::RParen)?;
815
816        Ok(DerivedDecl::Function(ParamList { params, is_variadic }))
817    }
818
819    /// 型修飾子をパース
820    fn parse_type_qualifiers(&mut self) -> Result<TypeQualifiers> {
821        let mut qualifiers = TypeQualifiers::default();
822
823        loop {
824            match &self.current.kind {
825                TokenKind::KwConst | TokenKind::KwConst2 | TokenKind::KwConst3 => {
826                    qualifiers.is_const = true;
827                    self.advance()?;
828                }
829                TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3 => {
830                    qualifiers.is_volatile = true;
831                    self.advance()?;
832                }
833                TokenKind::KwRestrict | TokenKind::KwRestrict2 | TokenKind::KwRestrict3 => {
834                    qualifiers.is_restrict = true;
835                    self.advance()?;
836                }
837                TokenKind::KwAtomic => {
838                    qualifiers.is_atomic = true;
839                    self.advance()?;
840                }
841                _ => break,
842            }
843        }
844
845        Ok(qualifiers)
846    }
847
848    /// 初期化子をパース
849    fn parse_initializer(&mut self) -> Result<Initializer> {
850        if self.check(&TokenKind::LBrace) {
851            self.advance()?;
852            let mut items = Vec::new();
853
854            while !self.check(&TokenKind::RBrace) {
855                let designation = self.parse_designation()?;
856                let init = self.parse_initializer()?;
857                items.push(InitializerItem { designation, init });
858
859                if !self.check(&TokenKind::Comma) {
860                    break;
861                }
862                self.advance()?;
863            }
864            self.expect(&TokenKind::RBrace)?;
865
866            Ok(Initializer::List(items))
867        } else {
868            Ok(Initializer::Expr(Box::new(self.parse_assignment_expr()?)))
869        }
870    }
871
872    /// 指示子列をパース
873    fn parse_designation(&mut self) -> Result<Vec<Designator>> {
874        let mut designators = Vec::new();
875
876        loop {
877            if self.check(&TokenKind::LBracket) {
878                self.advance()?;
879                let index = self.parse_conditional_expr()?;
880                self.expect(&TokenKind::RBracket)?;
881                designators.push(Designator::Index(Box::new(index)));
882            } else if self.check(&TokenKind::Dot) {
883                self.advance()?;
884                let name = self.expect_ident()?;
885                designators.push(Designator::Member(name));
886            } else {
887                break;
888            }
889        }
890
891        if !designators.is_empty() {
892            self.expect(&TokenKind::Eq)?;
893        }
894
895        Ok(designators)
896    }
897
898    /// 型名をパース
899    pub fn parse_type_name(&mut self) -> Result<TypeName> {
900        let specs = self.parse_decl_specs()?;
901        let declarator = if self.check(&TokenKind::RParen) {
902            None
903        } else {
904            Some(self.parse_abstract_declarator()?)
905        };
906        Ok(TypeName { specs, declarator })
907    }
908
909    /// 抽象宣言子をパース
910    fn parse_abstract_declarator(&mut self) -> Result<AbstractDeclarator> {
911        let mut derived = Vec::new();
912
913        // ポインタ
914        while self.check(&TokenKind::Star) {
915            self.advance()?;
916            let qualifiers = self.parse_type_qualifiers()?;
917            derived.push(DerivedDecl::Pointer(qualifiers));
918        }
919
920        // 直接抽象宣言子
921        if self.check(&TokenKind::LParen) {
922            // ( abstract-declarator ) または ( parameter-list )
923            // 先読みで判定が必要だが、簡略化のためここでは単純に処理
924            self.advance()?;
925            if !self.check(&TokenKind::RParen) && !self.is_type_start() {
926                let inner = self.parse_abstract_declarator()?;
927                self.expect(&TokenKind::RParen)?;
928                derived.extend(inner.derived);
929            } else {
930                // パラメータリストとして処理
931                let params = self.parse_param_list_inner()?;
932                derived.push(DerivedDecl::Function(params));
933            }
934        }
935
936        // 配列・関数の後置修飾
937        loop {
938            if self.check(&TokenKind::LBracket) {
939                derived.push(self.parse_array_declarator()?);
940            } else if self.check(&TokenKind::LParen) {
941                derived.push(self.parse_function_declarator()?);
942            } else {
943                break;
944            }
945        }
946
947        Ok(AbstractDeclarator { derived })
948    }
949
950    /// パラメータリストの内部をパース（RParen消費済み前提ではない）
951    fn parse_param_list_inner(&mut self) -> Result<ParamList> {
952        if self.check(&TokenKind::RParen) {
953            self.advance()?;
954            return Ok(ParamList {
955                params: Vec::new(),
956                is_variadic: false,
957            });
958        }
959
960        let mut params = Vec::new();
961        let mut is_variadic = false;
962
963        loop {
964            if self.check(&TokenKind::Ellipsis) {
965                is_variadic = true;
966                self.advance()?;
967                break;
968            }
969
970            let loc = self.current.loc.clone();
971            let specs = self.parse_decl_specs()?;
972            let declarator = if self.check(&TokenKind::Comma) || self.check(&TokenKind::RParen) {
973                None
974            } else if self.check(&TokenKind::Star) || self.check(&TokenKind::LParen) || self.check(&TokenKind::LBracket) {
975                Some(self.parse_declarator()?)
976            } else if let Some(id) = self.current_ident() {
977                // 識別子（キーワードはTokenKind::Kw*なのでここには来ない）
978                // typedef名でなければ宣言子
979                if !self.typedefs.contains(&id) {
980                    Some(self.parse_declarator()?)
981                } else {
982                    None
983                }
984            } else {
985                None
986            };
987
988            // GCC拡張: パラメータ後の __attribute__((...)) をスキップ
989            self.try_skip_attribute()?;
990
991            params.push(ParamDecl {
992                specs,
993                declarator,
994                loc,
995            });
996
997            if !self.check(&TokenKind::Comma) {
998                break;
999            }
1000            self.advance()?;
1001        }
1002
1003        self.expect(&TokenKind::RParen)?;
1004
1005        Ok(ParamList { params, is_variadic })
1006    }
1007
1008    // ==================== 文のパース ====================
1009
1010    /// 複合文をパース
1011    fn parse_compound_stmt(&mut self) -> Result<CompoundStmt> {
1012        let loc = self.current.loc.clone();
1013        self.expect(&TokenKind::LBrace)?;
1014
1015        let mut items = Vec::new();
1016        while !self.check(&TokenKind::RBrace) {
1017            items.push(self.parse_block_item()?);
1018        }
1019
1020        self.expect(&TokenKind::RBrace)?;
1021
1022        Ok(CompoundStmt { items, info: NodeInfo::new(loc) })
1023    }
1024
1025    /// ブロック項目をパース
1026    pub(crate) fn parse_block_item(&mut self) -> Result<BlockItem> {
1027        if self.is_declaration_start() {
1028            Ok(BlockItem::Decl(self.parse_declaration()?))
1029        } else {
1030            Ok(BlockItem::Stmt(self.parse_stmt()?))
1031        }
1032    }
1033
1034    /// 宣言をパース
1035    fn parse_declaration(&mut self) -> Result<Declaration> {
1036        let comments = self.current.leading_comments.clone();
1037        let loc = self.current.loc.clone();
1038        let is_target = self.source.is_file_in_target(loc.file_id);
1039        let specs = self.parse_decl_specs()?;
1040
1041        if self.check(&TokenKind::Semi) {
1042            self.advance()?;
1043            return Ok(Declaration {
1044                specs,
1045                declarators: Vec::new(),
1046                info: NodeInfo::new(loc),
1047                comments,
1048                is_target,
1049            });
1050        }
1051
1052        let mut declarators = Vec::new();
1053
1054        loop {
1055            let declarator = self.parse_declarator()?;
1056
1057            // GCC拡張: 宣言子の後の __attribute__((...)) をスキップ
1058            self.try_skip_attribute()?;
1059
1060            let init = if self.check(&TokenKind::Eq) {
1061                self.advance()?;
1062                Some(self.parse_initializer()?)
1063            } else {
1064                None
1065            };
1066            declarators.push(InitDeclarator { declarator, init });
1067
1068            if !self.check(&TokenKind::Comma) {
1069                break;
1070            }
1071            self.advance()?;
1072        }
1073
1074        // GCC拡張: 宣言の最後の __attribute__((...)) をスキップ
1075        self.try_skip_attribute()?;
1076
1077        self.expect(&TokenKind::Semi)?;
1078
1079        // typedef の場合、名前を登録
1080        if specs.storage == Some(StorageClass::Typedef) {
1081            for d in &declarators {
1082                if let Some(name) = d.declarator.name {
1083                    self.typedefs.insert(name);
1084                }
1085            }
1086        }
1087
1088        Ok(Declaration {
1089            specs,
1090            declarators,
1091            info: NodeInfo::new(loc),
1092            comments,
1093            is_target,
1094        })
1095    }
1096
1097    /// 文をパース
1098    fn parse_stmt(&mut self) -> Result<Stmt> {
1099        let loc = self.current.loc.clone();
1100
1101        // キーワードに基づく文のパース
1102        match &self.current.kind {
1103            // ラベル文
1104            TokenKind::KwCase => return self.parse_case_stmt(),
1105            TokenKind::KwDefault => return self.parse_default_stmt(),
1106            // 複合文
1107            TokenKind::LBrace => return Ok(Stmt::Compound(self.parse_compound_stmt()?)),
1108            // 制御フロー文
1109            TokenKind::KwIf => return self.parse_if_stmt(),
1110            TokenKind::KwSwitch => return self.parse_switch_stmt(),
1111            TokenKind::KwWhile => return self.parse_while_stmt(),
1112            TokenKind::KwDo => return self.parse_do_while_stmt(),
1113            TokenKind::KwFor => return self.parse_for_stmt(),
1114            TokenKind::KwGoto => {
1115                self.advance()?;
1116                let name = self.expect_ident()?;
1117                self.expect(&TokenKind::Semi)?;
1118                return Ok(Stmt::Goto(name, loc));
1119            }
1120            TokenKind::KwContinue => {
1121                self.advance()?;
1122                self.expect(&TokenKind::Semi)?;
1123                return Ok(Stmt::Continue(loc));
1124            }
1125            TokenKind::KwBreak => {
1126                self.advance()?;
1127                self.expect(&TokenKind::Semi)?;
1128                return Ok(Stmt::Break(loc));
1129            }
1130            TokenKind::KwReturn => {
1131                self.advance()?;
1132                let expr = if self.check(&TokenKind::Semi) {
1133                    None
1134                } else {
1135                    Some(Box::new(self.parse_expr()?))
1136                };
1137                self.expect(&TokenKind::Semi)?;
1138                return Ok(Stmt::Return(expr, loc));
1139            }
1140            // __asm__ 文
1141            TokenKind::KwAsm | TokenKind::KwAsm2 | TokenKind::KwAsm3 => {
1142                return self.parse_asm_stmt();
1143            }
1144            _ => {}
1145        }
1146
1147        // 式文
1148        if self.check(&TokenKind::Semi) {
1149            self.advance()?;
1150            return Ok(Stmt::Expr(None, loc));
1151        }
1152
1153        let expr = self.parse_expr()?;
1154
1155        // ラベルのチェック（識別子 : の場合）
1156        if self.check(&TokenKind::Colon) {
1157            if let ExprKind::Ident(name) = expr.kind {
1158                self.advance()?;
1159                let stmt = self.parse_stmt()?;
1160                return Ok(Stmt::Label {
1161                    name,
1162                    stmt: Box::new(stmt),
1163                    loc,
1164                });
1165            }
1166        }
1167
1168        self.expect(&TokenKind::Semi)?;
1169        Ok(Stmt::Expr(Some(Box::new(expr)), loc))
1170    }
1171
1172    fn parse_if_stmt(&mut self) -> Result<Stmt> {
1173        let loc = self.current.loc.clone();
1174        self.advance()?; // if
1175        self.expect(&TokenKind::LParen)?;
1176        let cond = Box::new(self.parse_expr()?);
1177        self.expect(&TokenKind::RParen)?;
1178        let then_stmt = Box::new(self.parse_stmt()?);
1179
1180        let else_stmt = if matches!(self.current.kind, TokenKind::KwElse) {
1181            self.advance()?;
1182            Some(Box::new(self.parse_stmt()?))
1183        } else {
1184            None
1185        };
1186
1187        Ok(Stmt::If {
1188            cond,
1189            then_stmt,
1190            else_stmt,
1191            loc,
1192        })
1193    }
1194
1195    fn parse_switch_stmt(&mut self) -> Result<Stmt> {
1196        let loc = self.current.loc.clone();
1197        self.advance()?; // switch
1198        self.expect(&TokenKind::LParen)?;
1199        let expr = Box::new(self.parse_expr()?);
1200        self.expect(&TokenKind::RParen)?;
1201        let body = Box::new(self.parse_stmt()?);
1202
1203        Ok(Stmt::Switch { expr, body, loc })
1204    }
1205
1206    fn parse_while_stmt(&mut self) -> Result<Stmt> {
1207        let loc = self.current.loc.clone();
1208        self.advance()?; // while
1209        self.expect(&TokenKind::LParen)?;
1210        let cond = Box::new(self.parse_expr()?);
1211        self.expect(&TokenKind::RParen)?;
1212        let body = Box::new(self.parse_stmt()?);
1213
1214        Ok(Stmt::While { cond, body, loc })
1215    }
1216
1217    fn parse_do_while_stmt(&mut self) -> Result<Stmt> {
1218        let loc = self.current.loc.clone();
1219        self.advance()?; // do
1220        let body = Box::new(self.parse_stmt()?);
1221        // expect 'while' keyword
1222        if !matches!(self.current.kind, TokenKind::KwWhile) {
1223            return Err(CompileError::Parse {
1224                loc: self.current.loc.clone(),
1225                kind: ParseError::UnexpectedToken {
1226                    expected: "while".to_string(),
1227                    found: self.current.kind.clone(),
1228                },
1229            });
1230        }
1231        self.advance()?;
1232        self.expect(&TokenKind::LParen)?;
1233        let cond = Box::new(self.parse_expr()?);
1234        self.expect(&TokenKind::RParen)?;
1235
1236        // allow_missing_semi が true の場合、; は任意
1237        if self.allow_missing_semi {
1238            if self.check(&TokenKind::Semi) {
1239                self.advance()?;
1240            }
1241        } else {
1242            self.expect(&TokenKind::Semi)?;
1243        }
1244
1245        Ok(Stmt::DoWhile { body, cond, loc })
1246    }
1247
1248    fn parse_for_stmt(&mut self) -> Result<Stmt> {
1249        let loc = self.current.loc.clone();
1250        self.advance()?; // for
1251        self.expect(&TokenKind::LParen)?;
1252
1253        // 初期化部
1254        let init = if self.check(&TokenKind::Semi) {
1255            self.advance()?;
1256            None
1257        } else if self.is_declaration_start() {
1258            let decl = self.parse_declaration()?;
1259            Some(ForInit::Decl(decl))
1260        } else {
1261            let expr = self.parse_expr()?;
1262            self.expect(&TokenKind::Semi)?;
1263            Some(ForInit::Expr(Box::new(expr)))
1264        };
1265
1266        // 条件部
1267        let cond = if self.check(&TokenKind::Semi) {
1268            None
1269        } else {
1270            Some(Box::new(self.parse_expr()?))
1271        };
1272        self.expect(&TokenKind::Semi)?;
1273
1274        // 更新部
1275        let step = if self.check(&TokenKind::RParen) {
1276            None
1277        } else {
1278            Some(Box::new(self.parse_expr()?))
1279        };
1280        self.expect(&TokenKind::RParen)?;
1281
1282        let body = Box::new(self.parse_stmt()?);
1283
1284        Ok(Stmt::For {
1285            init,
1286            cond,
1287            step,
1288            body,
1289            loc,
1290        })
1291    }
1292
1293    fn parse_case_stmt(&mut self) -> Result<Stmt> {
1294        let loc = self.current.loc.clone();
1295        self.advance()?; // case
1296        let expr = Box::new(self.parse_conditional_expr()?);
1297        self.expect(&TokenKind::Colon)?;
1298        let stmt = Box::new(self.parse_stmt()?);
1299
1300        Ok(Stmt::Case { expr, stmt, loc })
1301    }
1302
1303    fn parse_default_stmt(&mut self) -> Result<Stmt> {
1304        let loc = self.current.loc.clone();
1305        self.advance()?; // default
1306        self.expect(&TokenKind::Colon)?;
1307        let stmt = Box::new(self.parse_stmt()?);
1308
1309        Ok(Stmt::Default { stmt, loc })
1310    }
1311
1312    fn parse_asm_stmt(&mut self) -> Result<Stmt> {
1313        let loc = self.current.loc.clone();
1314        self.advance()?; // asm / __asm / __asm__
1315
1316        // volatile / __volatile__ はスキップ
1317        while matches!(
1318            self.current.kind,
1319            TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3
1320        ) {
1321            self.advance()?;
1322        }
1323
1324        // 括弧内をスキップ
1325        self.expect(&TokenKind::LParen)?;
1326        self.skip_balanced_parens()?;
1327
1328        self.expect(&TokenKind::Semi)?;
1329        Ok(Stmt::Asm { loc })
1330    }
1331
1332    // ==================== 式のパース ====================
1333
1334    /// 式をパース（コンマ式を含む）
1335    fn parse_expr(&mut self) -> Result<Expr> {
1336        let lhs = self.parse_assignment_expr()?;
1337
1338        if self.check(&TokenKind::Comma) {
1339            let loc = self.current.loc.clone();
1340            self.advance()?;
1341            let rhs = self.parse_expr()?;
1342            return Ok(Expr::new(
1343                ExprKind::Comma {
1344                    lhs: Box::new(lhs),
1345                    rhs: Box::new(rhs),
1346                },
1347                loc,
1348            ));
1349        }
1350
1351        Ok(lhs)
1352    }
1353
1354    /// 代入式をパース
1355    fn parse_assignment_expr(&mut self) -> Result<Expr> {
1356        let lhs = self.parse_conditional_expr()?;
1357
1358        let op = match &self.current.kind {
1359            TokenKind::Eq => Some(AssignOp::Assign),
1360            TokenKind::StarEq => Some(AssignOp::MulAssign),
1361            TokenKind::SlashEq => Some(AssignOp::DivAssign),
1362            TokenKind::PercentEq => Some(AssignOp::ModAssign),
1363            TokenKind::PlusEq => Some(AssignOp::AddAssign),
1364            TokenKind::MinusEq => Some(AssignOp::SubAssign),
1365            TokenKind::LtLtEq => Some(AssignOp::ShlAssign),
1366            TokenKind::GtGtEq => Some(AssignOp::ShrAssign),
1367            TokenKind::AmpEq => Some(AssignOp::AndAssign),
1368            TokenKind::CaretEq => Some(AssignOp::XorAssign),
1369            TokenKind::PipeEq => Some(AssignOp::OrAssign),
1370            _ => None,
1371        };
1372
1373        if let Some(op) = op {
1374            let loc = self.current.loc.clone();
1375            self.advance()?;
1376            let rhs = self.parse_assignment_expr()?;
1377            return Ok(Expr::new(
1378                ExprKind::Assign {
1379                    op,
1380                    lhs: Box::new(lhs),
1381                    rhs: Box::new(rhs),
1382                },
1383                loc,
1384            ));
1385        }
1386
1387        Ok(lhs)
1388    }
1389
1390    /// 条件式をパース
1391    fn parse_conditional_expr(&mut self) -> Result<Expr> {
1392        let cond = self.parse_logical_or_expr()?;
1393
1394        if self.check(&TokenKind::Question) {
1395            let loc = self.current.loc.clone();
1396            self.advance()?;
1397            let then_expr = self.parse_expr()?;
1398            self.expect(&TokenKind::Colon)?;
1399            let else_expr = self.parse_conditional_expr()?;
1400            return Ok(Expr::new(
1401                ExprKind::Conditional {
1402                    cond: Box::new(cond),
1403                    then_expr: Box::new(then_expr),
1404                    else_expr: Box::new(else_expr),
1405                },
1406                loc,
1407            ));
1408        }
1409
1410        Ok(cond)
1411    }
1412
1413    /// 論理OR式をパース
1414    fn parse_logical_or_expr(&mut self) -> Result<Expr> {
1415        let mut lhs = self.parse_logical_and_expr()?;
1416
1417        while self.check(&TokenKind::PipePipe) {
1418            let loc = self.current.loc.clone();
1419            self.advance()?;
1420            let rhs = self.parse_logical_and_expr()?;
1421            lhs = Expr::new(
1422                ExprKind::Binary {
1423                    op: BinOp::LogOr,
1424                    lhs: Box::new(lhs),
1425                    rhs: Box::new(rhs),
1426                },
1427                loc,
1428            );
1429        }
1430
1431        Ok(lhs)
1432    }
1433
1434    /// 論理AND式をパース
1435    fn parse_logical_and_expr(&mut self) -> Result<Expr> {
1436        let mut lhs = self.parse_bitwise_or_expr()?;
1437
1438        while self.check(&TokenKind::AmpAmp) {
1439            let loc = self.current.loc.clone();
1440            self.advance()?;
1441            let rhs = self.parse_bitwise_or_expr()?;
1442            lhs = Expr::new(
1443                ExprKind::Binary {
1444                    op: BinOp::LogAnd,
1445                    lhs: Box::new(lhs),
1446                    rhs: Box::new(rhs),
1447                },
1448                loc,
1449            );
1450        }
1451
1452        Ok(lhs)
1453    }
1454
1455    /// ビットOR式をパース
1456    fn parse_bitwise_or_expr(&mut self) -> Result<Expr> {
1457        let mut lhs = self.parse_bitwise_xor_expr()?;
1458
1459        while self.check(&TokenKind::Pipe) {
1460            let loc = self.current.loc.clone();
1461            self.advance()?;
1462            let rhs = self.parse_bitwise_xor_expr()?;
1463            lhs = Expr::new(
1464                ExprKind::Binary {
1465                    op: BinOp::BitOr,
1466                    lhs: Box::new(lhs),
1467                    rhs: Box::new(rhs),
1468                },
1469                loc,
1470            );
1471        }
1472
1473        Ok(lhs)
1474    }
1475
1476    /// ビットXOR式をパース
1477    fn parse_bitwise_xor_expr(&mut self) -> Result<Expr> {
1478        let mut lhs = self.parse_bitwise_and_expr()?;
1479
1480        while self.check(&TokenKind::Caret) {
1481            let loc = self.current.loc.clone();
1482            self.advance()?;
1483            let rhs = self.parse_bitwise_and_expr()?;
1484            lhs = Expr::new(
1485                ExprKind::Binary {
1486                    op: BinOp::BitXor,
1487                    lhs: Box::new(lhs),
1488                    rhs: Box::new(rhs),
1489                },
1490                loc,
1491            );
1492        }
1493
1494        Ok(lhs)
1495    }
1496
1497    /// ビットAND式をパース
1498    fn parse_bitwise_and_expr(&mut self) -> Result<Expr> {
1499        let mut lhs = self.parse_equality_expr()?;
1500
1501        while self.check(&TokenKind::Amp) {
1502            let loc = self.current.loc.clone();
1503            self.advance()?;
1504            let rhs = self.parse_equality_expr()?;
1505            lhs = Expr::new(
1506                ExprKind::Binary {
1507                    op: BinOp::BitAnd,
1508                    lhs: Box::new(lhs),
1509                    rhs: Box::new(rhs),
1510                },
1511                loc,
1512            );
1513        }
1514
1515        Ok(lhs)
1516    }
1517
1518    /// 等価式をパース
1519    fn parse_equality_expr(&mut self) -> Result<Expr> {
1520        let mut lhs = self.parse_relational_expr()?;
1521
1522        loop {
1523            let op = match &self.current.kind {
1524                TokenKind::EqEq => BinOp::Eq,
1525                TokenKind::BangEq => BinOp::Ne,
1526                _ => break,
1527            };
1528            let loc = self.current.loc.clone();
1529            self.advance()?;
1530            let rhs = self.parse_relational_expr()?;
1531            lhs = Expr::new(
1532                ExprKind::Binary {
1533                    op,
1534                    lhs: Box::new(lhs),
1535                    rhs: Box::new(rhs),
1536                },
1537                loc,
1538            );
1539        }
1540
1541        Ok(lhs)
1542    }
1543
1544    /// 関係式をパース
1545    fn parse_relational_expr(&mut self) -> Result<Expr> {
1546        let mut lhs = self.parse_shift_expr()?;
1547
1548        loop {
1549            let op = match &self.current.kind {
1550                TokenKind::Lt => BinOp::Lt,
1551                TokenKind::Gt => BinOp::Gt,
1552                TokenKind::LtEq => BinOp::Le,
1553                TokenKind::GtEq => BinOp::Ge,
1554                _ => break,
1555            };
1556            let loc = self.current.loc.clone();
1557            self.advance()?;
1558            let rhs = self.parse_shift_expr()?;
1559            lhs = Expr::new(
1560                ExprKind::Binary {
1561                    op,
1562                    lhs: Box::new(lhs),
1563                    rhs: Box::new(rhs),
1564                },
1565                loc,
1566            );
1567        }
1568
1569        Ok(lhs)
1570    }
1571
1572    /// シフト式をパース
1573    fn parse_shift_expr(&mut self) -> Result<Expr> {
1574        let mut lhs = self.parse_additive_expr()?;
1575
1576        loop {
1577            let op = match &self.current.kind {
1578                TokenKind::LtLt => BinOp::Shl,
1579                TokenKind::GtGt => BinOp::Shr,
1580                _ => break,
1581            };
1582            let loc = self.current.loc.clone();
1583            self.advance()?;
1584            let rhs = self.parse_additive_expr()?;
1585            lhs = Expr::new(
1586                ExprKind::Binary {
1587                    op,
1588                    lhs: Box::new(lhs),
1589                    rhs: Box::new(rhs),
1590                },
1591                loc,
1592            );
1593        }
1594
1595        Ok(lhs)
1596    }
1597
1598    /// 加減式をパース
1599    fn parse_additive_expr(&mut self) -> Result<Expr> {
1600        let mut lhs = self.parse_multiplicative_expr()?;
1601
1602        loop {
1603            let op = match &self.current.kind {
1604                TokenKind::Plus => BinOp::Add,
1605                TokenKind::Minus => BinOp::Sub,
1606                _ => break,
1607            };
1608            let loc = self.current.loc.clone();
1609            self.advance()?;
1610            let rhs = self.parse_multiplicative_expr()?;
1611            lhs = Expr::new(
1612                ExprKind::Binary {
1613                    op,
1614                    lhs: Box::new(lhs),
1615                    rhs: Box::new(rhs),
1616                },
1617                loc,
1618            );
1619        }
1620
1621        Ok(lhs)
1622    }
1623
1624    /// 乗除式をパース
1625    fn parse_multiplicative_expr(&mut self) -> Result<Expr> {
1626        let mut lhs = self.parse_cast_expr()?;
1627
1628        loop {
1629            let op = match &self.current.kind {
1630                TokenKind::Star => BinOp::Mul,
1631                TokenKind::Slash => BinOp::Div,
1632                TokenKind::Percent => BinOp::Mod,
1633                _ => break,
1634            };
1635            let loc = self.current.loc.clone();
1636            self.advance()?;
1637            let rhs = self.parse_cast_expr()?;
1638            lhs = Expr::new(
1639                ExprKind::Binary {
1640                    op,
1641                    lhs: Box::new(lhs),
1642                    rhs: Box::new(rhs),
1643                },
1644                loc,
1645            );
1646        }
1647
1648        Ok(lhs)
1649    }
1650
1651    /// キャスト式をパース
1652    fn parse_cast_expr(&mut self) -> Result<Expr> {
1653        // ( type-name ) cast-expression のみをここで処理
1654        // ( expr ) は parse_primary_expr で処理し、postfix操作を許可する
1655        if self.check(&TokenKind::LParen) {
1656            let loc = self.current.loc.clone();
1657            self.advance()?; // (
1658
1659            // 1. 確定的な型名（キーワード/typedef/既検出の generic param）
1660            if self.is_type_start() {
1661                return self.finish_parse_cast_or_compound_lit(loc);
1662            }
1663
1664            // 2. 未検出の generic param → 先読みで判定
1665            if let Some(id) = self.current_ident() {
1666                if self.generic_params.contains_key(&id)
1667                    && self.looks_like_generic_cast()
1668                {
1669                    // 型パラメータとして記録
1670                    self.detected_type_params.insert(id);
1671                    return self.finish_parse_cast_or_compound_lit(loc);
1672                }
1673            }
1674
1675            if self.check(&TokenKind::LBrace) {
1676                // GCC拡張: ステートメント式 ({ ... })
1677                let stmt = self.parse_compound_stmt()?;
1678                self.expect(&TokenKind::RParen)?;
1679                // ステートメント式の後もpostfixを許可する
1680                let stmt_expr = Expr::new(ExprKind::StmtExpr(stmt), loc);
1681                return self.parse_postfix_on(stmt_expr);
1682            } else {
1683                // 括弧で囲まれた式 - parse_primary_exprに任せる
1684                // いったん戻してparse_unary_exprに任せる
1685                // 注: ここではadvanceを巻き戻す代わりに、式をパースしてからpostfixを処理
1686                let expr = self.parse_expr()?;
1687                self.expect(&TokenKind::RParen)?;
1688                // postfix操作を許可する（->や.など）
1689                return self.parse_postfix_on(expr);
1690            }
1691        }
1692
1693        self.parse_unary_expr()
1694    }
1695
1696    /// キャスト式または複合リテラルのパースを完了する
1697    ///
1698    /// `parse_cast_expr` で `(` を消費し、current が型名の先頭にある状態で呼ぶ。
1699    fn finish_parse_cast_or_compound_lit(&mut self, loc: SourceLocation) -> Result<Expr> {
1700        let type_name = self.parse_type_name()?;
1701        self.expect(&TokenKind::RParen)?;
1702
1703        // 複合リテラルのチェック
1704        if self.check(&TokenKind::LBrace) {
1705            self.advance()?;
1706            let mut items = Vec::new();
1707            while !self.check(&TokenKind::RBrace) {
1708                let designation = self.parse_designation()?;
1709                let init = self.parse_initializer()?;
1710                items.push(InitializerItem { designation, init });
1711                if !self.check(&TokenKind::Comma) {
1712                    break;
1713                }
1714                self.advance()?;
1715            }
1716            self.expect(&TokenKind::RBrace)?;
1717            return Ok(Expr::new(
1718                ExprKind::CompoundLit {
1719                    type_name: Box::new(type_name),
1720                    init: items,
1721                },
1722                loc,
1723            ));
1724        }
1725
1726        let expr = self.parse_cast_expr()?;
1727        Ok(Expr::new(
1728            ExprKind::Cast {
1729                type_name: Box::new(type_name),
1730                expr: Box::new(expr),
1731            },
1732            loc,
1733        ))
1734    }
1735
1736    /// generic param がキャスト式の型として使われているかを先読みで判定
1737    ///
1738    /// 呼び出し時点: current = generic param の Ident
1739    /// TokenSource::next_token + unget_token で先読み
1740    fn looks_like_generic_cast(&mut self) -> bool {
1741        // 先読み1: param の次のトークン
1742        let next1 = match self.source.next_token() {
1743            Ok(t) => t,
1744            Err(_) => return false,
1745        };
1746
1747        let result = match &next1.kind {
1748            // (PARAM *...) — ポインタキャスト
1749            TokenKind::Star => true,
1750
1751            // (PARAM) — 値キャスト候補、後続の文脈で判定
1752            TokenKind::RParen => {
1753                let next2 = match self.source.next_token() {
1754                    Ok(t) => t,
1755                    Err(_) => {
1756                        self.source.unget_token(next1);
1757                        return false;
1758                    }
1759                };
1760                // ) の後に式の開始トークンが続くならキャスト
1761                let is_cast = match &next2.kind {
1762                    TokenKind::LParen       // (PARAM)(expr)
1763                    | TokenKind::Ident(_)   // (PARAM)ident
1764                    | TokenKind::IntLit(_) | TokenKind::UIntLit(_)
1765                    | TokenKind::FloatLit(_)
1766                    | TokenKind::StringLit(_) | TokenKind::CharLit(_)
1767                    | TokenKind::Star       // (PARAM)*ptr (deref)
1768                    | TokenKind::Amp        // (PARAM)&x
1769                    | TokenKind::Bang       // (PARAM)!x
1770                    | TokenKind::Tilde      // (PARAM)~x
1771                    | TokenKind::KwSizeof   // (PARAM)sizeof(x)
1772                    => true,
1773
1774                    // (PARAM)-x: 3トークン先読みで判定
1775                    // `-` の次が数値リテラルなら cast (e.g. (T)-1)
1776                    // それ以外なら二項減算 (e.g. (val) - func(...))
1777                    TokenKind::Minus => {
1778                        let next3 = match self.source.next_token() {
1779                            Ok(t) => t,
1780                            Err(_) => {
1781                                self.source.unget_token(next2);
1782                                self.source.unget_token(next1);
1783                                return false;
1784                            }
1785                        };
1786                        let is_numeric = matches!(&next3.kind,
1787                            TokenKind::IntLit(_)
1788                            | TokenKind::UIntLit(_)
1789                            | TokenKind::FloatLit(_)
1790                        );
1791                        self.source.unget_token(next3);
1792                        is_numeric
1793                    }
1794
1795                    _ => false,
1796                };
1797                self.source.unget_token(next2);
1798                is_cast
1799            }
1800
1801            // (PARAM + ...) など — 括弧付き式
1802            _ => false,
1803        };
1804
1805        self.source.unget_token(next1);
1806        result
1807    }
1808
1809    /// 既存の式に対してpostfix操作をパース
1810    fn parse_postfix_on(&mut self, mut expr: Expr) -> Result<Expr> {
1811        loop {
1812            let loc = self.current.loc.clone();
1813            match &self.current.kind {
1814                TokenKind::LBracket => {
1815                    self.advance()?;
1816                    let index = self.parse_expr()?;
1817                    self.expect(&TokenKind::RBracket)?;
1818                    expr = Expr::new(
1819                        ExprKind::Index {
1820                            expr: Box::new(expr),
1821                            index: Box::new(index),
1822                        },
1823                        loc,
1824                    );
1825                }
1826                TokenKind::LParen => {
1827                    self.advance()?;
1828                    let mut args = Vec::new();
1829                    while !self.check(&TokenKind::RParen) {
1830                        args.push(self.parse_assignment_expr()?);
1831                        if !self.check(&TokenKind::Comma) {
1832                            break;
1833                        }
1834                        self.advance()?;
1835                    }
1836                    self.expect(&TokenKind::RParen)?;
1837                    self.function_call_count += 1;
1838                    expr = Expr::new(
1839                        ExprKind::Call {
1840                            func: Box::new(expr),
1841                            args,
1842                        },
1843                        loc,
1844                    );
1845                }
1846                TokenKind::Dot => {
1847                    self.advance()?;
1848                    let member = self.expect_ident()?;
1849                    expr = Expr::new(
1850                        ExprKind::Member {
1851                            expr: Box::new(expr),
1852                            member,
1853                        },
1854                        loc,
1855                    );
1856                }
1857                TokenKind::Arrow => {
1858                    self.advance()?;
1859                    let member = self.expect_ident()?;
1860                    self.deref_count += 1;
1861                    expr = Expr::new(
1862                        ExprKind::PtrMember {
1863                            expr: Box::new(expr),
1864                            member,
1865                        },
1866                        loc,
1867                    );
1868                }
1869                TokenKind::PlusPlus => {
1870                    self.advance()?;
1871                    expr = Expr::new(ExprKind::PostInc(Box::new(expr)), loc);
1872                }
1873                TokenKind::MinusMinus => {
1874                    self.advance()?;
1875                    expr = Expr::new(ExprKind::PostDec(Box::new(expr)), loc);
1876                }
1877                _ => break,
1878            }
1879        }
1880        Ok(expr)
1881    }
1882
1883    /// 単項式をパース
1884    fn parse_unary_expr(&mut self) -> Result<Expr> {
1885        let loc = self.current.loc.clone();
1886
1887        match &self.current.kind {
1888            TokenKind::PlusPlus => {
1889                self.advance()?;
1890                let expr = self.parse_unary_expr()?;
1891                Ok(Expr::new(ExprKind::PreInc(Box::new(expr)), loc))
1892            }
1893            TokenKind::MinusMinus => {
1894                self.advance()?;
1895                let expr = self.parse_unary_expr()?;
1896                Ok(Expr::new(ExprKind::PreDec(Box::new(expr)), loc))
1897            }
1898            TokenKind::Amp => {
1899                self.advance()?;
1900                let expr = self.parse_cast_expr()?;
1901                Ok(Expr::new(ExprKind::AddrOf(Box::new(expr)), loc))
1902            }
1903            TokenKind::Star => {
1904                self.advance()?;
1905                let expr = self.parse_cast_expr()?;
1906                self.deref_count += 1;
1907                Ok(Expr::new(ExprKind::Deref(Box::new(expr)), loc))
1908            }
1909            TokenKind::Plus => {
1910                self.advance()?;
1911                let expr = self.parse_cast_expr()?;
1912                Ok(Expr::new(ExprKind::UnaryPlus(Box::new(expr)), loc))
1913            }
1914            TokenKind::Minus => {
1915                self.advance()?;
1916                let expr = self.parse_cast_expr()?;
1917                Ok(Expr::new(ExprKind::UnaryMinus(Box::new(expr)), loc))
1918            }
1919            TokenKind::Tilde => {
1920                self.advance()?;
1921                let expr = self.parse_cast_expr()?;
1922                Ok(Expr::new(ExprKind::BitNot(Box::new(expr)), loc))
1923            }
1924            TokenKind::Bang => {
1925                self.advance()?;
1926                let expr = self.parse_cast_expr()?;
1927                Ok(Expr::new(ExprKind::LogNot(Box::new(expr)), loc))
1928            }
1929            TokenKind::KwSizeof => {
1930                self.advance()?;
1931                if self.check(&TokenKind::LParen) {
1932                    self.advance()?; // (
1933                    if self.is_type_start() {
1934                        // sizeof(type)
1935                        let type_name = self.parse_type_name()?;
1936                        self.expect(&TokenKind::RParen)?;
1937                        Ok(Expr::new(ExprKind::SizeofType(Box::new(type_name)), loc))
1938                    } else {
1939                        // sizeof(expr) - 括弧付きの式
1940                        let expr = self.parse_expr()?;
1941                        self.expect(&TokenKind::RParen)?;
1942                        Ok(Expr::new(ExprKind::Sizeof(Box::new(expr)), loc))
1943                    }
1944                } else {
1945                    let expr = self.parse_unary_expr()?;
1946                    Ok(Expr::new(ExprKind::Sizeof(Box::new(expr)), loc))
1947                }
1948            }
1949            TokenKind::KwAlignof | TokenKind::KwAlignof2 | TokenKind::KwAlignof3 => {
1950                self.advance()?;
1951                self.expect(&TokenKind::LParen)?;
1952                let type_name = self.parse_type_name()?;
1953                self.expect(&TokenKind::RParen)?;
1954                Ok(Expr::new(ExprKind::Alignof(Box::new(type_name)), loc))
1955            }
1956            // GCC拡張: __extension__ は無視して続行（TinyCC方式）
1957            TokenKind::KwExtension => {
1958                self.advance()?;
1959                self.parse_unary_expr()
1960            }
1961            _ => self.parse_postfix_expr(),
1962        }
1963    }
1964
1965    /// 後置式をパース
1966    fn parse_postfix_expr(&mut self) -> Result<Expr> {
1967        let mut expr = self.parse_primary_expr()?;
1968
1969        loop {
1970            let loc = self.current.loc.clone();
1971            match &self.current.kind {
1972                TokenKind::LBracket => {
1973                    self.advance()?;
1974                    let index = self.parse_expr()?;
1975                    self.expect(&TokenKind::RBracket)?;
1976                    expr = Expr::new(
1977                        ExprKind::Index {
1978                            expr: Box::new(expr),
1979                            index: Box::new(index),
1980                        },
1981                        loc,
1982                    );
1983                }
1984                TokenKind::LParen => {
1985                    // ビルトイン呼び出し判定
1986                    if let ExprKind::Ident(name) = &expr.kind {
1987                        if self.is_type_arg_builtin(*name) {
1988                            let builtin_name = *name;
1989                            self.advance()?; // (
1990                            let args = self.parse_builtin_args()?;
1991                            self.expect(&TokenKind::RParen)?;
1992                            self.function_call_count += 1;
1993                            expr = Expr::new(
1994                                ExprKind::BuiltinCall { name: builtin_name, args },
1995                                loc,
1996                            );
1997                            continue;
1998                        }
1999                    }
2000                    // 通常の関数呼び出し
2001                    self.advance()?;
2002                    let mut args = Vec::new();
2003                    if !self.check(&TokenKind::RParen) {
2004                        loop {
2005                            args.push(self.parse_assignment_expr()?);
2006                            if !self.check(&TokenKind::Comma) {
2007                                break;
2008                            }
2009                            self.advance()?;
2010                        }
2011                    }
2012                    self.expect(&TokenKind::RParen)?;
2013                    self.function_call_count += 1;
2014                    expr = Expr::new(
2015                        ExprKind::Call {
2016                            func: Box::new(expr),
2017                            args,
2018                        },
2019                        loc,
2020                    );
2021                }
2022                TokenKind::Dot => {
2023                    self.advance()?;
2024                    let member = self.expect_ident()?;
2025                    expr = Expr::new(
2026                        ExprKind::Member {
2027                            expr: Box::new(expr),
2028                            member,
2029                        },
2030                        loc,
2031                    );
2032                }
2033                TokenKind::Arrow => {
2034                    self.advance()?;
2035                    let member = self.expect_ident()?;
2036                    self.deref_count += 1;
2037                    expr = Expr::new(
2038                        ExprKind::PtrMember {
2039                            expr: Box::new(expr),
2040                            member,
2041                        },
2042                        loc,
2043                    );
2044                }
2045                TokenKind::PlusPlus => {
2046                    self.advance()?;
2047                    expr = Expr::new(ExprKind::PostInc(Box::new(expr)), loc);
2048                }
2049                TokenKind::MinusMinus => {
2050                    self.advance()?;
2051                    expr = Expr::new(ExprKind::PostDec(Box::new(expr)), loc);
2052                }
2053                _ => break,
2054            }
2055        }
2056
2057        Ok(expr)
2058    }
2059
2060    /// 一次式をパース
2061    fn parse_primary_expr(&mut self) -> Result<Expr> {
2062        let loc = self.current.loc.clone();
2063
2064        match &self.current.kind {
2065            TokenKind::Ident(id) => {
2066                let id = *id;
2067                self.advance()?;
2068                Ok(Expr::new(ExprKind::Ident(id), loc))
2069            }
2070            TokenKind::IntLit(n) => {
2071                let n = *n;
2072                self.advance()?;
2073                Ok(Expr::new(ExprKind::IntLit(n), loc))
2074            }
2075            TokenKind::UIntLit(n) => {
2076                let n = *n;
2077                self.advance()?;
2078                Ok(Expr::new(ExprKind::UIntLit(n), loc))
2079            }
2080            TokenKind::FloatLit(f) => {
2081                let f = *f;
2082                self.advance()?;
2083                Ok(Expr::new(ExprKind::FloatLit(f), loc))
2084            }
2085            TokenKind::CharLit(c) => {
2086                let c = *c;
2087                self.advance()?;
2088                Ok(Expr::new(ExprKind::CharLit(c), loc))
2089            }
2090            TokenKind::StringLit(s) => {
2091                let mut bytes = s.clone();
2092                self.advance()?;
2093                // 連続した文字列リテラルを結合
2094                while let TokenKind::StringLit(s2) = &self.current.kind {
2095                    bytes.extend_from_slice(s2);
2096                    self.advance()?;
2097                }
2098                Ok(Expr::new(ExprKind::StringLit(bytes), loc))
2099            }
2100            TokenKind::LParen => {
2101                self.advance()?;
2102                // GCC拡張: ステートメント式 ({ ... })
2103                if self.check(&TokenKind::LBrace) {
2104                    let stmt = self.parse_compound_stmt()?;
2105                    self.expect(&TokenKind::RParen)?;
2106                    Ok(Expr::new(ExprKind::StmtExpr(stmt), loc))
2107                } else {
2108                    let expr = self.parse_expr()?;
2109                    self.expect(&TokenKind::RParen)?;
2110                    Ok(expr)
2111                }
2112            }
2113            TokenKind::MacroBegin(info) if info.is_wrapped => {
2114                // wrapped マクロ（assert 等）を処理
2115                self.parse_wrapped_macro_expr()
2116            }
2117            TokenKind::MacroBegin(info) if info.preserve_call => {
2118                // preserve_call マクロを MacroCall ノードとして処理
2119                self.parse_macro_call_expr()
2120            }
2121            _ => Err(CompileError::Parse {
2122                loc,
2123                kind: ParseError::UnexpectedToken {
2124                    expected: "primary expression".to_string(),
2125                    found: self.current.kind.clone(),
2126                },
2127            }),
2128        }
2129    }
2130
2131    /// wrapped マクロ（assert 等）を Assert 式としてパース
2132    ///
2133    /// MacroBegin(is_wrapped=true) から args を取得し、condition をパースして
2134    /// Assert 式を生成する。その後 MacroEnd までスキップ。
2135    ///
2136    /// `assert_` や `__ASSERT_` は末尾カンマ形式で、式の前に付ける修飾子として使用される。
2137    /// 空展開時はカンマがないため、後続の式があれば暗黙的にカンマ式を形成する。
2138    fn parse_wrapped_macro_expr(&mut self) -> Result<Expr> {
2139        let loc = self.current.loc.clone();
2140
2141        // MacroBegin から情報を取得
2142        let (marker_id, macro_name, args) = match &self.current.kind {
2143            TokenKind::MacroBegin(info) if info.is_wrapped => {
2144                let args = match &info.kind {
2145                    MacroInvocationKind::Function { args } => args.clone(),
2146                    MacroInvocationKind::Object => {
2147                        let name = self.source.interner().get(info.macro_name).to_string();
2148                        return Err(CompileError::Parse {
2149                            loc,
2150                            kind: ParseError::AssertNotFunctionMacro { macro_name: name },
2151                        });
2152                    }
2153                };
2154                (info.marker_id, info.macro_name, args)
2155            }
2156            _ => unreachable!("parse_wrapped_macro_expr called without wrapped MacroBegin"),
2157        };
2158
2159        // 引数数チェック（assert は 1 引数）
2160        if args.len() != 1 {
2161            let name = self.source.interner().get(macro_name).to_string();
2162            return Err(CompileError::Parse {
2163                loc,
2164                kind: ParseError::InvalidAssertArgs {
2165                    macro_name: name,
2166                    arg_count: args.len(),
2167                },
2168            });
2169        }
2170
2171        // args[0] から condition をパース
2172        let condition = self.parse_expr_from_tokens(&args[0], &loc)?;
2173
2174        // AssertKind を判定
2175        let macro_name_str = self.source.interner().get(macro_name);
2176        let kind = detect_assert_kind(macro_name_str).unwrap_or(AssertKind::Assert);
2177
2178        // MacroBegin を消費して MacroEnd までスキップ
2179        // 注意: advance() は inner_next_token() を使うため MacroEnd をスキップしてしまう
2180        // そのため、ここでは skip_to_macro_end() を使って直接ソースから読み取る
2181        self.skip_to_macro_end(marker_id)?;
2182
2183        let assert_expr = Expr::new(ExprKind::Assert {
2184            kind,
2185            condition: Box::new(condition),
2186        }, loc.clone());
2187
2188        // 末尾カンマ形式（assert_, __ASSERT_）の場合、後続の式と暗黙的にカンマ式を形成
2189        // 次のトークンが式の開始（別の Assert 含む）であれば結合
2190        if self.is_expression_start() {
2191            // 後続の式をパース（再帰的に Assert もパースされる）
2192            let next_expr = self.parse_assignment_expr()?;
2193            Ok(Expr::new(
2194                ExprKind::Comma {
2195                    lhs: Box::new(assert_expr),
2196                    rhs: Box::new(next_expr),
2197                },
2198                loc,
2199            ))
2200        } else {
2201            Ok(assert_expr)
2202        }
2203    }
2204
2205    /// preserve_call マクロを MacroCall 式としてパース
2206    ///
2207    /// MacroBegin(preserve_call=true) から元の引数を取得し、
2208    /// 展開結果をパースして MacroCall ノードを生成する。
2209    ///
2210    /// MacroCall は元のマクロ呼び出し情報と展開結果を両方保持することで：
2211    /// - 展開結果で型推論を実行
2212    /// - コード生成時にマクロ呼び出し形式で出力可能
2213    fn parse_macro_call_expr(&mut self) -> Result<Expr> {
2214        let loc = self.current.loc.clone();
2215
2216        // MacroBegin から情報を取得
2217        let (marker_id, macro_name, raw_args, call_loc) = match &self.current.kind {
2218            TokenKind::MacroBegin(info) if info.preserve_call => {
2219                let args = match &info.kind {
2220                    MacroInvocationKind::Function { args } => args.clone(),
2221                    MacroInvocationKind::Object => Vec::new(),
2222                };
2223                (info.marker_id, info.macro_name, args, info.call_loc.clone())
2224            }
2225            _ => unreachable!("parse_macro_call_expr called without preserve_call MacroBegin"),
2226        };
2227
2228        // MacroBegin を消費（advance は inner_next_token を使うため MacroEnd もスキップされる可能性がある）
2229        // そのため、ここでは source から直接読み取って展開トークンを収集
2230        let expanded_tokens = self.collect_tokens_until_macro_end(marker_id)?;
2231
2232        // 展開トークンから式をパース
2233        let expanded = if expanded_tokens.is_empty() {
2234            // 空展開の場合は 0 を返す（void 式として扱う）
2235            Expr::new(ExprKind::IntLit(0), loc.clone())
2236        } else {
2237            crate::parser::parse_expression_from_tokens_ref(
2238                expanded_tokens,
2239                self.source.interner(),
2240                self.source.files(),
2241                &self.typedefs,
2242            )?
2243        };
2244
2245        // 元の引数トークン列を式としてパース
2246        let parsed_args: Result<Vec<Expr>> = raw_args.iter()
2247            .map(|arg_tokens| {
2248                if arg_tokens.is_empty() {
2249                    // 空引数の場合
2250                    Ok(Expr::new(ExprKind::IntLit(0), loc.clone()))
2251                } else {
2252                    crate::parser::parse_expression_from_tokens_ref(
2253                        arg_tokens.clone(),
2254                        self.source.interner(),
2255                        self.source.files(),
2256                        &self.typedefs,
2257                    )
2258                }
2259            })
2260            .collect();
2261        let args = parsed_args?;
2262
2263        // current を次のトークンで更新
2264        self.current = self.inner_next_token()?;
2265
2266        Ok(Expr::new(ExprKind::MacroCall {
2267            name: macro_name,
2268            args,
2269            expanded: Box::new(expanded),
2270            call_loc,
2271        }, loc))
2272    }
2273
2274    /// 指定した marker_id に対応する MacroEnd までのトークンを収集
2275    ///
2276    /// source から直接読み取り、MacroBegin/MacroEnd のネストを追跡する。
2277    fn collect_tokens_until_macro_end(&mut self, target_marker_id: TokenId) -> Result<Vec<Token>> {
2278        let mut tokens = Vec::new();
2279        let mut nested_depth = 0;
2280
2281        loop {
2282            let token = self.source.next_token()?;
2283
2284            match &token.kind {
2285                TokenKind::MacroBegin(_) => {
2286                    // ネストされたマクロ展開開始
2287                    nested_depth += 1;
2288                    tokens.push(token);
2289                }
2290                TokenKind::MacroEnd(info) => {
2291                    if nested_depth > 0 {
2292                        // ネストされたマクロ展開終了
2293                        nested_depth -= 1;
2294                        tokens.push(token);
2295                    } else if info.begin_marker_id == target_marker_id {
2296                        // 目標の MacroEnd を見つけた
2297                        return Ok(tokens);
2298                    } else {
2299                        // 異なる MacroEnd（これは起こらないはず）
2300                        tokens.push(token);
2301                    }
2302                }
2303                TokenKind::Eof => {
2304                    return Err(CompileError::Parse {
2305                        loc: token.loc,
2306                        kind: ParseError::UnexpectedToken {
2307                            expected: "MacroEnd".to_string(),
2308                            found: token.kind,
2309                        },
2310                    });
2311                }
2312                _ => {
2313                    tokens.push(token);
2314                }
2315            }
2316        }
2317    }
2318
2319    /// 現在のトークンが式の開始かどうかを判定
2320    fn is_expression_start(&self) -> bool {
2321        match &self.current.kind {
2322            // 式の開始になり得るトークン
2323            TokenKind::Ident(_)
2324            | TokenKind::IntLit(_)
2325            | TokenKind::UIntLit(_)
2326            | TokenKind::FloatLit(_)
2327            | TokenKind::CharLit(_)
2328            | TokenKind::WideCharLit(_)
2329            | TokenKind::StringLit(_)
2330            | TokenKind::WideStringLit(_)
2331            | TokenKind::LParen
2332            | TokenKind::Star      // 間接参照
2333            | TokenKind::Amp       // アドレス取得
2334            | TokenKind::Plus      // 単項プラス
2335            | TokenKind::Minus     // 単項マイナス
2336            | TokenKind::Bang      // 論理否定
2337            | TokenKind::Tilde     // ビット反転
2338            | TokenKind::PlusPlus  // 前置インクリメント
2339            | TokenKind::MinusMinus // 前置デクリメント
2340            | TokenKind::KwSizeof
2341            | TokenKind::KwAlignof
2342            | TokenKind::KwAlignof2
2343            | TokenKind::KwAlignof3
2344            | TokenKind::MacroBegin(_) => true, // 別の Assert も含む
2345            _ => false,
2346        }
2347    }
2348
2349    /// トークン列から式をパース
2350    ///
2351    /// args から取り出したトークン列を一時的なソースとして式をパースする。
2352    /// 入れ子の wrapped マクロがあればエラー。
2353    fn parse_expr_from_tokens(&self, tokens: &[Token], loc: &SourceLocation) -> Result<Expr> {
2354        // 入れ子チェック：tokens 内に wrapped MacroBegin があればエラー
2355        for token in tokens {
2356            if let TokenKind::MacroBegin(info) = &token.kind {
2357                if info.is_wrapped {
2358                    return Err(CompileError::Parse {
2359                        loc: loc.clone(),
2360                        kind: ParseError::NestedAssertNotSupported,
2361                    });
2362                }
2363            }
2364        }
2365
2366        // トークン列から式をパース
2367        crate::parser::parse_expression_from_tokens_ref(
2368            tokens.to_vec(),
2369            self.source.interner(),
2370            self.source.files(),
2371            &self.typedefs,
2372        )
2373    }
2374
2375    /// 指定した marker_id に対応する MacroEnd までスキップ
2376    ///
2377    /// inner_next_token は MacroEnd をスキップするため、
2378    /// ここでは source から直接読み取る。
2379    fn skip_to_macro_end(&mut self, target_marker_id: TokenId) -> Result<()> {
2380        // まず current をチェック（MacroBegin の直後なので通常は MacroEnd ではない）
2381        loop {
2382            // source から直接読み取る（inner_next_token は MacroEnd をスキップするため）
2383            let token = self.source.next_token()?;
2384
2385            match &token.kind {
2386                TokenKind::MacroEnd(info) if info.begin_marker_id == target_marker_id => {
2387                    // 目標の MacroEnd を見つけた
2388                    // current を次のトークンで更新（inner_next_token を使って正常なフローに戻す）
2389                    self.current = self.inner_next_token()?;
2390                    return Ok(());
2391                }
2392                TokenKind::Eof => {
2393                    return Err(CompileError::Parse {
2394                        loc: token.loc.clone(),
2395                        kind: ParseError::MacroEndNotFound,
2396                    });
2397                }
2398                _ => {
2399                    // 他のトークンはスキップ（MacroBegin/MacroEnd 含む）
2400                    continue;
2401                }
2402            }
2403        }
2404    }
2405
2406    // ==================== ユーティリティ ====================
2407
2408    /// 内部トークン取得メソッド（マーカーを透過的に処理）
2409    ///
2410    /// `handle_macro_markers` が true の場合、MacroBegin/MacroEnd マーカーを
2411    /// 処理してスキップし、通常のトークンのみを返す。
2412    /// ただし、以下の MacroBegin はスキップせず返す：
2413    /// - `is_wrapped=true`: assert 等の特殊処理用
2414    /// - `preserve_call=true`: MacroCall ノード生成用
2415    /// 空展開でもこれらの MacroBegin を返し、適切な AST ノードを生成する。
2416    fn inner_next_token(&mut self) -> Result<Token> {
2417        loop {
2418            let token = self.source.next_token()?;
2419
2420            if !self.handle_macro_markers {
2421                return Ok(token);
2422            }
2423
2424            match &token.kind {
2425                TokenKind::MacroBegin(info) => {
2426                    if info.is_wrapped {
2427                        // wrapped マクロ（assert 等）は常に返す
2428                        // 空展開でも Assert ノードとして AST に残す
2429                        return Ok(token);
2430                    }
2431                    if info.preserve_call {
2432                        // preserve_call マクロは常に返す
2433                        // MacroCall ノードとして AST に残す
2434                        return Ok(token);
2435                    }
2436                    // 通常のマクロ展開開始：コンテキストにプッシュ
2437                    self.macro_ctx.push((**info).clone());
2438                    continue; // マーカーはスキップ
2439                }
2440                TokenKind::MacroEnd(_info) => {
2441                    // マクロ展開終了：コンテキストからポップ
2442                    self.macro_ctx.pop();
2443                    continue; // マーカーはスキップ
2444                }
2445                _ => return Ok(token),
2446            }
2447        }
2448    }
2449
2450    fn advance(&mut self) -> Result<Token> {
2451        let next = self.inner_next_token()?;
2452        let old = std::mem::replace(&mut self.current, next);
2453        Ok(old)
2454    }
2455
2456    /// 現在のマクロコンテキストから NodeInfo を作成
2457    pub fn make_node_info(&self, loc: SourceLocation) -> NodeInfo {
2458        match self.macro_ctx.build_macro_info(self.source.interner()) {
2459            Some(macro_info) => NodeInfo::with_macro_info(loc, macro_info),
2460            None => NodeInfo::new(loc),
2461        }
2462    }
2463
2464    /// 現在マクロ展開中かどうか
2465    pub fn is_in_macro(&self) -> bool {
2466        self.macro_ctx.is_in_macro()
2467    }
2468
2469    /// マクロ展開の深さ
2470    pub fn macro_depth(&self) -> usize {
2471        self.macro_ctx.depth()
2472    }
2473
2474    fn expect(&mut self, kind: &TokenKind) -> Result<Token> {
2475        if self.check(kind) {
2476            self.advance()
2477        } else {
2478            Err(CompileError::Parse {
2479                loc: self.current.loc.clone(),
2480                kind: ParseError::UnexpectedToken {
2481                    expected: format!("{:?}", kind),
2482                    found: self.current.kind.clone(),
2483                },
2484            })
2485        }
2486    }
2487
2488    fn expect_ident(&mut self) -> Result<InternedStr> {
2489        if let TokenKind::Ident(id) = self.current.kind {
2490            self.advance()?;
2491            Ok(id)
2492        } else {
2493            Err(CompileError::Parse {
2494                loc: self.current.loc.clone(),
2495                kind: ParseError::UnexpectedToken {
2496                    expected: "identifier".to_string(),
2497                    found: self.current.kind.clone(),
2498                },
2499            })
2500        }
2501    }
2502
2503    fn check(&self, kind: &TokenKind) -> bool {
2504        std::mem::discriminant(&self.current.kind) == std::mem::discriminant(kind)
2505    }
2506
2507    fn is_eof(&self) -> bool {
2508        matches!(self.current.kind, TokenKind::Eof)
2509    }
2510
2511    fn current_ident(&self) -> Option<InternedStr> {
2512        if let TokenKind::Ident(id) = self.current.kind {
2513            Some(id)
2514        } else {
2515            None
2516        }
2517    }
2518
2519    /// 引数に型名を取りうるビルトイン関数名かどうか
2520    fn is_type_arg_builtin(&self, name: InternedStr) -> bool {
2521        let s = self.source.interner().get(name);
2522        matches!(s, "offsetof" | "__builtin_offsetof"
2523                  | "__builtin_types_compatible_p"
2524                  | "__builtin_va_arg"
2525                  | "STRUCT_OFFSET")
2526    }
2527
2528    /// ビルトイン関数の引数をパース（型名と式を自動判定）
2529    fn parse_builtin_args(&mut self) -> Result<Vec<BuiltinArg>> {
2530        let mut args = Vec::new();
2531        if !self.check(&TokenKind::RParen) {
2532            loop {
2533                if self.is_type_start() {
2534                    let type_name = self.parse_type_name()?;
2535                    args.push(BuiltinArg::TypeName(Box::new(type_name)));
2536                } else {
2537                    let expr = self.parse_assignment_expr()?;
2538                    args.push(BuiltinArg::Expr(Box::new(expr)));
2539                }
2540                if !self.check(&TokenKind::Comma) {
2541                    break;
2542                }
2543                self.advance()?;
2544            }
2545        }
2546        Ok(args)
2547    }
2548
2549    fn is_type_start(&self) -> bool {
2550        match &self.current.kind {
2551            // 型指定子キーワード
2552            TokenKind::KwVoid
2553            | TokenKind::KwChar
2554            | TokenKind::KwShort
2555            | TokenKind::KwInt
2556            | TokenKind::KwLong
2557            | TokenKind::KwFloat
2558            | TokenKind::KwDouble
2559            | TokenKind::KwSigned
2560            | TokenKind::KwSigned2
2561            | TokenKind::KwUnsigned
2562            | TokenKind::KwBool
2563            | TokenKind::KwBool2
2564            | TokenKind::KwComplex
2565            | TokenKind::KwFloat16
2566            | TokenKind::KwFloat32
2567            | TokenKind::KwFloat64
2568            | TokenKind::KwFloat128
2569            | TokenKind::KwFloat32x
2570            | TokenKind::KwFloat64x
2571            | TokenKind::KwInt128 => true,
2572            // 型修飾子キーワード
2573            TokenKind::KwConst
2574            | TokenKind::KwConst2
2575            | TokenKind::KwConst3
2576            | TokenKind::KwVolatile
2577            | TokenKind::KwVolatile2
2578            | TokenKind::KwVolatile3
2579            | TokenKind::KwRestrict
2580            | TokenKind::KwRestrict2
2581            | TokenKind::KwRestrict3
2582            | TokenKind::KwAtomic => true,
2583            // 構造体・共用体・列挙
2584            TokenKind::KwStruct | TokenKind::KwUnion | TokenKind::KwEnum => true,
2585            // typeof
2586            TokenKind::KwTypeof | TokenKind::KwTypeof2 | TokenKind::KwTypeof3 => true,
2587            // typedef名 or 検出済みの generic 型パラメータ
2588            TokenKind::Ident(id) => {
2589                self.typedefs.contains(id) || self.detected_type_params.contains(id)
2590            }
2591            _ => false,
2592        }
2593    }
2594
2595    fn is_declaration_start(&self) -> bool {
2596        match &self.current.kind {
2597            // ストレージクラス
2598            TokenKind::KwTypedef
2599            | TokenKind::KwExtern
2600            | TokenKind::KwStatic
2601            | TokenKind::KwAuto
2602            | TokenKind::KwRegister => true,
2603            // inline
2604            TokenKind::KwInline | TokenKind::KwInline2 | TokenKind::KwInline3 => true,
2605            // GCC拡張
2606            TokenKind::KwExtension => true,
2607            // thread-local
2608            TokenKind::KwThreadLocal | TokenKind::KwThread => true,
2609            _ => self.is_type_start(),
2610        }
2611    }
2612
2613    /// __attribute__ / __asm__ があればスキップ（複数連続も対応）
2614    fn try_skip_attribute(&mut self) -> Result<()> {
2615        loop {
2616            match &self.current.kind {
2617                TokenKind::KwAttribute | TokenKind::KwAttribute2 => {
2618                    self.skip_attribute()?;
2619                }
2620                TokenKind::KwAsm | TokenKind::KwAsm2 | TokenKind::KwAsm3 => {
2621                    self.try_skip_asm_label()?;
2622                }
2623                _ => break,
2624            }
2625        }
2626        Ok(())
2627    }
2628
2629    /// GCC拡張: __attribute__((...)) をスキップ
2630    fn skip_attribute(&mut self) -> Result<()> {
2631        self.advance()?; // __attribute__ / __attribute
2632
2633        // 外側の ( を期待
2634        if !self.check(&TokenKind::LParen) {
2635            return Ok(()); // 引数なしの場合
2636        }
2637        self.advance()?;
2638
2639        // 内側の ( を期待
2640        if !self.check(&TokenKind::LParen) {
2641            // 単一括弧の場合もある
2642            self.skip_balanced_parens()?;
2643            return Ok(());
2644        }
2645        self.advance()?;
2646
2647        // 内側の括弧の中身をスキップ
2648        self.skip_balanced_parens()?;
2649
2650        // 外側の ) を期待
2651        self.expect(&TokenKind::RParen)?;
2652
2653        Ok(())
2654    }
2655
2656    /// __asm__(label) があればスキップ
2657    fn try_skip_asm_label(&mut self) -> Result<()> {
2658        if matches!(
2659            self.current.kind,
2660            TokenKind::KwAsm | TokenKind::KwAsm2 | TokenKind::KwAsm3
2661        ) {
2662            self.advance()?; // asm / __asm / __asm__
2663            if self.check(&TokenKind::LParen) {
2664                self.advance()?; // (
2665                self.skip_balanced_parens()?; // 内容をスキップして ) を消費
2666            }
2667        }
2668        Ok(())
2669    }
2670
2671    /// 括弧のバランスを取りながらスキップ
2672    fn skip_balanced_parens(&mut self) -> Result<()> {
2673        let mut depth = 1;
2674        while depth > 0 {
2675            match &self.current.kind {
2676                TokenKind::LParen => depth += 1,
2677                TokenKind::RParen => depth -= 1,
2678                TokenKind::Eof => {
2679                    return Err(CompileError::Parse {
2680                        loc: self.current.loc.clone(),
2681                        kind: ParseError::UnexpectedToken {
2682                            expected: ")".to_string(),
2683                            found: TokenKind::Eof,
2684                        },
2685                    });
2686                }
2687                _ => {}
2688            }
2689            if depth > 0 {
2690                self.advance()?;
2691            }
2692        }
2693        self.advance()?; // 最後の )
2694        Ok(())
2695    }
2696}
2697
2698// ==================== ヘルパー関数 ====================
2699
2700use crate::source::FileRegistry;
2701use crate::token_source::TokenSlice;
2702
2703/// トークン列から式をパース
2704///
2705/// マクロ本体などのトークン列を式としてパースする際に使用。
2706///
2707/// # Arguments
2708/// * `tokens` - パースするトークン列
2709/// * `interner` - 文字列インターナー
2710/// * `files` - ファイルレジストリ
2711/// * `typedefs` - typedef名のセット（キャスト式の型名判定に使用）
2712pub fn parse_expression_from_tokens(
2713    tokens: Vec<Token>,
2714    interner: StringInterner,
2715    files: FileRegistry,
2716    typedefs: HashSet<InternedStr>,
2717) -> Result<Expr> {
2718    let mut source = TokenSlice::new(tokens, interner, files);
2719    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs)?;
2720    parser.parse_expr_only()
2721}
2722
2723/// トークン列から式をパース（参照ベース版）
2724///
2725/// `parse_expression_from_tokens` の参照ベース版。
2726/// interner, files, typedefs をクローンせずに借用することで、
2727/// 高頻度の呼び出し時のオーバーヘッドを削減する。
2728///
2729/// # Arguments
2730/// * `tokens` - パースするトークン列
2731/// * `interner` - 文字列インターナーへの参照
2732/// * `files` - ファイルレジストリへの参照
2733/// * `typedefs` - typedef名のセットへの参照
2734pub fn parse_expression_from_tokens_ref(
2735    tokens: Vec<Token>,
2736    interner: &StringInterner,
2737    files: &FileRegistry,
2738    typedefs: &HashSet<InternedStr>,
2739) -> Result<Expr> {
2740    let mut source = TokenSliceRef::new(tokens, interner, files);
2741    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2742    parser.parse_expr_only()
2743}
2744
2745/// トークン列を文としてパース（参照ベース版）
2746///
2747/// マクロ body のパースに使用。do-while の末尾セミコロンは省略可能。
2748///
2749/// # Arguments
2750/// * `tokens` - パースするトークン列
2751/// * `interner` - 文字列インターナーへの参照
2752/// * `files` - ファイルレジストリへの参照
2753/// * `typedefs` - typedef名のセットへの参照
2754pub fn parse_statement_from_tokens_ref(
2755    tokens: Vec<Token>,
2756    interner: &StringInterner,
2757    files: &FileRegistry,
2758    typedefs: &HashSet<InternedStr>,
2759) -> Result<Stmt> {
2760    let mut source = TokenSliceRef::new(tokens, interner, files);
2761    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2762    parser.parse_stmt_allow_missing_semi()
2763}
2764
2765/// パース結果に付随する統計情報
2766#[derive(Debug, Clone, Default)]
2767pub struct ParseStats {
2768    /// 関数呼び出しの数
2769    pub function_call_count: usize,
2770    /// ポインタデリファレンスの数
2771    pub deref_count: usize,
2772}
2773
2774impl ParseStats {
2775    /// unsafe 操作を含むか
2776    pub fn has_unsafe_ops(&self) -> bool {
2777        self.function_call_count > 0 || self.deref_count > 0
2778    }
2779}
2780
2781/// トークン列から式をパース（統計情報付き・参照ベース版）
2782///
2783/// `parse_expression_from_tokens_ref` と同様だが、
2784/// パース統計（関数呼び出し数など）も返す。
2785///
2786/// # Arguments
2787/// * `tokens` - パースするトークン列
2788/// * `interner` - 文字列インターナーへの参照
2789/// * `files` - ファイルレジストリへの参照
2790/// * `typedefs` - typedef名のセットへの参照
2791///
2792/// # Returns
2793/// (パースされた式, 統計情報)
2794pub fn parse_expression_from_tokens_ref_with_stats(
2795    tokens: Vec<Token>,
2796    interner: &StringInterner,
2797    files: &FileRegistry,
2798    typedefs: &HashSet<InternedStr>,
2799) -> Result<(Expr, ParseStats)> {
2800    let mut source = TokenSliceRef::new(tokens, interner, files);
2801    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2802    let expr = parser.parse_expr_only()?;
2803    let stats = ParseStats {
2804        function_call_count: parser.function_call_count,
2805        deref_count: parser.deref_count,
2806    };
2807    Ok((expr, stats))
2808}
2809
2810/// トークン列から式をパース（generic_params 付き）
2811///
2812/// マクロ本体のパースに使用。マクロの仮引数名を generic_params として渡し、
2813/// キャスト式での型パラメータ使用を自動検出する。
2814///
2815/// # Returns
2816/// (パースされた式, 統計情報, 検出された型パラメータ)
2817pub fn parse_expression_from_tokens_ref_with_generic_params(
2818    tokens: Vec<Token>,
2819    interner: &StringInterner,
2820    files: &FileRegistry,
2821    typedefs: &HashSet<InternedStr>,
2822    generic_params: HashMap<InternedStr, usize>,
2823) -> Result<(Expr, ParseStats, HashSet<InternedStr>)> {
2824    let mut source = TokenSliceRef::new(tokens, interner, files);
2825    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2826    parser.generic_params = generic_params;
2827    let expr = parser.parse_expr_only()?;
2828    let stats = ParseStats {
2829        function_call_count: parser.function_call_count,
2830        deref_count: parser.deref_count,
2831    };
2832    let detected = parser.detected_type_params;
2833    Ok((expr, stats, detected))
2834}
2835
2836/// トークン列を文としてパース（統計情報付き・参照ベース版）
2837///
2838/// `parse_statement_from_tokens_ref` と同様だが、
2839/// パース統計（関数呼び出し数など）も返す。
2840/// do-while の末尾セミコロンは省略可能。
2841///
2842/// # Arguments
2843/// * `tokens` - パースするトークン列
2844/// * `interner` - 文字列インターナーへの参照
2845/// * `files` - ファイルレジストリへの参照
2846/// * `typedefs` - typedef名のセットへの参照
2847///
2848/// # Returns
2849/// (パースされた文, 統計情報)
2850pub fn parse_statement_from_tokens_ref_with_stats(
2851    tokens: Vec<Token>,
2852    interner: &StringInterner,
2853    files: &FileRegistry,
2854    typedefs: &HashSet<InternedStr>,
2855) -> Result<(Stmt, ParseStats)> {
2856    let mut source = TokenSliceRef::new(tokens, interner, files);
2857    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2858    let stmt = parser.parse_stmt_allow_missing_semi()?;
2859    let stats = ParseStats {
2860        function_call_count: parser.function_call_count,
2861        deref_count: parser.deref_count,
2862    };
2863    Ok((stmt, stats))
2864}
2865
2866/// トークン列を文としてパース（generic_params 付き）
2867///
2868/// マクロ本体のパースに使用。マクロの仮引数名を generic_params として渡し、
2869/// キャスト式での型パラメータ使用を自動検出する。
2870///
2871/// # Returns
2872/// (パースされた文, 統計情報, 検出された型パラメータ)
2873pub fn parse_statement_from_tokens_ref_with_generic_params(
2874    tokens: Vec<Token>,
2875    interner: &StringInterner,
2876    files: &FileRegistry,
2877    typedefs: &HashSet<InternedStr>,
2878    generic_params: HashMap<InternedStr, usize>,
2879) -> Result<(Stmt, ParseStats, HashSet<InternedStr>)> {
2880    let mut source = TokenSliceRef::new(tokens, interner, files);
2881    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2882    parser.generic_params = generic_params;
2883    let stmt = parser.parse_stmt_allow_missing_semi()?;
2884    let stats = ParseStats {
2885        function_call_count: parser.function_call_count,
2886        deref_count: parser.deref_count,
2887    };
2888    let detected = parser.detected_type_params;
2889    Ok((stmt, stats, detected))
2890}
2891
2892/// トークン列を複数のブロック項目としてパース
2893///
2894/// セミコロン区切りの複数文を含むマクロ本体のパースに使用。
2895/// `{ }` なしの BlockItem リストをパースし、EOF まで読む。
2896///
2897/// # Returns
2898/// (パースされたブロック項目リスト, 統計情報)
2899pub fn parse_block_items_from_tokens_ref_with_stats(
2900    tokens: Vec<Token>,
2901    interner: &StringInterner,
2902    files: &FileRegistry,
2903    typedefs: &HashSet<InternedStr>,
2904) -> Result<(Vec<BlockItem>, ParseStats)> {
2905    let mut source = TokenSliceRef::new(tokens, interner, files);
2906    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2907    parser.allow_missing_semi = true;
2908    let mut items = Vec::new();
2909    while !parser.check(&TokenKind::Eof) {
2910        items.push(parser.parse_block_item()?);
2911    }
2912    let stats = ParseStats {
2913        function_call_count: parser.function_call_count,
2914        deref_count: parser.deref_count,
2915    };
2916    Ok((items, stats))
2917}
2918
2919/// トークン列を複数のブロック項目としてパース（generic_params 付き）
2920///
2921/// # Returns
2922/// (パースされたブロック項目リスト, 統計情報, 検出された型パラメータ)
2923pub fn parse_block_items_from_tokens_ref_with_generic_params(
2924    tokens: Vec<Token>,
2925    interner: &StringInterner,
2926    files: &FileRegistry,
2927    typedefs: &HashSet<InternedStr>,
2928    generic_params: HashMap<InternedStr, usize>,
2929) -> Result<(Vec<BlockItem>, ParseStats, HashSet<InternedStr>)> {
2930    let mut source = TokenSliceRef::new(tokens, interner, files);
2931    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2932    parser.allow_missing_semi = true;
2933    parser.generic_params = generic_params;
2934    let mut items = Vec::new();
2935    while !parser.check(&TokenKind::Eof) {
2936        items.push(parser.parse_block_item()?);
2937    }
2938    let stats = ParseStats {
2939        function_call_count: parser.function_call_count,
2940        deref_count: parser.deref_count,
2941    };
2942    let detected = parser.detected_type_params;
2943    Ok((items, stats, detected))
2944}
2945
2946/// 型文字列から TypeName をパース
2947///
2948/// apidoc 等の型文字列（例: "SV *", "const char *"）をパースして
2949/// TypeName AST を返す。ReadOnlyLexer を使用するため、
2950/// 型文字列内の識別子は既に intern 済みである必要がある。
2951///
2952/// # Arguments
2953/// * `type_str` - パースする型文字列
2954/// * `interner` - 文字列インターナーへの参照（読み取り専用）
2955/// * `files` - ファイルレジストリへの参照
2956/// * `typedefs` - typedef名のセットへの参照
2957///
2958/// # Returns
2959/// パースされた TypeName AST、または識別子が未知の場合はエラー
2960pub fn parse_type_from_string(
2961    type_str: &str,
2962    interner: &StringInterner,
2963    files: &FileRegistry,
2964    typedefs: &HashSet<InternedStr>,
2965) -> Result<TypeName> {
2966    // 型文字列用のダミー FileId（エラー時の位置情報は限定的）
2967    let file_id = FileId::default();
2968
2969    // ReadOnlyLexer でトークン化（新規 intern なし）
2970    let mut lexer = Lexer::<LookupOnly>::new_readonly(type_str.as_bytes(), file_id, interner);
2971
2972    let mut tokens = Vec::new();
2973    loop {
2974        let token = lexer.next_token()?;
2975        if matches!(token.kind, TokenKind::Eof) {
2976            break;
2977        }
2978        tokens.push(token);
2979    }
2980
2981    // パース
2982    let mut source = TokenSliceRef::new(tokens, interner, files);
2983    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2984    parser.parse_type_name()
2985}
2986
2987/// トークン列を struct メンバー宣言の連続としてパースする。
2988///
2989/// `_XPVCV_COMMON` のような共通フィールド宣言マクロの本体を解析する用途。
2990/// 入力末尾に `;` が無い場合は自動補完する（マクロ本体は典型的に最終
2991/// 宣言の後に `;` を持たない — 展開先で `;` が補われる）。
2992pub fn parse_struct_members_from_tokens_ref(
2993    mut tokens: Vec<Token>,
2994    interner: &StringInterner,
2995    files: &FileRegistry,
2996    typedefs: &HashSet<InternedStr>,
2997) -> Result<Vec<StructMember>> {
2998    // 末尾に `;` が無ければ補う（最後の意味のあるトークンを見て判定）
2999    let needs_trailing_semi = tokens
3000        .iter()
3001        .rev()
3002        .find(|t| !matches!(t.kind, TokenKind::Eof))
3003        .is_some_and(|t| !matches!(t.kind, TokenKind::Semi));
3004    if needs_trailing_semi {
3005        // EOF を取り除いて `;` を足し直す
3006        let eof = tokens.iter().position(|t| matches!(t.kind, TokenKind::Eof))
3007            .map(|i| tokens.remove(i));
3008        let semi_loc = tokens.last().map(|t| t.loc.clone()).unwrap_or_default();
3009        tokens.push(Token::new(TokenKind::Semi, semi_loc));
3010        if let Some(eof) = eof {
3011            tokens.push(eof);
3012        }
3013    }
3014    let mut source = TokenSliceRef::new(tokens, interner, files);
3015    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
3016    let mut members = Vec::new();
3017    while !parser.check(&TokenKind::Eof) {
3018        members.push(parser.parse_struct_member()?);
3019    }
3020    Ok(members)
3021}
3022
3023#[cfg(test)]
3024mod tests {
3025    use super::*;
3026    use crate::preprocessor::PPConfig;
3027    use std::io::Write;
3028    use tempfile::NamedTempFile;
3029
3030    fn parse_str(code: &str) -> Result<TranslationUnit> {
3031        let mut file = NamedTempFile::new().unwrap();
3032        file.write_all(code.as_bytes()).unwrap();
3033
3034        let mut pp = Preprocessor::new(PPConfig::default());
3035        pp.add_source_file(file.path())?;
3036
3037        let mut parser = Parser::new(&mut pp)?;
3038        parser.parse()
3039    }
3040
3041    #[test]
3042    fn test_simple_function() {
3043        let tu = parse_str("int main(void) { return 0; }").unwrap();
3044        assert_eq!(tu.decls.len(), 1);
3045        assert!(matches!(tu.decls[0], ExternalDecl::FunctionDef(_)));
3046    }
3047
3048    #[test]
3049    fn test_variable_declaration() {
3050        let tu = parse_str("int x;").unwrap();
3051        assert_eq!(tu.decls.len(), 1);
3052        assert!(matches!(tu.decls[0], ExternalDecl::Declaration(_)));
3053    }
3054
3055    #[test]
3056    fn test_struct_declaration() {
3057        let tu = parse_str("struct Point { int x; int y; };").unwrap();
3058        assert_eq!(tu.decls.len(), 1);
3059    }
3060
3061    #[test]
3062    fn test_typedef() {
3063        let tu = parse_str("typedef int INT; INT x;").unwrap();
3064        assert_eq!(tu.decls.len(), 2);
3065    }
3066
3067    #[test]
3068    fn test_expression() {
3069        let tu = parse_str("int x = 1 + 2 * 3;").unwrap();
3070        assert_eq!(tu.decls.len(), 1);
3071    }
3072}