change syntax tree api for number token

CppCXY · CppCXY · commit 49a70d10c8a0 · 2025-12-12T14:24:23.000+08:00
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/decl/exprs.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/decl/exprs.rs
@@ -1,7 +1,7 @@
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaAstToken, LuaCallExpr, LuaClosureExpr, LuaDocTagCast, LuaExpr,
     LuaFuncStat, LuaIndexExpr, LuaIndexKey, LuaLiteralExpr, LuaLiteralToken, LuaNameExpr,
-    LuaTableExpr, LuaVarExpr,
+    LuaTableExpr, LuaVarExpr, NumberResult,
 };
 
 use crate::{
@@ -58,8 +58,8 @@ pub fn analyze_index_expr(analyzer: &mut DeclAnalyzer, index_expr: LuaIndexExpr)
     let key = match index_key {
         LuaIndexKey::Name(name) => LuaMemberKey::Name(name.get_name_text().to_string().into()),
         LuaIndexKey::Integer(int) => {
-            if int.is_int() {
-                LuaMemberKey::Integer(int.get_int_value())
+            if let NumberResult::Int(i) = int.get_number_value() {
+                LuaMemberKey::Integer(i)
             } else {
                 return None;
             }
@@ -232,7 +232,13 @@ pub fn analyze_table_expr(analyzer: &mut DeclAnalyzer, table_expr: LuaTableExpr)
                 let key: LuaMemberKey = match field_key {
                     LuaIndexKey::Name(name) => LuaMemberKey::Name(name.get_name_text().into()),
                     LuaIndexKey::String(str) => LuaMemberKey::Name(str.get_value().into()),
-                    LuaIndexKey::Integer(i) => LuaMemberKey::Integer(i.get_int_value()),
+                    LuaIndexKey::Integer(i) => {
+                        if let NumberResult::Int(idx) = i.get_number_value() {
+                            LuaMemberKey::Integer(idx)
+                        } else {
+                            continue;
+                        }
+                    }
                     LuaIndexKey::Idx(idx) => LuaMemberKey::Integer(idx as i64),
                     LuaIndexKey::Expr(field_expr) => {
                         let unresolve_member = UnResolveTableField {
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/decl/stats.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/decl/stats.rs
@@ -1,7 +1,7 @@
 use emmylua_parser::{
     LuaAssignStat, LuaAstNode, LuaAstToken, LuaExpr, LuaForRangeStat, LuaForStat, LuaFuncStat,
     LuaIndexExpr, LuaIndexKey, LuaLocalFuncStat, LuaLocalStat, LuaSyntaxId, LuaSyntaxKind,
-    LuaVarExpr,
+    LuaVarExpr, NumberResult,
 };
 
 use crate::{
@@ -108,7 +108,13 @@ pub fn analyze_assign_stat(analyzer: &mut DeclAnalyzer, stat: LuaAssignStat) ->
                 let key: LuaMemberKey = match index_key {
                     LuaIndexKey::Name(name) => LuaMemberKey::Name(name.get_name_text().into()),
                     LuaIndexKey::String(str) => LuaMemberKey::Name(str.get_value().into()),
-                    LuaIndexKey::Integer(i) => LuaMemberKey::Integer(i.get_int_value()),
+                    LuaIndexKey::Integer(i) => {
+                        if let NumberResult::Int(idx) = i.get_number_value() {
+                            LuaMemberKey::Integer(idx)
+                        } else {
+                            continue;
+                        }
+                    }
                     LuaIndexKey::Idx(idx) => LuaMemberKey::Integer(idx as i64),
                     LuaIndexKey::Expr(_) => {
                         continue;
@@ -255,7 +261,13 @@ pub fn analyze_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaFuncStat) -> Opti
             let key: LuaMemberKey = match index_key {
                 LuaIndexKey::Name(name) => LuaMemberKey::Name(name.get_name_text().into()),
                 LuaIndexKey::String(str) => LuaMemberKey::Name(str.get_value().into()),
-                LuaIndexKey::Integer(i) => LuaMemberKey::Integer(i.get_int_value()),
+                LuaIndexKey::Integer(i) => {
+                    if let NumberResult::Int(idx) = i.get_number_value() {
+                        LuaMemberKey::Integer(idx)
+                    } else {
+                        return None;
+                    }
+                }
                 LuaIndexKey::Idx(idx) => LuaMemberKey::Integer(idx as i64),
                 LuaIndexKey::Expr(_) => {
                     return None;
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/attribute_tags.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/attribute_tags.rs
@@ -1,6 +1,6 @@
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaDocTagAttributeUse, LuaDocType, LuaExpr, LuaKind, LuaLiteralExpr,
-    LuaLiteralToken, LuaSyntaxKind, LuaSyntaxNode, LuaTokenKind,
+    LuaLiteralToken, LuaSyntaxKind, LuaSyntaxNode, LuaTokenKind, NumberResult,
 };
 use smol_str::SmolStr;
 
@@ -110,8 +110,8 @@ fn infer_attribute_arg_type(expr: LuaLiteralExpr) -> LuaType {
                 return LuaType::DocStringConst(SmolStr::new(str_token.get_value()).into());
             }
             LuaLiteralToken::Number(number_token) => {
-                if number_token.is_int() {
-                    return LuaType::DocIntegerConst(number_token.get_int_value());
+                if let NumberResult::Int(i) = number_token.get_number_value() {
+                    return LuaType::DocIntegerConst(i);
                 } else {
                     return LuaType::Number;
                 }
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/field_or_operator_def_tags.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/field_or_operator_def_tags.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use emmylua_parser::{
     LuaAstNode, LuaAstToken, LuaDocDescriptionOwner, LuaDocFieldKey, LuaDocTagField,
-    LuaDocTagOperator, LuaDocType, VisibilityKind,
+    LuaDocTagOperator, LuaDocType, NumberResult, VisibilityKind,
 };
 
 use crate::{
@@ -79,7 +79,13 @@ pub fn analyze_field(analyzer: &mut DocAnalyzer, tag: LuaDocTagField) -> Option<
             LuaMemberKey::Name(name_token.get_name_text().to_string().into())
         }
         LuaDocFieldKey::String(string_token) => LuaMemberKey::Name(string_token.get_value().into()),
-        LuaDocFieldKey::Integer(int_token) => LuaMemberKey::Integer(int_token.get_int_value()),
+        LuaDocFieldKey::Integer(int_token) => {
+            if let NumberResult::Int(idx) = int_token.get_number_value() {
+                LuaMemberKey::Integer(idx)
+            } else {
+                return None;
+            }
+        }
         LuaDocFieldKey::Type(doc_type) => {
             let range = doc_type.get_range();
             let key_type_ref = infer_type(analyzer, doc_type);
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/infer_type.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/infer_type.rs
@@ -6,7 +6,7 @@ use emmylua_parser::{
     LuaDocGenericType, LuaDocIndexAccessType, LuaDocInferType, LuaDocMappedType,
     LuaDocMultiLineUnionType, LuaDocObjectFieldKey, LuaDocObjectType, LuaDocStrTplType, LuaDocType,
     LuaDocUnaryType, LuaDocVariadicType, LuaLiteralToken, LuaSyntaxKind, LuaTypeBinaryOperator,
-    LuaTypeUnaryOperator, LuaVarExpr,
+    LuaTypeUnaryOperator, LuaVarExpr, NumberResult,
 };
 use internment::ArcIntern;
 use rowan::TextRange;
@@ -62,8 +62,8 @@ pub fn infer_type(analyzer: &mut DocAnalyzer, node: LuaDocType) -> LuaType {
                         return LuaType::DocStringConst(SmolStr::new(str_token.get_value()).into());
                     }
                     LuaLiteralToken::Number(number_token) => {
-                        if number_token.is_int() {
-                            return LuaType::DocIntegerConst(number_token.get_int_value());
+                        if let NumberResult::Int(i) = number_token.get_number_value() {
+                            return LuaType::DocIntegerConst(i);
                         } else {
                             return LuaType::Number;
                         }
@@ -601,7 +601,11 @@ fn infer_object_type(analyzer: &mut DocAnalyzer, object_type: &LuaDocObjectType)
                     LuaIndexAccessKey::String(name.get_name_text().to_string().into())
                 }
                 LuaDocObjectFieldKey::Integer(int) => {
-                    LuaIndexAccessKey::Integer(int.get_int_value())
+                    if let NumberResult::Int(i) = int.get_number_value() {
+                        LuaIndexAccessKey::Integer(i)
+                    } else {
+                        continue;
+                    }
                 }
                 LuaDocObjectFieldKey::String(str) => {
                     LuaIndexAccessKey::String(str.get_value().to_string().into())
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/find_decl_function.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/find_decl_function.rs
@@ -1,4 +1,4 @@
-use emmylua_parser::{LuaAstNode, LuaIndexKey, LuaIndexMemberExpr};
+use emmylua_parser::{LuaAstNode, LuaIndexKey, LuaIndexMemberExpr, NumberResult};
 use rowan::TextRange;
 use smol_str::SmolStr;
 
@@ -304,7 +304,13 @@ fn find_index_metamethod(
     let access_key_type = match &index_key {
         LuaIndexKey::Name(name) => LuaType::StringConst(SmolStr::new(name.get_name_text()).into()),
         LuaIndexKey::String(s) => LuaType::StringConst(SmolStr::new(s.get_value()).into()),
-        LuaIndexKey::Integer(i) => LuaType::IntegerConst(i.get_int_value()),
+        LuaIndexKey::Integer(i) => {
+            if let NumberResult::Int(idx) = i.get_number_value() {
+                LuaType::IntegerConst(idx)
+            } else {
+                return Err(InferFailReason::FieldNotFound);
+            }
+        }
         LuaIndexKey::Idx(i) => LuaType::IntegerConst(*i as i64),
         LuaIndexKey::Expr(expr) => infer_expr(db, cache, expr.clone())?,
     };
diff --git a/crates/emmylua_code_analysis/src/db_index/member/lua_member.rs b/crates/emmylua_code_analysis/src/db_index/member/lua_member.rs
@@ -1,6 +1,6 @@
 use std::ops::Deref;
 
-use emmylua_parser::{LuaIndexKey, LuaSyntaxId, LuaSyntaxKind};
+use emmylua_parser::{LuaIndexKey, LuaSyntaxId, LuaSyntaxKind, NumberResult};
 use rowan::{TextRange, TextSize};
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
@@ -107,7 +107,13 @@ impl LuaMemberKey {
         match key {
             LuaIndexKey::Name(name) => Ok(LuaMemberKey::Name(name.get_name_text().into())),
             LuaIndexKey::String(str) => Ok(LuaMemberKey::Name(str.get_value().into())),
-            LuaIndexKey::Integer(i) => Ok(LuaMemberKey::Integer(i.get_int_value())),
+            LuaIndexKey::Integer(i) => {
+                if let NumberResult::Int(idx) = i.get_number_value() {
+                    Ok(LuaMemberKey::Integer(idx))
+                } else {
+                    Err(InferFailReason::FieldNotFound)
+                }
+            }
             LuaIndexKey::Idx(idx) => Ok(LuaMemberKey::Integer(*idx as i64)),
             LuaIndexKey::Expr(expr) => {
                 let expr_type = infer_expr(db, cache, expr.clone())?;
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_doc_type.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_doc_type.rs
@@ -4,7 +4,7 @@ use emmylua_parser::{
     LuaAstNode, LuaDocAttributeType, LuaDocBinaryType, LuaDocDescriptionOwner, LuaDocFuncType,
     LuaDocGenericType, LuaDocMultiLineUnionType, LuaDocObjectFieldKey, LuaDocObjectType,
     LuaDocStrTplType, LuaDocType, LuaDocUnaryType, LuaDocVariadicType, LuaLiteralToken,
-    LuaSyntaxKind, LuaTypeBinaryOperator, LuaTypeUnaryOperator,
+    LuaSyntaxKind, LuaTypeBinaryOperator, LuaTypeUnaryOperator, NumberResult,
 };
 use rowan::TextRange;
 use smol_str::SmolStr;
@@ -65,8 +65,8 @@ pub fn infer_doc_type(ctx: DocTypeInferContext<'_>, node: &LuaDocType) -> LuaTyp
                         return LuaType::DocStringConst(SmolStr::new(str_token.get_value()).into());
                     }
                     LuaLiteralToken::Number(number_token) => {
-                        if number_token.is_int() {
-                            return LuaType::DocIntegerConst(number_token.get_int_value());
+                        if let NumberResult::Int(i) = number_token.get_number_value() {
+                            return LuaType::DocIntegerConst(i);
                         } else {
                             return LuaType::Number;
                         }
@@ -471,7 +471,11 @@ fn infer_object_type(ctx: DocTypeInferContext<'_>, object_type: &LuaDocObjectTyp
                     LuaIndexAccessKey::String(name.get_name_text().to_string().into())
                 }
                 LuaDocObjectFieldKey::Integer(int) => {
-                    LuaIndexAccessKey::Integer(int.get_int_value())
+                    if let NumberResult::Int(i) = int.get_number_value() {
+                        LuaIndexAccessKey::Integer(i)
+                    } else {
+                        continue;
+                    }
                 }
                 LuaDocObjectFieldKey::String(str) => {
                     LuaIndexAccessKey::String(str.get_value().to_string().into())
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs
@@ -1,8 +1,8 @@
 use std::collections::HashSet;
 
 use emmylua_parser::{
-    LuaAstNode, LuaExpr, LuaForStat, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, PathTrait,
-    UnaryOperator,
+    LuaAstNode, LuaExpr, LuaForStat, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, NumberResult,
+    PathTrait, UnaryOperator,
 };
 use internment::ArcIntern;
 use rowan::TextRange;
@@ -240,9 +240,10 @@ fn infer_array_member(
             match array_type.get_len() {
                 LuaArrayLen::None => {}
                 LuaArrayLen::Max(max_len) => {
-                    let index_value = i.get_int_value();
-                    if index_value > 0 && index_value <= *max_len {
-                        return Ok(base_type.clone());
+                    if let NumberResult::Int(index_value) = i.get_number_value() {
+                        if index_value > 0 && index_value <= *max_len {
+                            return Ok(base_type.clone());
+                        }
                     }
                 }
             }
@@ -648,7 +649,13 @@ fn infer_index_metamethod(
     let access_key_type = match &index_key {
         LuaIndexKey::Name(name) => LuaType::StringConst(SmolStr::new(name.get_name_text()).into()),
         LuaIndexKey::String(s) => LuaType::StringConst(SmolStr::new(s.get_value()).into()),
-        LuaIndexKey::Integer(i) => LuaType::IntegerConst(i.get_int_value()),
+        LuaIndexKey::Integer(i) => {
+            if let NumberResult::Int(index_value) = i.get_number_value() {
+                LuaType::IntegerConst(index_value)
+            } else {
+                return Err(InferFailReason::FieldNotFound);
+            }
+        }
         LuaIndexKey::Idx(i) => LuaType::IntegerConst(*i as i64),
         LuaIndexKey::Expr(expr) => infer_expr(db, cache, expr.clone())?,
     };
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/mod.rs b/crates/emmylua_code_analysis/src/semantic/infer/mod.rs
@@ -13,7 +13,7 @@ use std::ops::Deref;
 
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaCallExpr, LuaClosureExpr, LuaExpr, LuaLiteralExpr, LuaLiteralToken,
-    LuaTableExpr, LuaVarExpr,
+    LuaTableExpr, LuaVarExpr, NumberResult,
 };
 use infer_binary::infer_binary_expr;
 use infer_call::infer_call_expr;
@@ -115,15 +115,11 @@ fn infer_literal_expr(db: &DbIndex, config: &LuaInferCache, expr: LuaLiteralExpr
     match expr.get_literal().ok_or(InferFailReason::None)? {
         LuaLiteralToken::Nil(_) => Ok(LuaType::Nil),
         LuaLiteralToken::Bool(bool) => Ok(LuaType::BooleanConst(bool.is_true())),
-        LuaLiteralToken::Number(num) => {
-            if num.is_int() {
-                Ok(LuaType::IntegerConst(num.get_int_value()))
-            } else if num.is_float() {
-                Ok(LuaType::FloatConst(num.get_float_value()))
-            } else {
-                Ok(LuaType::Number)
-            }
-        }
+        LuaLiteralToken::Number(num) => match num.get_number_value() {
+            NumberResult::Int(i) => Ok(LuaType::IntegerConst(i)),
+            NumberResult::Float(f) => Ok(LuaType::FloatConst(f)),
+            _ => Ok(LuaType::Number),
+        },
         LuaLiteralToken::String(str) => {
             Ok(LuaType::StringConst(SmolStr::new(str.get_value()).into()))
         }
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/var_ref_id.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/var_ref_id.rs
@@ -110,7 +110,7 @@ fn get_call_expr_var_ref_id(
                         access_path.push_str(string_token.get_value().as_str());
                     }
                     LuaLiteralToken::Number(number_token) => {
-                        access_path.push_str(number_token.get_int_value().to_string().as_str());
+                        access_path.push_str(number_token.get_number_value().to_string().as_str());
                     }
                     _ => return None,
                 },
diff --git a/crates/emmylua_ls/src/handlers/document_symbol/expr.rs b/crates/emmylua_ls/src/handlers/document_symbol/expr.rs
@@ -108,7 +108,7 @@ pub fn build_table_symbol(
             let str_key = match key {
                 LuaIndexKey::String(key) => key.get_value(),
                 LuaIndexKey::Name(key) => key.get_name_text().to_string(),
-                LuaIndexKey::Integer(i) => i.get_int_value().to_string(),
+                LuaIndexKey::Integer(i) => i.get_number_value().to_string(),
                 _ => continue,
             };
 
diff --git a/crates/emmylua_ls/src/handlers/inlay_hint/build_inlay_hint.rs b/crates/emmylua_ls/src/handlers/inlay_hint/build_inlay_hint.rs
@@ -757,7 +757,7 @@ fn process_enum_hint_for_arg(
                     }
                     LuaLiteralToken::Number(number_token) => {
                         if number_token.is_int() {
-                            let number_value = format!("[{}]", number_token.get_int_value());
+                            let number_value = format!("[{}]", number_token.get_number_value());
                             if number_value == member_name {
                                 return None;
                             }
diff --git a/crates/emmylua_parser/src/syntax/node/lua/mod.rs b/crates/emmylua_parser/src/syntax/node/lua/mod.rs
@@ -382,7 +382,7 @@ impl LuaIndexKey {
             LuaIndexKey::String(s) => s.get_value(),
             LuaIndexKey::Name(name) => name.get_name_text().to_string(),
             LuaIndexKey::Integer(i) => {
-                format!("[{}]", i.get_int_value())
+                format!("[{}]", i.get_number_value())
             }
             LuaIndexKey::Expr(expr) => {
                 format!("[{}]", expr.syntax().text())
diff --git a/crates/emmylua_parser/src/syntax/node/lua/path_trait.rs b/crates/emmylua_parser/src/syntax/node/lua/path_trait.rs
@@ -31,7 +31,7 @@ pub trait PathTrait: LuaAstNode {
                             paths.push(name.get_name_text().to_string());
                         }
                         LuaIndexKey::Integer(i) => {
-                            paths.push(i.get_int_value().to_string());
+                            paths.push(i.get_number_value().to_string());
                         }
                         LuaIndexKey::Expr(expr) => {
                             let text = format!("[{}]", expr.syntax().text());
diff --git a/crates/emmylua_parser/src/syntax/node/token/mod.rs b/crates/emmylua_parser/src/syntax/node/token/mod.rs
@@ -3,7 +3,7 @@ mod string_analyzer;
 mod test;
 mod tokens;
 
-pub use number_analyzer::{float_token_value, int_token_value};
+pub use number_analyzer::{NumberResult, float_token_value, int_token_value};
 pub use string_analyzer::string_token_value;
 #[allow(unused)]
 pub use tokens::*;
diff --git a/crates/emmylua_parser/src/syntax/node/token/number_analyzer.rs b/crates/emmylua_parser/src/syntax/node/token/number_analyzer.rs
diff --git a/crates/emmylua_parser/src/syntax/node/token/tokens.rs b/crates/emmylua_parser/src/syntax/node/token/tokens.rs
