support const function and add more analysis for safe nav

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/decl/stats.rs

@@ -317,6 +317,11 @@ pub fn analyze_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaFuncStat) -> Opti
 pub fn analyze_local_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalFuncStat) -> Option<()> {
     let local_name = stat.get_local_name()?;
     let name_token = local_name.get_name_token()?;
+    let is_const = if stat.is_const() {
+        Some(LocalAttribute::Const)
+    } else {
+        None
+    };
     let name = name_token.get_name_text();
     let range = local_name.get_range();
     let file_id = analyzer.get_file_id();
@@ -326,7 +331,7 @@ pub fn analyze_local_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalFuncSt
         range,
         LuaDeclExtra::Local {
             kind: local_name.syntax().kind(),
-            attrib: None,
+            attrib: is_const,
         },
         None,
     );

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_binary_expr.rs

@@ -18,6 +18,7 @@ pub fn bind_binary_expr(
     match op_token.get_op() {
         BinaryOperator::OpAnd => bind_and_expr(binder, binary_expr, current),
         BinaryOperator::OpOr => bind_or_expr(binder, binary_expr, current),
+        BinaryOperator::OpNilCoalescing => bind_or_expr(binder, binary_expr, current),
         _ => {
             bind_each_child(binder, LuaAst::LuaBinaryExpr(binary_expr.clone()), current);
             Some(())
@@ -74,7 +75,7 @@ pub fn is_binary_logical(expr: &LuaExpr) -> bool {
 
             return matches!(
                 op_token.get_op(),
-                BinaryOperator::OpAnd | BinaryOperator::OpOr
+                BinaryOperator::OpAnd | BinaryOperator::OpOr | BinaryOperator::OpNilCoalescing
             );
         }
         LuaExpr::ParenExpr(paren_expr) => {

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs

@@ -95,10 +95,34 @@ pub fn bind_index_expr(
     current: FlowId,
 ) -> Option<()> {
     binder.bind_syntax_node(index_expr.get_syntax_id(), current);
+    if index_expr.is_safe_index() {
+        return bind_safe_index_expr(binder, index_expr, current);
+    }
     bind_each_child(binder, LuaAst::LuaIndexExpr(index_expr.clone()), current);
     Some(())
 }
 
+fn bind_safe_index_expr(
+    binder: &mut FlowBinder,
+    index_expr: LuaIndexExpr,
+    current: FlowId,
+) -> Option<()> {
+    let prefix_expr = index_expr.get_prefix_expr()?;
+
+    let pre_access = binder.create_branch_label();
+    bind_condition_expr(
+        binder,
+        prefix_expr,
+        current,
+        pre_access,
+        binder.false_target,
+    );
+    let current = finish_flow_label(binder, pre_access, current);
+
+    bind_each_child(binder, LuaAst::LuaIndexExpr(index_expr), current);
+    Some(())
+}
+
 pub fn bind_paren_expr(
     binder: &mut FlowBinder,
     paren_expr: emmylua_parser::LuaParenExpr,

crates/emmylua_code_analysis/src/diagnostic/checker/need_check_nil.rs

@@ -35,6 +35,10 @@ fn check_call_expr(
     semantic_model: &SemanticModel,
     call_expr: LuaCallExpr,
 ) -> Option<()> {
+    if call_expr.has_safe_navigation() {
+        return None;
+    }
+
     let prefix = call_expr.get_prefix_expr()?;
     let func = semantic_model.infer_expr(prefix.clone()).ok()?;
     if func.is_nullable() {

crates/emmylua_code_analysis/src/semantic/infer/infer_binary/mod.rs

@@ -113,6 +113,9 @@ fn infer_binary_expr_type(
         BinaryOperator::OpConcat => infer_binary_expr_concat(db, left_type, right_type),
         BinaryOperator::OpOr => infer_binary_expr_or(db, left_type, right_type),
         BinaryOperator::OpAnd => infer_binary_expr_and(db, left_type, right_type),
+        BinaryOperator::OpNilCoalescing => {
+            infer_binary_expr_nil_coalescing(db, left_type, right_type)
+        }
         BinaryOperator::OpLt
         | BinaryOperator::OpLe
         | BinaryOperator::OpGt
@@ -537,3 +540,20 @@ fn float_cmp(left: f64, right: f64, op: BinaryOperator) -> bool {
         _ => false,
     }
 }
+
+fn infer_binary_expr_nil_coalescing(db: &DbIndex, left: LuaType, right: LuaType) -> InferResult {
+    if left.is_nil() || left.is_any() || left.is_unknown() {
+        return Ok(right);
+    }
+
+    if right.is_nil() || right.is_any() || right.is_unknown() {
+        return Ok(left);
+    }
+
+    let left_without_nil = TypeOps::Remove.apply(db, &left, &LuaType::Nil);
+    if left_without_nil.is_unknown() {
+        return Ok(right);
+    }
+
+    Ok(TypeOps::Union.apply(db, &left_without_nil, &right))
+}

crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs

@@ -12,7 +12,7 @@ use crate::semantic::overload_resolve::callable_accepts_args;
 use crate::{
     AsyncState, CacheEntry, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType,
     LuaIntersectionType, LuaOperatorMetaMethod, LuaOperatorOwner, LuaSignature, LuaSignatureId,
-    LuaType, LuaTypeDeclId, LuaUnionType, TypeVisitTrait, VariadicType,
+    LuaType, LuaTypeDeclId, LuaUnionType, TypeOps, TypeVisitTrait, VariadicType,
 };
 use crate::{
     InferGuardRef,
@@ -767,19 +767,27 @@ pub fn infer_call_expr(
 
     check_can_infer(db, cache, &call_expr)?;
 
+    let is_safe_call = call_expr.has_safe_navigation();
+
     let prefix_expr = call_expr.get_prefix_expr().ok_or(InferFailReason::None)?;
     let prefix_type = infer_expr(db, cache, prefix_expr)?;
     let ret_type = infer_call_expr_func(
         db,
         cache,
         call_expr.clone(),
-        prefix_type,
+        prefix_type.clone(),
         &InferGuard::new(),
         None,
     )?
     .get_ret()
     .clone();
 
+    let ret_type = if is_safe_call && prefix_type.is_nullable() {
+        TypeOps::Union.apply(db, &ret_type, &LuaType::Nil)
+    } else {
+        ret_type
+    };
+
     if !cache.is_no_flow()
         && let Some(tree) = db.get_flow_index().get_flow_tree(&cache.get_file_id())
         && let Some(flow_id) = tree.get_flow_id(call_expr.get_syntax_id())

crates/emmylua_code_analysis/src/semantic/infer/infer_index/mod.rs

@@ -75,6 +75,7 @@ pub fn infer_index_expr(
     index_expr: LuaIndexExpr,
     pass_flow: bool,
 ) -> InferResult {
+    let is_safe = index_expr.is_safe_index();
     let prefix_expr = index_expr.get_prefix_expr().ok_or(InferFailReason::None)?;
     let prefix_type = infer_expr_for_index(db, cache, prefix_expr)?;
     let index_member_expr = LuaIndexMemberExpr::IndexExpr(index_expr.clone());
@@ -87,10 +88,16 @@ pub fn infer_index_expr(
         &InferGuard::new(),
     )?;
 
+    let result_type = if is_safe && prefix_type.is_nullable() {
+        TypeOps::Union.apply(db, &member_type, &LuaType::Nil)
+    } else {
+        member_type
+    };
+
     if pass_flow {
-        infer_member_type_pass_flow(db, cache, index_expr, member_type)
+        infer_member_type_pass_flow(db, cache, index_expr, result_type)
     } else {
-        Ok(member_type)
+        Ok(result_type)
     }
 }
 

crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/binary_flow.rs

@@ -83,10 +83,37 @@ pub fn get_type_at_binary_expr(
             condition_flow,
             false,
         ),
+        BinaryOperator::OpNilCoalescing => {
+            try_get_at_nil_coalescing(db, cache, var_ref_id, left_expr, condition_flow)
+        }
         _ => Ok(ConditionFlowAction::Continue),
     }
 }
 
+fn try_get_at_nil_coalescing(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    var_ref_id: &VarRefId,
+    left_expr: LuaExpr,
+    condition_flow: InferConditionFlow,
+) -> Result<ConditionFlowAction, InferFailReason> {
+    let Some(left_ref_id) = get_var_expr_var_ref_id(db, cache, left_expr) else {
+        return Ok(ConditionFlowAction::Continue);
+    };
+
+    if !var_ref_id.eq(&left_ref_id) {
+        return Ok(ConditionFlowAction::Continue);
+    }
+
+    if condition_flow == InferConditionFlow::FalseCondition {
+        Ok(ConditionFlowAction::Pending(
+            PendingConditionNarrow::NarrowTo(LuaType::Nil),
+        ))
+    } else {
+        Ok(ConditionFlowAction::Continue)
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 fn try_get_at_eq_or_neq_expr(
     db: &DbIndex,

crates/emmylua_parser/src/grammar/lua/stat.rs

@@ -646,10 +646,33 @@ fn parse_local(p: &mut LuaParser) -> ParseResult {
 }
 
 fn parse_const(p: &mut LuaParser) -> ParseResult {
-    let m = p.mark(LuaSyntaxKind::ConstStat);
+    let mut m = p.mark(LuaSyntaxKind::ConstStat);
     p.bump(); // consume 'const'
 
     match p.current_token() {
+        LuaTokenKind::TkFunction => {
+            p.bump();
+            m.set_kind(p, LuaSyntaxKind::LocalFuncStat);
+
+            match parse_local_name(p, false) {
+                Ok(_) => {}
+                Err(_) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("expected function name after 'local function'"),
+                        p.current_token_range(),
+                    ));
+                }
+            }
+            match parse_closure_expr(p) {
+                Ok(_) => {}
+                Err(_) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("invalid function definition"),
+                        p.current_token_range(),
+                    ));
+                }
+            }
+        }
         LuaTokenKind::TkName => {
             parse_variable_name_list(p, false)?;
 

crates/emmylua_parser/src/syntax/node/lua/stat.rs

@@ -440,6 +440,10 @@ impl LuaLocalFuncStat {
     pub fn get_closure(&self) -> Option<LuaClosureExpr> {
         self.child()
     }
+
+    pub fn is_const(&self) -> bool {
+        self.token_by_kind(LuaTokenKind::TkConst).is_some()
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]