Add a warning ``use-implicit-booleaness-not-comparison`` for comparison with collection literals (#5120)

* Create a new checker; use-implicit-booleanness checker where it looks
  for boolean evaluatiion with collection literals such as `()`, `[]`,
  or `{}`

* Fixed invalid usage of comparison within pylint package

This closes #4774

* Ignore tuples when checking for `literal-comparison`

Closes #3031

* Merge len_checker with empty_literal checker

Moving empty literal checker with len_checker to avoid class without
iterators without boolean expressions (false positive on pandas)
Reference: https://github.com/PyCQA/pylint/pull/3821/files

* Update `len_checker` and its class `LenChecker` to `ComparisonChecker`
  to reflect better usage after merging between `len_checker` and
  `empty_literal_checker` and its tests.

* Fixed `consider_using_in` and `consider_iterating_dictionary` tests
  that were failing due to new empty literal checkers.

Co-authored-by: Pierre Sassoulas <pierre.sassoulas@gmail.com>

2 files changed, 35 insertions, 13 deletions

diff --git a/tests/checkers/unittest_spelling.py b/tests/checkers/unittest_spelling.py
index 509cb502f..f9c335006 100644
--- a/tests/checkers/unittest_spelling.py
+++ b/tests/checkers/unittest_spelling.py
@@ -135,30 +135,30 @@ class TestSpellingChecker(CheckerTestCase):  # pylint:disable=too-many-public-me
     @set_config(spelling_dict=spell_dict)
     def test_skip_shebangs(self):
         self.checker.process_tokens(_tokenize_str("#!/usr/bin/env python"))
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
     def test_skip_python_coding_comments(self):
         self.checker.process_tokens(_tokenize_str("# -*- coding: utf-8 -*-"))
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
         self.checker.process_tokens(_tokenize_str("# coding=utf-8"))
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
         self.checker.process_tokens(_tokenize_str("# vim: set fileencoding=utf-8 :"))
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
         # Now with a shebang first
         self.checker.process_tokens(
             _tokenize_str("#!/usr/bin/env python\n# -*- coding: utf-8 -*-")
         )
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
         self.checker.process_tokens(
             _tokenize_str("#!/usr/bin/env python\n# coding=utf-8")
         )
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
         self.checker.process_tokens(
             _tokenize_str("#!/usr/bin/env python\n# vim: set fileencoding=utf-8 :")
         )
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
@@ -166,13 +166,13 @@ class TestSpellingChecker(CheckerTestCase):  # pylint:disable=too-many-public-me
         self.checker.process_tokens(
             _tokenize_str("# Line 1\n Line 2\n# pylint: disable=ungrouped-imports")
         )
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
     def test_skip_words_with_numbers(self):
         self.checker.process_tokens(_tokenize_str("\n# 0ne\n# Thr33\n# Sh3ll"))
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
@@ -244,7 +244,7 @@ class TestSpellingChecker(CheckerTestCase):  # pylint:disable=too-many-public-me
                 f'class TestClass(object):\n   """{ccn} comment"""\n   pass'
             )
             self.checker.visit_classdef(stmt)
-            assert self.linter.release_messages() == []
+            assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
@@ -253,19 +253,19 @@ class TestSpellingChecker(CheckerTestCase):  # pylint:disable=too-many-public-me
             'def fff(param_name):\n   """test param_name"""\n   pass'
         )
         self.checker.visit_functiondef(stmt)
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
     def test_skip_email_address(self):
         self.checker.process_tokens(_tokenize_str("# uname@domain.tld"))
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
     def test_skip_urls(self):
         self.checker.process_tokens(_tokenize_str("# https://github.com/rfk/pyenchant"))
-        assert self.linter.release_messages() == []
+        assert not self.linter.release_messages()
 
     @skip_on_missing_package_or_dict
     @set_config(spelling_dict=spell_dict)
diff --git a/tests/checkers/unittest_utils.py b/tests/checkers/unittest_utils.py
index 583bf3823..cb10d4fce 100644
--- a/tests/checkers/unittest_utils.py
+++ b/tests/checkers/unittest_utils.py
@@ -463,3 +463,25 @@ def test_if_typing_guard() -> None:
 
     assert isinstance(code[3], nodes.If)
     assert utils.is_typing_guard(code[3]) is False
+
+
+def test_is_empty_literal() -> None:
+    list_node = astroid.extract_node("a = []")
+    assert utils.is_empty_list_literal(list_node.value)
+    not_empty_list_node = astroid.extract_node("a = [1,2,3]")
+    assert not utils.is_empty_list_literal(not_empty_list_node.value)
+
+    tuple_node = astroid.extract_node("a = ()")
+    assert utils.is_empty_tuple_literal(tuple_node.value)
+    not_empty_tuple_node = astroid.extract_node("a = (1,2)")
+    assert not utils.is_empty_tuple_literal(not_empty_tuple_node.value)
+
+    dict_node = astroid.extract_node("a = {}")
+    assert utils.is_empty_dict_literal(dict_node.value)
+    not_empty_dict_node = astroid.extract_node("a = {1:1}")
+    assert not utils.is_empty_dict_literal(not_empty_dict_node.value)
+
+    string_node = astroid.extract_node("a = ''")
+    assert utils.is_empty_str_literal(string_node.value)
+    not_empty_string_node = astroid.extract_node("a = 'hello'")
+    assert not utils.is_empty_str_literal(not_empty_string_node.value)