Merge pull request #268 from CppCXY/refactor-infer

refactor infer

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/lua/closure.rs

@@ -7,7 +7,8 @@ use crate::{
         UnResolveClosureParams, UnResolveClosureReturn, UnResolveReturn,
     },
     db_index::{LuaDocReturnInfo, LuaSignatureId},
-    infer_expr, DbIndex, LuaInferCache, LuaMultiReturn, LuaType, SignatureReturnStatus, TypeOps,
+    infer_expr, DbIndex, InferFailReason, LuaInferCache, LuaMultiReturn, LuaType,
+    SignatureReturnStatus, TypeOps,
 };
 
 use super::{func_body::analyze_func_body_returns, LuaAnalyzer, LuaReturnPoint};
@@ -99,12 +100,20 @@ fn analyze_return(
     let return_points = analyze_func_body_returns(block);
     let returns =
         match analyze_return_point(&analyzer.db, &mut analyzer.infer_cache, &return_points) {
-            Some(returns) => returns,
-            None => {
+            Ok(returns) => returns,
+            Err(InferFailReason::None) => {
+                vec![LuaDocReturnInfo {
+                    type_ref: LuaType::Unknown,
+                    description: None,
+                    name: None,
+                }]
+            }
+            Err(reason) => {
                 let unresolve = UnResolveReturn {
                     file_id: analyzer.file_id,
                     signature_id: signature_id.clone(),
                     return_points,
+                    reason,
                 };
 
                 analyzer.add_unresolved(unresolve.into());
@@ -150,7 +159,7 @@ pub fn analyze_return_point(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     return_points: &Vec<LuaReturnPoint>,
-) -> Option<Vec<LuaDocReturnInfo>> {
+) -> Result<Vec<LuaDocReturnInfo>, InferFailReason> {
     let mut return_type = LuaType::Unknown;
     for point in return_points {
         match point {
@@ -174,7 +183,7 @@ pub fn analyze_return_point(
         }
     }
 
-    Some(vec![LuaDocReturnInfo {
+    Ok(vec![LuaDocReturnInfo {
         type_ref: return_type,
         description: None,
         name: None,

crates/emmylua_code_analysis/src/compilation/analyzer/lua/mod.rs

@@ -19,7 +19,7 @@ use crate::{
     db_index::{DbIndex, LuaType},
     profile::Profile,
     semantic::{infer_expr, LuaInferCache},
-    CacheOptions, FileId, LuaAnalysisPhase, LuaMemberId, LuaMemberOwner,
+    CacheOptions, FileId, InferFailReason, LuaAnalysisPhase, LuaMemberId, LuaMemberOwner,
 };
 
 use super::{unresolve::UnResolve, AnalyzeContext};
@@ -120,7 +120,7 @@ impl LuaAnalyzer<'_> {
 }
 
 impl LuaAnalyzer<'_> {
-    pub fn infer_expr(&mut self, expr: &LuaExpr) -> Option<LuaType> {
+    pub fn infer_expr(&mut self, expr: &LuaExpr) -> Result<LuaType, InferFailReason> {
         infer_expr(self.db, &mut self.infer_cache, expr.clone())
     }
 

crates/emmylua_code_analysis/src/compilation/analyzer/lua/module.rs

@@ -1,8 +1,8 @@
 use emmylua_parser::{LuaAstNode, LuaChunk, LuaExpr};
 
 use crate::{
-    compilation::analyzer::unresolve::UnResolveModule, db_index::LuaType, LuaSemanticDeclId,
-    LuaSignatureId,
+    compilation::analyzer::unresolve::UnResolveModule, db_index::LuaType, InferFailReason,
+    LuaSemanticDeclId, LuaSignatureId,
 };
 
 use super::{func_body::analyze_func_body_returns, LuaAnalyzer, LuaReturnPoint};
@@ -13,13 +13,14 @@ pub fn analyze_chunk_return(analyzer: &mut LuaAnalyzer, chunk: LuaChunk) -> Opti
     for point in return_exprs {
         match point {
             LuaReturnPoint::Expr(expr) => {
-                let expr_type = analyzer.infer_expr(&expr);
-                let expr_type = match expr_type {
-                    Some(expr_type) => expr_type,
-                    None => {
+                let expr_type = match analyzer.infer_expr(&expr) {
+                    Ok(expr_type) => expr_type,
+                    Err(InferFailReason::None) => LuaType::Unknown,
+                    Err(reason) => {
                         let unresolve = UnResolveModule {
                             file_id: analyzer.file_id,
                             expr,
+                            reason,
                         };
                         analyzer.add_unresolved(unresolve.into());
                         return None;