feat: 타입 검사기(TypeChecker) 신규 구현

- Analyzer에서 분리해 TypeChecker 모듈로 타입 검사 로직 이관
- check_program, check_block, check_stmt, check_expr로 AST 재귀 순회 구조화
- 산술·비트·논리·비교 연산자 및 단항 연산자, 대입문, 함수 호출, 배열 인덱싱, 초기화 리스트 검사 구현
- char→int 암시 승격(promotion) 및 int→char 암시 축소 허용
- 고정 크기 배열 선언을 Pointer(T)로 등록해 arr[i] 인덱싱 검사 통과
- Analyzer::analyze()에서 name_resolution 후 type_check 호출로 책임 분리

Author: tape4

src/lexer/lexer.rs

@@ -1,6 +1,7 @@
 use super::token::{LexError, SpannedToken, Token, lookup_ident};
 
 /// 렉서 구조
+#[allow(dead_code)]
 pub struct Lexer {
     input: Vec<char>, // full codes
     pos: usize,       // current position
@@ -10,6 +11,7 @@ pub struct Lexer {
     column: usize,    // current column
 }
 
+#[allow(dead_code)]
 impl Lexer {
     pub fn new(input: &str) -> Self {
         let mut l = Lexer {

src/lexer/mod.rs

@@ -1,6 +1,6 @@
-pub mod lexer;
+mod lexer;
 pub mod token;
-
 pub use lexer::Lexer;
 pub use token::LexError;
+pub use token::SpannedToken;
 pub use token::Token;

src/lexer/token.rs

@@ -15,6 +15,7 @@ pub struct SpannedToken {
 }
 
 /// Token types
+#[allow(dead_code)]
 #[derive(Debug, PartialEq, Clone)]
 pub enum Token {
     // Special
@@ -88,6 +89,7 @@ pub enum Token {
 }
 
 /// Lookup identifier keyword
+#[allow(dead_code)]
 pub fn lookup_ident(ident: &str) -> Token {
     match ident {
         "int" => Token::Int,

src/lib.rs

@@ -2,3 +2,7 @@ pub mod ast;
 pub mod lexer;
 pub mod parser;
 pub mod semantic;
+
+pub use lexer::Lexer;
+pub use parser::Parser;
+pub use semantic::Analyzer as SemanticAnalyzer;

src/main.rs

@@ -1,9 +1,4 @@
-use rustc_tape4::lexer::Lexer;
-use rustc_tape4::parser::Parser;
-use rustc_tape4::semantic;
-use semantic::analyzer::analyzer::Analyzer;
-
-mod lexer;
+use rustc_tape4::{Lexer, Parser, SemanticAnalyzer};
 
 fn main() {
     let source = std::fs::read_to_string("tests/fixtures/sample.c").expect("could not read file");
@@ -15,9 +10,7 @@ fn main() {
     let mut parser = Parser::new(tokens);
     let program = parser.parse_program().expect("Parsing Failed");
 
-    // println!("{:#?}", program);
     // semantic analysis
-    let mut analyzer = Analyzer::new(&program);
-    let result = analyzer.analyze().expect("Analyzing Failed");
-    // println!("Hello, world!");
+    let mut analyzer = SemanticAnalyzer::new(&program);
+    let _result = analyzer.analyze().expect("Analyzing Failed");
 }

src/parser/error_helpers.rs

@@ -2,7 +2,6 @@ use crate::lexer::Token;
 use crate::parser::Parser;
 use crate::parser::error::ParserError;
 use crate::parser::parser::ParseResult;
-
 // #[macro_export]
 // macro_rules! expect {
 //     ($p:expr, $pat:pat_param) => {{

src/parser/mod.rs

@@ -1,11 +1,9 @@
-#[macro_use]
+mod error;
 mod error_helpers;
-pub mod error;
-pub mod utils;
-
-pub mod expression;
-pub mod function;
-pub mod parser;
-pub mod statements;
-
+mod expression;
+mod function;
+mod parser;
+mod statements;
+mod utils;
+pub use parser::ParseResult;
 pub use parser::Parser;

src/parser/parser.rs

@@ -1,6 +1,5 @@
 use crate::ast::Program;
-use crate::lexer::Token;
-use crate::lexer::token::SpannedToken;
+use crate::lexer::{SpannedToken, Token};
 use crate::parser::error::ParserError;
 
 pub type ParseResult<T> = Result<T, ParserError>;

src/parser/statements.rs

@@ -1,7 +1,7 @@
 use crate::ast::Stmt;
 use crate::ast::Stmt::{Break, For, Return, While};
 use crate::ast::stmt::{Block, Declarator};
-use crate::lexer::Token;
+use crate::lexer::token::Token;
 use crate::parser::Parser;
 use crate::parser::parser::ParseResult;
 

src/parser/utils.rs

@@ -1,5 +1,5 @@
 use crate::ast::program::Pos;
-use crate::lexer::Token;
+use crate::lexer::token::Token;
 use crate::parser::Parser;
 use crate::parser::parser::ParseResult;