optimize or infer and remove nil

Close #392

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_up.rs

@@ -84,12 +84,12 @@ pub fn broadcast_up(
 
                     if let LuaExpr::LiteralExpr(literal) = expr {
                         let type_assert = match literal.get_literal()? {
-                            LuaLiteralToken::Nil(_) => TypeAssertion::NotExist,
+                            LuaLiteralToken::Nil(_) => TypeAssertion::Force(LuaType::Nil),
                             LuaLiteralToken::Bool(b) => {
                                 if b.is_true() {
-                                    TypeAssertion::Exist
+                                    TypeAssertion::Force(LuaType::BooleanConst(true))
                                 } else {
-                                    TypeAssertion::NotExist
+                                    TypeAssertion::Force(LuaType::BooleanConst(false))
                                 }
                             }
                             LuaLiteralToken::Number(i) => {
@@ -127,12 +127,12 @@ pub fn broadcast_up(
 
                     if let LuaExpr::LiteralExpr(literal) = expr {
                         let type_assert = match literal.get_literal()? {
-                            LuaLiteralToken::Nil(_) => TypeAssertion::Exist,
+                            LuaLiteralToken::Nil(_) => TypeAssertion::Remove(LuaType::Nil),
                             LuaLiteralToken::Bool(b) => {
                                 if b.is_true() {
-                                    TypeAssertion::NotExist
+                                    TypeAssertion::Remove(LuaType::BooleanConst(true))
                                 } else {
-                                    TypeAssertion::Exist
+                                    TypeAssertion::Remove(LuaType::BooleanConst(false))
                                 }
                             }
                             LuaLiteralToken::Number(i) => {

crates/emmylua_code_analysis/src/db_index/type/type_assert.rs

@@ -48,7 +48,7 @@ impl TypeAssertion {
         source: LuaType,
     ) -> Result<LuaType, InferFailReason> {
         match self {
-            TypeAssertion::Exist => Ok(TypeOps::Remove.apply(&source, &LuaType::Nil)),
+            TypeAssertion::Exist => Ok(TypeOps::RemoveNilOrFalse.apply_source(&source)),
             TypeAssertion::NotExist => Ok(TypeOps::NarrowFalseOrNil.apply_source(&source)),
             TypeAssertion::Narrow(t) => Ok(TypeOps::Narrow.apply(&source, t)),
             TypeAssertion::Add(lua_type) => Ok(TypeOps::Union.apply(&source, lua_type)),

crates/emmylua_code_analysis/src/db_index/type/type_ops/false_or_nil_type.rs

@@ -1,4 +1,4 @@
-use crate::LuaType;
+use crate::{LuaType, LuaUnionType};
 
 use super::TypeOps;
 
@@ -9,3 +9,34 @@ pub fn narrow_false_or_nil(t: LuaType) -> LuaType {
 
     return TypeOps::Narrow.apply(&t, &LuaType::Nil);
 }
+
+pub fn remove_false_or_nil(t: LuaType) -> LuaType {
+    match t {
+        LuaType::Nil => LuaType::Unknown,
+        LuaType::BooleanConst(false) => LuaType::Unknown,
+        LuaType::DocBooleanConst(false) => LuaType::Unknown,
+        LuaType::Boolean => LuaType::BooleanConst(true),
+        LuaType::Union(u) => {
+            let types = u.get_types();
+            let mut new_types = vec![];
+            for it in types.iter() {
+                match it {
+                    LuaType::Nil => {}
+                    LuaType::BooleanConst(false) => {}
+                    LuaType::DocBooleanConst(false) => {}
+                    LuaType::Boolean => new_types.push(LuaType::BooleanConst(true)),
+                    _ => new_types.push(it.clone()),
+                }
+            }
+
+            if new_types.is_empty() {
+                return LuaType::Unknown;
+            } else if new_types.len() == 1 {
+                return new_types[0].clone();
+            } else {
+                return LuaType::Union(LuaUnionType::new(new_types).into());
+            }
+        }
+        _ => t,
+    }
+}

crates/emmylua_code_analysis/src/db_index/type/type_ops/mod.rs

@@ -13,6 +13,8 @@ pub enum TypeOps {
     Union,
     /// Remove a type from the source type
     Remove,
+    /// Remove a type from the source type, but keep the source type
+    RemoveNilOrFalse,
     /// Force a type to the source type
     Narrow,
     /// Only keep the false or nil type
@@ -38,6 +40,7 @@ impl TypeOps {
     pub fn apply_source(&self, source: &LuaType) -> LuaType {
         match self {
             TypeOps::NarrowFalseOrNil => false_or_nil_type::narrow_false_or_nil(source.clone()),
+            TypeOps::RemoveNilOrFalse => false_or_nil_type::remove_false_or_nil(source.clone()),
             _ => source.clone(),
         }
     }

crates/emmylua_code_analysis/src/db_index/type/type_ops/remove_type.rs

@@ -10,24 +10,11 @@ pub fn remove_type(source: LuaType, removed_type: LuaType) -> Option<LuaType> {
     }
 
     match &removed_type {
-        LuaType::Nil => match &source {
-            LuaType::Boolean => return Some(LuaType::BooleanConst(true)),
-            LuaType::BooleanConst(b) => {
-                if *b {
-                    return Some(LuaType::BooleanConst(true));
-                } else {
-                    return None;
-                }
-            }
-            LuaType::DocBooleanConst(b) => {
-                if *b {
-                    return Some(LuaType::DocBooleanConst(true));
-                } else {
-                    return None;
-                }
+        LuaType::Nil => {
+            if source.is_nil() {
+                return None;
             }
-            _ => {}
-        },
+        }
         LuaType::Boolean => {
             if source.is_boolean() {
                 return None;

crates/emmylua_code_analysis/src/diagnostic/test/mod.rs

@@ -21,3 +21,4 @@ mod undefined_doc_param_test;
 mod undefined_field_test;
 mod undefined_global_test;
 mod unnecessary_assert_test;
+mod unnecessary_if_test;

crates/emmylua_code_analysis/src/diagnostic/test/unnecessary_if_test.rs

@@ -0,0 +1,17 @@
+#[cfg(test)]
+mod test {
+    use crate::{DiagnosticCode, VirtualWorkspace};
+
+    #[test]
+    fn test_issue_392() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.check_code_for(DiagnosticCode::UnnecessaryIf,
+        r#"
+        local a = false ---@type boolean|nil
+        if a == nil or a then -- Unnecessary `if` statement: this condition is always truthy [unnecessary-if]
+            print('a is not false')
+        end
+        "#
+        ));
+    }
+}

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

@@ -6,7 +6,7 @@ pub fn special_or_rule(
     db: &DbIndex,
     left_type: &LuaType,
     right_type: &LuaType,
-    _: LuaExpr,
+    left_expr: LuaExpr,
     right_expr: LuaExpr,
 ) -> Option<LuaType> {
     match right_expr {
@@ -23,10 +23,17 @@ pub fn special_or_rule(
             }
         }
         LuaExpr::LiteralExpr(_) => {
-            if !right_type.is_nil() {
-                if check_type_compact(db, &left_type, &right_type).is_ok() {
-                    return Some(TypeOps::Remove.apply(&left_type, &LuaType::Nil));
-                }
+            match left_expr {
+                LuaExpr::CallExpr(_) | LuaExpr::NameExpr(_) | LuaExpr::IndexExpr(_) => {}
+                _ => return None,
+            }
+
+            if right_type.is_nil() || left_type.is_const() {
+                return None;
+            }
+
+            if check_type_compact(db, &left_type, &right_type).is_ok() {
+                return Some(TypeOps::Remove.apply(&left_type, &LuaType::Nil));
             }
         }
 
@@ -43,6 +50,5 @@ pub fn infer_binary_expr_or(left: LuaType, right: LuaType) -> InferResult {
         return Ok(right);
     }
 
-    // if check_type_compact(db, source, compact_type)
-    Ok(TypeOps::Union.apply(&TypeOps::Remove.apply(&left, &LuaType::Nil), &right))
+    Ok(TypeOps::Union.apply(&&TypeOps::RemoveNilOrFalse.apply_source(&left), &right))
 }

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

@@ -26,11 +26,39 @@ pub fn infer_binary_expr(
         if let Some(ty) = special_or_rule(db, &left_type, &right_type, left, right) {
             return Ok(ty);
         }
+    } else if !matches!(op, BinaryOperator::OpAnd | BinaryOperator::OpOr) {
+        if let Some(ty) = infer_union_binary_expr(db, op, &left_type, &right_type) {
+            return Ok(ty);
+        }
     }
 
     infer_binary_expr_type(db, left_type, right_type, op)
 }
 
+fn infer_union_binary_expr(
+    db: &DbIndex,
+    op: BinaryOperator,
+    left_type: &LuaType,
+    right_type: &LuaType,
+) -> Option<LuaType> {
+    let (u, other) = if let LuaType::Union(u) = left_type {
+        (u, right_type)
+    } else if let LuaType::Union(u) = right_type {
+        (u, left_type)
+    } else {
+        return None;
+    };
+
+    let mut result = LuaType::Unknown;
+    let types = u.get_types();
+    for ty in types.iter() {
+        if let Ok(ty) = infer_binary_expr_type(db, ty.clone(), other.clone(), op) {
+            result = TypeOps::Union.apply(&result, &ty);
+        }
+    }
+    return Some(result);
+}
+
 fn infer_binary_expr_type(
     db: &DbIndex,
     left_type: LuaType,

crates/emmylua_doc_cli/src/markdown_generator/init_tl.rs

@@ -18,7 +18,10 @@ pub fn init_tl(override_template: Option<PathBuf>) -> Option<Tera> {
 
     if let Some(override_template) = override_template {
         if !override_template.exists() {
-            eprintln!("Override template directory does not exist: {:?}", override_template);
+            eprintln!(
+                "Override template directory does not exist: {:?}",
+                override_template
+            );
             return None;
         }