bias less towards classes over functions

README.md

@@ -6,7 +6,8 @@ them on a Python build.
 
 To use, create a Python 3.11 venv and `pip install -r frozen.txt`.
 
-Then start the evalserver with your built Python:
+Then start the evalserver with the build of Python you want to test for
+compatibility with 3.11:
 
     /home/carljm/cpython-builds/dbg/python evalserver.py
 
@@ -18,8 +19,8 @@ the log file.
 
 Current approach is to generate a bunch of random code samples and filter down
 to the ones containing list comprehensions, then aim for samples that maximize
-number of listcomps and lambdas. The problem is that too many samples are
-generated without listcomps and then rejected. We probably need a more
+number of listcomps, lambdas, and classes. The problem is that too many samples
+are generated without listcomps and then rejected. We probably need a more
 constrained format for generating the samples initially, but without
 over-constraining and possibly missing counter-examples.
 

test_fuzz_comps.py

@@ -49,18 +49,22 @@ def record_targets(tree: ast.Module) -> ast.Module:
     num_lambdas = 0
     num_listcomps = 0
     num_classes = 0
+    num_functions = 0
     for n in nodes:
         if isinstance(n, ast.Lambda):
             num_lambdas += 1
         elif isinstance(n, ast.ListComp):
             num_listcomps += 1
         elif isinstance(n, ast.ClassDef):
-            num_classes += 100
+            num_classes += 1
+        elif isinstance(n, ast.FunctionDef):
+            num_functions += 1
     # hypothesis will aim for samples that maximize these metrics
     for value, label in [
         (num_lambdas, "(modules) number of lambdas"),
         (num_listcomps, "(modules) number of listcomps"),
         (num_classes, "(modules) number of classes"),
+        (num_functions, "(modules) number of functions"),
     ]:
         target(float(value), label=label)
     return to_source(tree)
@@ -259,7 +263,12 @@ def functions(draw):
 
 
 def module_level_statements():
-    return st.from_type(ast.ClassDef)
+    # require top-level class or function; plain module-level comprehensions are
+    # not very interesting in terms of finding scoping bugs
+    return st.one_of(
+        st.from_type(ast.ClassDef),
+        st.from_type(ast.FunctionDef)
+    )
 
 
 st.register_type_strategy(