From 1fc8e72c1de7ef3d4cdf9618bead2740ca5812ee Mon Sep 17 00:00:00 2001 From: Hermes Agent Date: Sat, 12 Sep 2026 08:08:58 +0000 Subject: [PATCH] test: cover numeric method return subtraction --- docs/CURRENT_STATUS.md | 1 + docs/ROADMAP.md | 1 + tests/typecheck_method_return_subtraction_good.claro | 11 +++++++++++ tools/validate_typecheck_diagnostics.py | 1 + 4 files changed, 14 insertions(+) create mode 100644 tests/typecheck_method_return_subtraction_good.claro diff --git a/docs/CURRENT_STATUS.md b/docs/CURRENT_STATUS.md index f9a9327..5da0a31 100644 --- a/docs/CURRENT_STATUS.md +++ b/docs/CURRENT_STATUS.md @@ -61,6 +61,7 @@ Ready now: Still needed: - Keep the focused typecheck validator's fixture list complete as new positive and negative examples are added. `claro validate` now executes the complete focused fixture matrix as well, so release validation cannot silently omit a listed typecheck example. - The expression checker now carries a known TEXT operand through all arithmetic operators so object-field and typed-function-return diagnostics do not hide addition, subtraction, multiplication, or division mistakes; focused numeric-subtraction, numeric-division, and numeric-multiplication positives plus text-operand addition, subtraction, multiplication, and division negatives protect this behavior. Typed-function return diagnostics now also have focused division coverage. Text concatenation into a TEXT field has focused positive fixtures for both operand orders, including concatenation of two TEXT object fields. Each numeric operator names the text operand and explains that it needs NUMBER values. +- Method return validation now has a focused positive subtraction fixture alongside the existing arithmetic return coverage, so a checked NUMBER method parameter and numeric subtraction remain accepted by the release validator. - richer typed function signatures and return values beyond the focused simple function/method `RETURNS TYPE` check - type checking through branches and loops - richer object field type checking beyond simple direct assignments diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 40f9b86..4163aaa 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -37,6 +37,7 @@ See `CURRENT_STATUS.md` for the detailed feature matrix. 4. Add small examples for each foundation feature before adding bigger syntax. The object-field foundation now includes positive and negative validation for field expressions such as `SET player.score player.name`, `SET player.score player.score + 1`, `SET player.name player.score + 1`, explicitly typed field assignments, explicit typed assignments to undeclared fields, simple and chained aliases such as `SET alias player`, `SET backup alias`, followed by `SET backup.score ...` or `CHECK TYPE backup.score IS ...`, chained aliases in object-method calls through both modern `DO` and compatibility `CALL ... WITH` forms (including a dedicated positive modern `DO` fixture), and arithmetic/text expression mismatches; typed containers also accept a map with nested type metadata when it is added to a `LIST OF MAP`; broader alias/control-flow checking remains planned. 5. Keep the focused typecheck validator complete: every `typecheck_*.claro` fixture, including positive fixtures, is now exercised by both the standalone diagnostic validator and `claro validate`. 6. Continue narrowing expression diagnostics: known TEXT operands now remain visible through arithmetic, with focused numeric-subtraction, numeric-division, and numeric-multiplication positives plus text-operand addition, subtraction, multiplication, and division coverage. Text concatenation into TEXT fields is covered in both operand orders, including field-to-field concatenation. Each numeric operator gives specific guidance naming the text operand. `CHECK TYPE` also rejects misspelled expected type names before comparing values. +- Keep typed method return examples balanced: numeric subtraction now has a dedicated positive method fixture in the focused validator, alongside the existing method return mismatch diagnostics. - Keep IDE metadata aligned with the current beginner syntax: typed-language keywords such as `RETURNS`, `CHECK`, and `TYPE` are now included in the metadata used by editor helpers. - Keep compatibility-call coverage aligned with modern calls: empty `CALL object.method WITH` forms now have a focused missing-argument diagnostic fixture alongside the modern `DO object.method` case. Keep declared return types honest: `claro typecheck` now reports friendly diagnostics for unknown declared return types, mismatched, not-yet-inferable, and empty return expressions, declarations with no `RETURN`, and incomplete conditional branches, when a simple function or object method declares `RETURNS TYPE`; the declaration keyword is case-insensitive like other Claro keywords, with positive coverage in modern and compatibility function forms, including lowercase compatibility declarations and lowercase compatibility method declarations, plus a lowercase compatibility-method mismatch fixture. Complete `IF`/`ELSE` return branches, including nested complete conditionals in functions and methods, are accepted, and modern and compatibility function syntax plus compatibility method syntax are covered by focused fixtures. `CHECK TYPE` parameter metadata also informs arithmetic return-expression checking, including object methods; positive numeric multiplication return coverage now sits beside the mismatch fixtures; typed methods can also return class-declared fields by simple name, with positive and mismatch fixtures, and unknown method return expressions now have dedicated modern and compatibility diagnostic fixtures, and NUMBER return expressions with known TEXT arithmetic operands identify the operation and offending operand, including focused addition, subtraction, multiplication, and division coverage for functions and methods. Full path-sensitive analysis across nested conditionals and loops remains planned. diff --git a/tests/typecheck_method_return_subtraction_good.claro b/tests/typecheck_method_return_subtraction_good.claro new file mode 100644 index 0000000..1af3042 --- /dev/null +++ b/tests/typecheck_method_return_subtraction_good.claro @@ -0,0 +1,11 @@ +CLASS Player + HAS score NUMBER + + TEACH total amount RETURNS NUMBER + CHECK TYPE amount IS NUMBER + RETURN amount - 2 + END +END + +NEW Player player +DO player.total 3 diff --git a/tools/validate_typecheck_diagnostics.py b/tools/validate_typecheck_diagnostics.py index 9e948f3..0c9dbdb 100644 --- a/tools/validate_typecheck_diagnostics.py +++ b/tools/validate_typecheck_diagnostics.py @@ -280,6 +280,7 @@ EXPECTED_OK = [ "tests/typecheck_method_compat_lowercase_return_good.claro", "tests/typecheck_method_return_expression_good.claro", "tests/typecheck_method_return_multiplication_good.claro", + "tests/typecheck_method_return_subtraction_good.claro", "tests/typecheck_method_return_addition_good.claro", "tests/typecheck_method_unknown_return_expression_good.claro", "tests/typecheck_method_nested_branch_complete_good.claro",