From 878afc8160bc456e628a92ad68af4b00e70b8d6d Mon Sep 17 00:00:00 2001 From: Hermes Agent Date: Mon, 21 Sep 2026 03:19:27 +0000 Subject: [PATCH] test: cover AS TO method field annotations --- docs/ADVANCED_STATIC_TYPING.md | 14 ++++++++++++++ docs/CURRENT_STATUS.md | 2 +- docs/ROADMAP.md | 1 + tests/test_validate_typecheck_diagnostics.py | 10 ++++++++++ ...compat_inline_field_annotation_as_to_good.claro | 10 ++++++++++ ...method_inline_field_annotation_as_to_good.claro | 10 ++++++++++ tools/validate_typecheck_diagnostics.py | 2 ++ 7 files changed, 48 insertions(+), 1 deletion(-) create mode 100644 tests/typecheck_method_compat_inline_field_annotation_as_to_good.claro create mode 100644 tests/typecheck_method_inline_field_annotation_as_to_good.claro diff --git a/docs/ADVANCED_STATIC_TYPING.md b/docs/ADVANCED_STATIC_TYPING.md index 5d2794e..b3dda3f 100644 --- a/docs/ADVANCED_STATIC_TYPING.md +++ b/docs/ADVANCED_STATIC_TYPING.md @@ -825,6 +825,20 @@ SET player.score AS NUMBER TO 10 Both explicit forms must agree with the class field declaration. +The `AS ... TO` spelling also works inside modern and compatibility object methods: + +```claro +CLASS Player + HAS score NUMBER + + TEACH set_score + SET score AS NUMBER TO 10 + END +END +``` + +The older `TAKES` / `LEARNED` method form accepts the same field annotation. Both forms are covered by focused typecheck validation, so method examples can use either the short annotation or the separated `AS ... TO` spelling. + The explicit `TEXT` annotation must agree with the class field declaration. This keeps typed field examples consistent with typed variable assignments while still allowing the shorter `SET player.name "Ada"` form. diff --git a/docs/CURRENT_STATUS.md b/docs/CURRENT_STATUS.md index 6ca0801..8dfbb4d 100644 --- a/docs/CURRENT_STATUS.md +++ b/docs/CURRENT_STATUS.md @@ -83,7 +83,7 @@ Ready now: - object creation now rejects repeated object names with a direct repair hint, so two `NEW Player player` statements cannot silently replace one another during type checking; when a script declares at least one class, a misspelled `NEW` class name gets a direct declaration hint without changing the older permissive no-class form; a missing class name or object name gets a direct example repair; extra words after the object name get a direct repair hint instead of being silently ignored - a narrow object-field assignment/check-type check for simple `NEW Class object` plus direct `SET object.field value` and `CHECK TYPE object.field IS TYPE` cases when the class declares `HAS field TYPE`; validation now covers correct NUMBER, TEXT, and YESNO direct assignments, dedicated positive and explicitly typed NUMBER/TEXT field assignments, explicitly typed method-body assignments to undeclared fields with a `HAS field TYPE` repair hint in modern and compatibility method syntax, dedicated positive NUMBER/TEXT/YESNO `CHECK TYPE` metadata fixtures, simple and chained object aliases for both field assignments and `CHECK TYPE` metadata (including a chained TEXT-field check), aliased object-method calls including chained aliases in modern `DO` and compatibility `CALL ... WITH` forms (with a dedicated positive modern `DO` chained-alias fixture), field-to-field, compound arithmetic field expressions, and arithmetic/text expression result types, negative NUMBER/TEXT/YESNO field `CHECK TYPE` metadata mismatches, NUMBER/TEXT/YESNO-expectation unknown-field `CHECK TYPE` diagnostics, missing-object field assignment and `CHECK TYPE` diagnostics, NUMBER/TEXT/YESNO wrong-type diagnostics, field collection when a `HAS` field appears after a simple method, NUMBER/TEXT/YESNO-valued unknown-field diagnostics for direct assignments to undeclared fields including explicitly typed assignments, numeric and text results from simple arithmetic/text expressions in object-field assignments, plus method-body field assignment and `CHECK TYPE` diagnostics for NUMBER, TEXT, and YESNO fields in modern and compatibility syntax, including compatibility YESNO `CHECK TYPE` metadata coverage, direct method assignments to undeclared fields now produce a beginner-facing missing-field diagnostic when the assigned expression has a known type, and a plain beginner-facing unknown-field diagnostic when the assigned expression is not inferable yet in both modern and compatibility method syntax; method-body `CHECK TYPE` now reports an unknown field with a repair hint in both method syntaxes, including compatibility `TAKES` / `LEARNED` methods; explicitly typed assignments to declared method fields now validate the class-declared field type instead of trusting only the inline type annotation, so a wrong value such as `SET score TEXT \"oops\"` reports the method and field in the diagnostic. - inline method-field annotations are checked against the class `HAS` declaration in modern and compatibility methods; conflicting known types and unknown annotation names produce field-specific repair guidance, with positive and negative focused fixtures for both syntaxes. -- Direct object-field validation also has positive coverage for explicit `NUMBER`, `TEXT`, and `YESNO` annotations, such as `SET player.ready YESNO YES`, plus the compatibility-shaped `AS ... TO` form such as `SET player.score AS NUMBER TO 10`, while the shorter unannotated form remains supported; conflicting annotations such as `SET player.score TEXT "oops"` explain the class-declared type and how to repair it, and unknown annotations such as `SET player.score AS BANANA TO 10` or `SET player.score BANANA 10` identify the invalid type and suggest the declared field type. +- Direct object-field validation also has positive coverage for explicit `NUMBER`, `TEXT`, and `YESNO` annotations, such as `SET player.ready YESNO YES`, plus the compatibility-shaped `AS ... TO` form such as `SET player.score AS NUMBER TO 10`, while the shorter unannotated form remains supported; method-body field assignments have matching positive coverage for both modern and compatibility `TEACH` forms using `SET score AS NUMBER TO 10`; conflicting annotations such as `SET player.score TEXT "oops"` explain the class-declared type and how to repair it, and unknown annotations such as `SET player.score AS BANANA TO 10` or `SET player.score BANANA 10` identify the invalid type and suggest the declared field type. 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. diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index c98e5bb..3700a9c 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -50,6 +50,7 @@ Keep declared return types honest: `claro typecheck` now reports friendly diagno 8c. Keep explicit method-field annotations aligned with class declarations: `SET score TEXT "oops"` inside a method with `HAS score NUMBER` now reports the declared field mismatch instead of accepting the inline annotation; broader annotation consistency remains planned. 8d. Keep inline field annotations consistent with `HAS` declarations: `claro typecheck` now rejects conflicting annotations on method-body and direct object-field assignments, explains which type to use, and gives a known-type repair hint for unknown direct object-field annotations in both `AS ... TO` and short `SET field TYPE value` forms. 8d.1. Keep direct field annotation forms balanced: the compatibility-shaped `SET player.score AS NUMBER TO 10` form now has a dedicated positive fixture beside short explicit annotations, so both accepted spellings remain protected by focused validation. +8d.2. Keep method field annotation forms balanced: modern and compatibility methods now have dedicated positive fixtures for `SET score AS NUMBER TO 10`, so the compatibility-shaped annotation remains protected inside both supported method syntaxes. 8e. Keep inline method-field annotation coverage aligned across syntax generations: compatibility `TAKES` / `LEARNED` methods now have matching positive and negative fixtures, so older lessons retain the same class-declared-type guidance. 8f. Keep inline method-field annotations learner-facing: an unknown annotation such as `BANANA` now names the field and method and suggests the `HAS` type instead of silently treating the annotation as an expression. 8g. Keep unknown inline method-field annotation diagnostics aligned across syntax generations: compatibility `TAKES` / `LEARNED` methods now have matching focused coverage for misspelled annotations. diff --git a/tests/test_validate_typecheck_diagnostics.py b/tests/test_validate_typecheck_diagnostics.py index 28f6b2b..b189de9 100644 --- a/tests/test_validate_typecheck_diagnostics.py +++ b/tests/test_validate_typecheck_diagnostics.py @@ -57,6 +57,16 @@ class ValidateTypecheckDiagnosticsTests(unittest.TestCase): MODULE.EXPECTED_OK, ) + def test_includes_as_to_method_field_success_fixtures(self): + self.assertIn( + "tests/typecheck_method_inline_field_annotation_as_to_good.claro", + MODULE.EXPECTED_OK, + ) + self.assertIn( + "tests/typecheck_method_compat_inline_field_annotation_as_to_good.claro", + MODULE.EXPECTED_OK, + ) + def test_includes_reverse_text_concatenation_success_fixture(self): self.assertIn( "tests/typecheck_object_field_text_concat_reverse_good.claro", diff --git a/tests/typecheck_method_compat_inline_field_annotation_as_to_good.claro b/tests/typecheck_method_compat_inline_field_annotation_as_to_good.claro new file mode 100644 index 0000000..c88b74b --- /dev/null +++ b/tests/typecheck_method_compat_inline_field_annotation_as_to_good.claro @@ -0,0 +1,10 @@ +CLASS Player + HAS score NUMBER + + TEACH set_score TAKES value + SET score AS NUMBER TO 10 + LEARNED +END + +NEW Player player +CALL player.set_score WITH 10 diff --git a/tests/typecheck_method_inline_field_annotation_as_to_good.claro b/tests/typecheck_method_inline_field_annotation_as_to_good.claro new file mode 100644 index 0000000..1969475 --- /dev/null +++ b/tests/typecheck_method_inline_field_annotation_as_to_good.claro @@ -0,0 +1,10 @@ +CLASS Player + HAS score NUMBER + + TEACH set_score + SET score AS NUMBER TO 10 + END +END + +NEW Player player +DO player.set_score diff --git a/tools/validate_typecheck_diagnostics.py b/tools/validate_typecheck_diagnostics.py index 51dde78..0daf995 100644 --- a/tools/validate_typecheck_diagnostics.py +++ b/tools/validate_typecheck_diagnostics.py @@ -543,6 +543,8 @@ EXPECTED_OK = [ "tests/typecheck_method_yesno_field_check_type_good.claro", "tests/typecheck_method_inline_field_annotation_good.claro", "tests/typecheck_method_compat_inline_field_annotation_good.claro", + "tests/typecheck_method_inline_field_annotation_as_to_good.claro", + "tests/typecheck_method_compat_inline_field_annotation_as_to_good.claro", "tests/typecheck_method_nested_branch_complete_good.claro", "tests/typecheck_function_multi_good.claro", "tests/typecheck_method_good.claro",