python · erlend-aasland · Feb 6, 2024 · Feb 6, 2024 · Feb 6, 2024 · Feb 6, 2024
@@ -265,7 +265,8 @@ def converter_init(self):
        self.expect_failure(raw, err)

    def test_clone_mismatch(self):
-        err = "'kind' of function and cloned function don't match!"
+        err = ("'kind' of function and cloned function don't match: "
+               "STATIC_METHOD != CLASS_METHOD")
        block = """
            /*[clinic input]
            module m
@@ -574,7 +575,7 @@ class C "void *" ""
            C.__init__ = C.meth
            [clinic start generated code]*/
        """
-        err = "'__init__' must be a normal method; got 'FunctionKind.CLASS_METHOD'!"
+        err = "'__init__' must be an instance method; got 'FunctionKind.CLASS_METHOD'"
        self.expect_failure(block, err, lineno=8)

    def test_validate_cloned_new(self):
@@ -1906,7 +1907,9 @@ def test_parameters_not_permitted_after_slash_for_now(self):
        self.expect_failure(block, err)

    def test_parameters_no_more_than_one_vararg(self):
-        err = "Too many var args"
+        err = ("Cannot specify multiple vararg parameters: "
+               "'vararg2' is a vararg, but "
+               "'vararg1' was already provided")
        block = """
            module foo
            foo.bar
@@ -2039,6 +2042,15 @@ def test_legacy_converters_non_string_constant_annotation(self):
            with self.subTest(block=block):
                self.expect_failure(block, err, lineno=2)

+    def test_str_converter_invalid_format_unit(self):
+        block = """
+            module foo
+            foo.bar
+              a: str(encoding='foo', zeroes=True, accept={})
+        """
+        err = "unsupported combination of str converter arguments"
+        self.expect_failure(block, err, lineno=2)
+
    def test_other_bizarre_things_in_annotations_fail(self):
        err = "Annotations must be either a name, a function call, or a string"
        dataset = (
@@ -2120,7 +2132,7 @@ class Foo "" ""
            self.parse_function(block)

    def test_new_must_be_a_class_method(self):
-        err = "'__new__' must be a class method!"
+        err = "'__new__' must be a class method; got 'FunctionKind.CALLABLE'"
        block = """
            module foo
            class Foo "" ""
@@ -2129,7 +2141,7 @@ class Foo "" ""
        self.expect_failure(block, err, lineno=2)

    def test_init_must_be_a_normal_method(self):
