Document compiler-assisted field mapping

Author: Frotty

_doc/manual.md

@@ -878,6 +878,33 @@ function foo()
     let s = Terrain.someArr[0]
 ```
 
+### Compiler-assisted field mapping
+
+For dedicated state classes, the compiler provides two save/load intrinsics that expand into direct field
+accesses:
+
+```wurst
+class PlayerState
+    int level = 1
+    string name = ""
+
+    function save(FieldWriter writer)
+        __wurst_forFields((fieldName, value) -> writer.write(fieldName, value))
+
+    function load(FieldReader reader)
+        __wurst_mapFields((fieldName, value) -> reader.read(fieldName, value))
+```
+
+`__wurst_forFields` invokes the callback once for every non-static instance field. The callback receives the
+field name and current value and must produce a statement. `__wurst_mapFields` invokes a reader callback and
+assigns its result back to each field. Leave the two callback parameter types inferred; overload the reader or
+writer for the field types used by the state class.
+
+These are compile-time transformations, not runtime reflection, and generate equivalent direct accesses in both
+Jass and Lua. Keep serializable state in a small class with mutable instance fields and keep the persistence
+codec separate from the rest of the game logic. See the [Save and Load tutorial](/tutorials/saveload.html) for
+integration with Warcraft III's file API.
+
 ### Array Members
 
 Wurstscript supports sized arrays as classmembers by translating it to SIZE times arrays and then resolve the array in a get/set function via binary search.

_tutorials/saveload.md

@@ -62,6 +62,35 @@ Of course usually we don't want to save just strings, but data that is stored in
 For this purpose there is the `Serializable` class for simple saving and loading of primitive attribute values.
 The `serialize()` function returns a `ChunkedString`, which then can be passed to the data save function from above.
 
+## Compiler-assisted field mapping
+
+For small, dedicated state classes, Wurst can generate the repetitive field mapping for you. Use the
+compiler intrinsics `__wurst_forFields` when writing fields and `__wurst_mapFields` when reading them:
+
+```wurst
+class PlayerState
+    int level = 1
+    string name = ""
+
+    function save(FieldWriter writer)
+        __wurst_forFields((fieldName, value) -> writer.write(fieldName, value))
+
+    function load(FieldReader reader)
+        __wurst_mapFields((fieldName, value) -> reader.read(fieldName, value))
+```
+
+The callback receives the field name as a `string` and the current field value. The compiler expands these
+calls into ordinary direct field accesses, so there is no runtime reflection or metadata lookup. The same
+source works for both Jass and Lua.
+
+`__wurst_forFields` is for statement callbacks. `__wurst_mapFields` uses the callback result to assign each
+field, so the reader should return the value to store. Leave both callback parameter types inferred and use
+the reader/writer overload matching each field type. Static fields are not included.
+
+The `__wurst_` names are compiler intrinsics; ordinary user functions named `forFields` or `mapFields` are
+unaffected. Keep these state classes focused on their serializable data (normally direct mutable instance
+fields) and keep the persistence codec separate from the game logic.
+
 
 ## Usage