[pull] master from GaijinEntertainment:master

doc/source/reference/tutorials.rst

@@ -85,6 +85,8 @@ introduced in earlier tutorials.
    tutorials/54_glob.rst
    tutorials/55_linq_decs.rst
    tutorials/56_linq_query.rst
+   tutorials/57_toml.rst
+   tutorials/58_logger.rst
 
 .. _tutorials_building_from_sdk:
 
@@ -206,6 +208,7 @@ Run any tutorial from the project root::
    tutorials/macros/16_template_type_macro.rst
    tutorials/macros/17_qmacro.rst
    tutorials/macros/18_with_boost.rst
+   tutorials/macros/19_add_module_option.rst
 
 .. _tutorials_dashv:
 

doc/source/reference/tutorials/03_operators.rst

@@ -86,12 +86,12 @@ Copy vs move — introduction
 ``=`` is copy assignment — works for simple types and copyable values.
 ``<-`` is move assignment — transfers ownership and zeroes the source::
 
-  var p = 10
+  let p = 10
   var q = p       // q is a copy of p
   q = 99          // p is unchanged
 
   var s = 42
-  var r <- s      // r gets 42, s is zeroed
+  let r <- s      // r gets 42, s is zeroed
 
 Move matters for arrays, tables, lambdas, and other heap-allocated types.
 See :ref:`tutorial_arrays` and :ref:`Move, copy, clone <move_copy_clone>`.

doc/source/reference/tutorials/17_move_copy_clone.rst

@@ -81,7 +81,7 @@ Type compatibility
      - Yes
      - Yes
    * - lambda
-     - No
+     - Yes (alias)
      - Yes
      - No
    * - iterator
@@ -93,6 +93,12 @@ Type compatibility
      - No
      - No
 
+.. note::
+
+   ``=`` on a lambda copies the fat pointer — both variables share the same
+   capture frame (aliasing, not an independent copy). See
+   :ref:`tutorial_lambdas` for details.
+
 Relaxed assign
 ==============
 

doc/source/reference/tutorials/21_error_handling.rst

@@ -40,8 +40,12 @@ general exception handling — only panics are caught::
 
 .. note::
 
-   You cannot ``return`` from inside ``try`` or ``recover`` blocks.
-   Assign results to a variable instead.
+   Execution resumes after the ``try``/``recover`` block, but a panic means
+   the program reached a broken state. Use ``recover`` to capture the failure
+   (log it, report it) before deciding to stop — **not** as resumable
+   exception handling and not for soft, expected errors. For those, return a
+   status value instead — see :ref:`tutorial_option_and_result`. (Consistent
+   with this, a ``finally`` block is skipped when its body panics.)
 
 assert and verify
 =================

doc/source/reference/tutorials/23_string_format.rst

@@ -24,8 +24,8 @@ Inside ``{expr}`` interpolation, add ``:flags width.precision type``::
 **Flags:**
 
 - ``0`` — zero-pad
-- ``-`` — left-align
 - ``+`` — force sign
+- ``<`` — left-align (e.g. ``{x:<10d}``)
 
 **Type characters:**
 

doc/source/reference/tutorials/32_operator_overloading.rst

@@ -24,32 +24,9 @@ Overload ``+``, ``-``, ``*``, ``/``, ``%`` to give your types arithmetic
 behaviour. Each operator is a binary function that takes two values and returns
 a result:
 
-.. code-block:: das
-
-    struct Vec2 {
-        x : float
-        y : float
-    }
-
-    def operator +(a, b : Vec2) : Vec2 {
-        return Vec2(x = a.x + b.x, y = a.y + b.y)
-    }
-
-    def operator -(a, b : Vec2) : Vec2 {
-        return Vec2(x = a.x - b.x, y = a.y - b.y)
-    }
-
-    def operator *(a : Vec2; s : float) : Vec2 {
-        return Vec2(x = a.x * s, y = a.y * s)
-    }
-
-    def operator *(s : float; a : Vec2) : Vec2 {
-        return a * s
-    }
-
-    def operator /(a : Vec2; s : float) : Vec2 {
-        return Vec2(x = a.x / s, y = a.y / s)
-    }
+.. literalinclude:: ../../../../tutorials/language/32_operator_overloading.das
+   :language: das
+   :lines: 27-50
 
 Usage::
 
@@ -122,22 +99,9 @@ Overload ``+=``, ``-=``, ``*=``, ``/=``, ``%=``, ``&=``, ``|=``, ``^=``,
 ``<<=``, ``>>=`` and others for in-place modification. The first argument must
 be ``var ... &`` (mutable reference):
 
