Enable self-doc and PEP 701 f-string detection by default

They are now always-on but can be disabled by using `--no-feature`.

Author: netromdk

sample.vermin.ini

@@ -115,7 +115,8 @@
 #  argparse
 
 ### Features ###
-# Some features are disabled by default due to being unstable but can be enabled explicitly.
+# fstring-self-doc and fstring-pep701 are enabled by default. Other features must be enabled
+# explicitly. Use `--no-feature` to disable all features.
 #
 # Get full list via `--help`.
 #

tests/arguments.py

@@ -304,18 +304,31 @@ def test_no_tips(self):
     self.assertFalse(self.config.show_tips())
 
   def test_feature(self):
+    # Default features are enabled.
+    self.config.reset()
+    self.assertContainsDict({"code": 0}, self.parse_args(["--verbose"]))
+    self.assertEqualItems(Features.defaults(), self.config.features())
+
+    # `--feature` is additive on top of the default features.
+    self.config.reset()
+    self.assertContainsDict({"code": 0}, self.parse_args(["--feature", "union-types"]))
+    feats = Features.defaults() | {"union-types"}
+    self.assertEqualItems(feats, self.config.features())
+
     # Needs <name> part.
+    self.config.reset()
     self.assertContainsDict({"code": 1}, self.parse_args(["--feature"]))
-    self.assertEmpty(self.config.features())
+    self.assertEqualItems(Features.defaults(), self.config.features())
 
     # Unknown feature.
+    self.config.reset()
     self.assertContainsDict({"code": 1}, self.parse_args(["--feature", "foobarbaz"]))
-    self.assertEmpty(self.config.features())
+    self.assertEqualItems(Features.defaults(), self.config.features())
 
-    # Known features.
+    # Known features can be enabled individually after clearing all defaults.
     for feature in Features.features():
       self.config.reset()
-      self.assertContainsDict({"code": 0}, self.parse_args(["--feature", feature]))
+      self.assertContainsDict({"code": 0}, self.parse_args(["--no-feature", "--feature", feature]))
       self.assertEqualItems([feature], self.config.features())
       self.assertContainsDict({"code": 0}, self.parse_args(["--no-feature"]))
       self.assertEmpty(self.config.features())

tests/config.py

@@ -20,7 +20,7 @@ def test_defaults(self):
     self.assertFalse(self.config.analyze_hidden())
     self.assertEmpty(self.config.exclusions())
     self.assertEmpty(self.config.backports())
-    self.assertEmpty(self.config.features())
+    self.assertEqualItems(Features.defaults(), self.config.features())
     self.assertEmpty(self.config.targets())
     self.assertEqual("default", self.config.format().name())
     self.assertFalse(self.config.eval_annotations())

tests/lang.py

@@ -185,6 +185,26 @@ def test_self_doc_detected(self, source):
     self.config.enable_feature("fstring-self-doc")
     self.assert_self_doc(source)
 
+  @VerminTest.skipUnlessVersion(3, 8)
+  def test_self_doc_feature_flag(self):
+    # Enabled by default.
+    visitor = self.visit("a = 1\nf'{a=}'")
+    self.assertTrue(visitor.fstrings())
+    self.assertTrue(visitor.fstrings_self_doc())
+    self.assertOnlyIn((3, 8), visitor.minimum_versions())
+
+    self.config.clear_features()
+    visitor = self.visit("a = 1\nf'{a=}'")
+    self.assertTrue(visitor.fstrings())
+    self.assertFalse(visitor.fstrings_self_doc())
+    self.assertOnlyIn((3, 6), visitor.minimum_versions())
+
+    self.config.enable_feature("fstring-self-doc")
+    visitor = self.visit("a = 1\nf'{a=}'")
+    self.assertTrue(visitor.fstrings())
+    self.assertTrue(visitor.fstrings_self_doc())
+    self.assertOnlyIn((3, 8), visitor.minimum_versions())
+
   def assert_pep701(self, source):
     visitor = self.visit(source)
     self.assertTrue(visitor.fstrings())
@@ -282,9 +302,16 @@ def test_pep701_comment_variants(self, source):
 
   @VerminTest.skipUnlessVersion(3, 12)
   def test_pep701_feature_flag(self):
+    # Enabled by default.
     self.config.reset()
     visitor = self.visit('f"outer {f"inner"}"')
     self.assertTrue(visitor.fstrings())
+    self.assertTrue(visitor.fstrings_pep701())
+    self.assertOnlyIn((3, 12), visitor.minimum_versions())
+
+    self.config.clear_features()
+    visitor = self.visit('f"outer {f"inner"}"')
+    self.assertTrue(visitor.fstrings())
     self.assertFalse(visitor.fstrings_pep701())
     self.assertOnlyIn((3, 6), visitor.minimum_versions())
 

vermin/arguments.py