-        err_template = "'__init__' must be a normal method; got 'FunctionKind.{}'!"
+        err_template = "'__init__' must be an instance method; got 'FunctionKind.{}'"
        annotations = {
            "@classmethod": "CLASS_METHOD",
            "@staticmethod": "STATIC_METHOD",
@@ -2317,7 +2329,7 @@ def test_non_ascii_character_in_docstring(self):
        self.assertEqual(stdout.getvalue(), expected)

    def test_illegal_c_identifier(self):
-        err = "Illegal C identifier: 17a"
+        err = "Expected a legal C identifier; got '17a'"
        block = """
            module test
            test.fn

@@ -3965,14 +3965,27 @@ class buffer: pass
 class rwbuffer: pass
 class robuffer: pass

-StrConverterKeyType = tuple[frozenset[type[object]], bool, bool]
+@dc.dataclass
+class StrConverterKey:
+    accept: frozenset[type[object]]
+    encoding: bool
+    zeroes: bool
+
+    def __hash__(self) -> int:
+        return hash((self.accept, self.encoding, self.zeroes))
+
+    def __str__(self) -> str:
+        accept = "{" + ", ".join([tp.__name__ for tp in self.accept]) + "}"
+        encoding = 'encodingname' if self.encoding else None
+        zeroes = self.zeroes
+        return f"{accept=!r}, {encoding=!r}, {zeroes=!r}"

 def str_converter_key(
    types: TypeSet, encoding: bool | str | None, zeroes: bool
-) -> StrConverterKeyType:
-    return (frozenset(types), bool(encoding), bool(zeroes))
+) -> StrConverterKey:
+    return StrConverterKey(frozenset(types), bool(encoding), bool(zeroes))

-str_converter_argument_map: dict[StrConverterKeyType, str] = {}
+str_converter_argument_map: dict[StrConverterKey, str] = {}

 class str_converter(CConverter):
    type = 'const char *'
@@ -3990,7 +4003,10 @@ def converter_init(
        key = str_converter_key(accept, encoding, zeroes)
        format_unit = str_converter_argument_map.get(key)
        if not format_unit:
-            fail("str_converter: illegal combination of arguments", key)
+            allowed = "\n".join([str(k) for k in str_converter_argument_map.keys()])
+            fail("unsupported combination of str converter arguments: "
+                 f"{accept=!r}, {encoding=!r}, {zeroes=!r}; "
+                 f"allowed combinations are:\n\n{allowed}")

        self.format_unit = format_unit
        self.length = bool(zeroes)
@@ -4931,12 +4947,14 @@ def directive_preserve(self) -> None:

    def at_classmethod(self) -> None:
        if self.kind is not CALLABLE:
-            fail("Can't set @classmethod, function is not a normal callable")
+            fail("Can't set @classmethod, "
+                 f"function is not a normal callable; got: {self.kind!r}")
        self.kind = CLASS_METHOD

    def at_critical_section(self, *args: str) -> None:
        if len(args) > 2:
-            fail("Up to 2 critical section variables are supported")
+            fail("Only 2 critical section variables are supported; "
+                 f"{len(args)} were given")
        self.target_critical_section.extend(args)
        self.critical_section = True

@@ -4960,7 +4978,8 @@ def at_setter(self) -> None:

    def at_staticmethod(self) -> None:
        if self.kind is not CALLABLE:
-            fail("Can't set @staticmethod, function is not a normal callable")
+            fail("Can't set @staticmethod, "
+                 f"function is not a normal callable; got: {self.kind!r}")
        self.kind = STATIC_METHOD

    def at_coexist(self) -> None:
@@ -5074,9 +5093,9 @@ def normalize_function_kind(self, fullname: str) -> None:
        if name in unsupported_special_methods:
            fail(f"{name!r} is a special method and cannot be converted to Argument Clinic!")
        if name == '__init__' and (self.kind is not CALLABLE or not cls):
-            fail(f"{name!r} must be a normal method; got '{self.kind}'!")
+            fail(f"{name!r} must be an instance method; got '{self.kind}'!")
        if name == '__new__' and (self.kind is not CLASS_METHOD or not cls):
-            fail("'__new__' must be a class method!")
+            fail(f"'__new__' must be a class method; got '{self.kind}'")
        if self.kind in {GETTER, SETTER} and not cls:
            fail("@getter and @setter must be methods")

@@ -5150,8 +5169,8 @@ def parse_cloned_function(self, names: FunctionNames, existing: str) -> None:
                # Future enhancement: allow custom return converters
                overrides["return_converter"] = CReturnConverter()
            else:
-                fail("'kind' of function and cloned function don't match! "
-                     "(@classmethod/@staticmethod/@coexist)")
+                fail("'kind' of function and cloned function don't match: "
+                     f"{self.kind.name} != {existing_function.kind.name}")
        function = existing_function.copy(**overrides)
        self.function = function
        self.block.signatures.append(function)
@@ -5424,10 +5443,13 @@ def parse_parameter(self, line: str) -> None:
                 f"invalid parameter declaration (**kwargs?): {line!r}")

        if function_args.vararg:
-            if any(p.is_vararg() for p in self.function.parameters.values()):
-                fail("Too many var args")
            is_vararg = True
            parameter = function_args.vararg
+            for p in self.function.parameters.values():
+                if p.is_vararg():
+                    fail("Cannot specify multiple vararg parameters: "
+                         f"{parameter.arg!r} is a vararg, but "
+                         f"{p.name!r} was already provided as a vararg")
        else:
            is_vararg = False
            parameter = function_args.args[0]

@@ -24,7 +24,7 @@ def is_legal_py_identifier(identifier: str) -> bool:
 def ensure_legal_c_identifier(identifier: str) -> str:
    # For now, just complain if what we're given isn't legal.
    if not is_legal_c_identifier(identifier):
-        raise ClinicError(f"Illegal C identifier: {identifier}")
+        raise ClinicError(f"Expected a legal C identifier; got {identifier!r}")
    # But if we picked a C keyword, pick something else.
    if identifier in _c_keywords:
        return identifier + "_value"