-.. code-block:: das
-
-    def operator +=(var a : Vec2&; b : Vec2) {
-        a.x += b.x
-        a.y += b.y
-    }
-
-    def operator -=(var a : Vec2&; b : Vec2) {
-        a.x -= b.x
-        a.y -= b.y
-    }
-
-    def operator *=(var a : Vec2&; s : float) {
-        a.x *= s
-        a.y *= s
-    }
+.. literalinclude:: ../../../../tutorials/language/32_operator_overloading.das
+   :language: das
+   :lines: 145-158
 
 Usage::
 

doc/source/reference/tutorials/44_compile_and_run.rst

@@ -24,7 +24,7 @@ section.
     options gen2
     options multiple_contexts   // required when holding smart_ptr<Context>
 
-    require daslib/rtti
+    require daslib/ast
     require daslib/debugger
     require daslib/jobque_boost
 

doc/source/reference/tutorials/46_apply_in_context.rst

@@ -77,15 +77,17 @@ From the caller's perspective, these look like normal functions:
     init_counter_service()
     print("  increment() = {increment()}\n")
     print("  increment() = {increment()}\n")
+    print("  increment() = {increment()}\n")
     print("  get_counter() = {get_counter()}\n")
     add_to_counter(10)
-    print("  after add = {get_counter()}\n")
+    print("  after add_to_counter(10) = {get_counter()}\n")
     print("  local counter = {counter}\n")
     // output:
     //   increment() = 1
     //   increment() = 2
-    //   get_counter() = 2
-    //   after add = 12
+    //   increment() = 3
+    //   get_counter() = 3
+    //   after add_to_counter(10) = 13
     //   local counter = 0
 
 The agent context's ``counter`` is modified — the caller's local

doc/source/reference/tutorials/47_data_walker.rst

@@ -35,22 +35,9 @@ A ``DapiDataWalker`` subclass overrides only the callbacks you need.
 All 87 methods default to no-ops, so a minimal walker that prints
 integers, floats, strings, and booleans is very small:
 
-.. code-block:: das
-
-    class ScalarPrinter : DapiDataWalker {
-        def override Int(var value : int&) : void {
-            print("  int: {value}\n")
-        }
-        def override Float(var value : float&) : void {
-            print("  float: {value}\n")
-        }
-        def override String(var value : string&) : void {
-            print("  string: \"{value}\"\n")
-        }
-        def override Bool(var value : bool&) : void {
-            print("  bool: {value}\n")
-        }
-    }
+.. literalinclude:: ../../../../tutorials/language/47_data_walker.das
+   :language: das
+   :lines: 41-54
 
 To walk a value, create the walker, wrap it with ``make_data_walker``,
 then call ``walk_data`` with a pointer and ``TypeInfo``:
@@ -375,21 +362,9 @@ Mutating data in-place
 Scalar callbacks receive ``var value : T&`` — a mutable reference.
 This means the walker can modify data during traversal:
 
-.. code-block:: das
-
-    class FloatClamper : DapiDataWalker {
-        lo : float = 0.0
-        hi : float = 1.0
-
-        def override Float(var value : float&) : void {
-            if (value < lo) {
-                value = lo
-            }
-            if (value > hi) {
-                value = hi
-            }
-        }
-    }
+.. literalinclude:: ../../../../tutorials/language/47_data_walker.das
+   :language: das
+   :lines: 767-779
 
 Walking a ``Particle`` with out-of-range floats clamps them to
 ``[0..1]``:

doc/source/reference/tutorials/50_soa.rst

@@ -22,9 +22,9 @@ Prerequisites: familiarity with structs and arrays.
 .. code-block:: das
 
     options gen2
-    options no_unused_function_arguments = false
 
     require daslib/soa
+    require math
 
 
 What is SOA?

doc/source/reference/tutorials/51_delegate.rst

@@ -20,9 +20,9 @@ Prerequisites: familiarity with lambdas, function pointers, and typedefs.
 .. code-block:: das
 
     options gen2
-    options no_unused_function_arguments = false
 
     require daslib/delegate
+    require math
 
 
 Declaring delegate types

doc/source/reference/tutorials/56_linq_query.rst

@@ -152,3 +152,5 @@ exact scope.
    Full source: :download:`tutorials/language/56_linq_query.das <../../../../tutorials/language/56_linq_query.das>`
 
    Previous tutorial: :ref:`tutorial_linq_decs`
+
+   Next tutorial: :ref:`TOML <tutorial_toml>`