@@ -187,10 +187,11 @@ def print_usage(full=False):
       print("\n  --no-backport (default)\n"
             "        Use no backports. Clears any backports specified before this.")
       print("\n  [--feature <name>] ...\n"
-            "        Some features are disabled by default due to being unstable:\n{}".
-            format(Features.str(10)))
-      print("\n  --no-feature (default)\n"
-            "        Use no features. Clears any features specified before this.")
+            "        Some features are enabled by default. Others must be\n"
+            "        explicitly enabled:\n{}".format(Features.str(10)))
+      print("\n  --no-feature\n"
+            "        Use no features. Disables all features, including those\n"
+            "        that are enabled by default.")
 
   def parse(self, config, detect_folder=None):
     assert config is not None

vermin/config.py

@@ -29,7 +29,7 @@ def reset(self):
     self.__exclusion_regex = set()
     self.__make_paths_absolute = True
     self.__backports = set()
-    self.__features = set()
+    self.__features = Features.defaults()
     self.__targets = []
     self.__eval_annotations = False
     self.__only_show_violations = False

vermin/features.py

@@ -1,14 +1,15 @@
 from .utility import format_title_descs
 
+DEFAULT_FEATURES = ("fstring-self-doc", "fstring-pep701")
+
 FEATURES = (
   ("fstring-self-doc", [
-    "[Unstable] Detect self-documenting fstrings. Can in",
-    "some cases wrongly report fstrings as self-documenting."
+    "Detect self-documenting fstrings. Enabled by default.",
   ]),
   ("fstring-pep701", [
-    "[Unstable] Detect PEP 701 f-string features (3.12+).",
-    "Same-quote nesting and multi-line expressions.",
-    "Requires running on Python 3.12+."
+    "Detect PEP 701 f-string features (3.12+): same-quote",
+    "nesting and multi-line expressions. Requires running on",
+    "Python 3.12+. Enabled by default."
   ]),
   ("union-types", [
     "[Unstable] Detect union types `X | Y`. Can in some cases",
@@ -17,6 +18,10 @@
 )
 
 class Features:
+  @staticmethod
+  def defaults():
+    return set(DEFAULT_FEATURES)
+
   @staticmethod
   def str(indent=0):
     return format_title_descs(FEATURES, Features.features(), indent)

vermin/source_state.py

@@ -149,13 +149,7 @@ def __init__(self, config, path=None, source=None):
     # Lines that should be ignored if they have the comment "novermin" or "novm".
     self.no_lines = set()
 
-    # Default to disabling fstring self-doc detection since the built-in AST cannot distinguish
-    # `f'{a=}'` from `f'a={a}'`, for instance, because it optimizes some information away. And this
-    # incorrectly marks some source code as using fstring self-doc when only using general fstring.
     self.fstring_self_doc_enabled = self.config.has_feature("fstring-self-doc")
-
-    # Default to disabling PEP 701 fstring detection since it requires source-text heuristics to
-    # detect same-quote nesting and multi-line expressions in fstrings.
     self.fstrings_pep701_enabled = self.config.has_feature("fstring-pep701")
 
     # Default to disabling union types detection because it sometimes fails to report it correctly

vermin/source_visitor.py

@@ -372,10 +372,10 @@ def minimum_versions(self):
     if self.fstrings():
       mins = self.__add_versions_entity(mins, (None, (3, 6)), "f-strings")
 
-    if self.fstrings_self_doc():  # pragma: no cover
+    if self.fstrings_self_doc():
       mins = self.__add_versions_entity(mins, (None, (3, 8)), "self-documenting f-strings")
 
-    if self.fstrings_pep701():  # pragma: no cover
+    if self.fstrings_pep701():
       mins = self.__add_versions_entity(mins, (None, (3, 12)), "f-strings (PEP 701)")
 
     if self.bool_const():  # pragma: no cover
@@ -1466,15 +1466,15 @@ def visit_JoinedStr(self, node):
     self.__vvprint("f-strings", versions=[None, (3, 6)])
 
     if self.__s.fstring_self_doc_enabled and hasattr(node, "values") and \
-       hasattr(node, "end_lineno"):  # pragma: no cover
+       hasattr(node, "end_lineno"):
       if self.__fstr.is_self_doc(node):
         self.__s.fstrings_self_doc = True
         self.__vvprint("self-documenting f-strings", versions=[None, (3, 8)])
 
     # PEP 701 fstrings detection requires Python 3.12+ to parse the syntax in the first place, and
     # avoids both false positives and false negatives.
     if self.__s.fstrings_pep701_enabled and sys.version_info >= (3, 12) and \
-       hasattr(node, "values") and hasattr(node, "end_lineno"):  # pragma: no cover
+       hasattr(node, "values") and hasattr(node, "end_lineno"):
       if self.__fstr.pep701_violation(node) is not None:
         self.__s.fstrings_pep701 = True
         self.__vvprint("f-strings (PEP 701)", versions=[None, (3, 12)])