Doc updates for 2.0.1

Author: mattias-mohlin

docs-sources/art-lang/index.md

@@ -1172,7 +1172,7 @@ The same transition can be triggered by multiple trigger operations (just like a
 
 Names of classes with state machines by convention start with uppercase, while names of trigger operations and their parameters by convention start with lowercase and use camelCase if the name consists of multiple words. 
 
-A common design pattern is to let a class-with-statemachine instance be managed by a single capsule instance. This means that the capsule instance is responsible both for creating, using and finally destroying the class-with-statemachine instance. If you follow this pattern it is thread-safe to for example call public member functions defined on the capsule from a transition in the class state machine (or, better, to call non-public member functions by letting the class be a friend of the capsule). This can for example be used as a means for the class state machine to send events through the ports of the capsule (i.e. it can call a capsule member function that sends the event). However, to avoid exposing the full capsule functionality to the class state machine it's recommended to define an interface (i.e. abstract C++ class) which the capsule can implement. This interface can contain only those member functions which the class needs to call on the capsule.
+A common design pattern is to let a class-with-statemachine instance be managed by a single capsule instance. This means that the capsule instance is responsible both for creating, using and finally destroying the class-with-statemachine instance. If you follow this pattern it is thread-safe to, for example, call public member functions defined on the capsule from a transition in the class state machine (or, better, to call non-public member functions by letting the class be a friend of the capsule). This can for example be used as a means for the class state machine to send events through the ports of the capsule (i.e. it can call a capsule member function that sends the event). However, to avoid exposing the full capsule functionality to the class state machine it's recommended to define an interface (i.e. abstract C++ class) which the capsule can implement. This interface can contain only those member functions which the class needs to call on the capsule.
 
 A class state machine can use the same constructs as a capsule state machine with a few exceptions:
 
@@ -1188,7 +1188,7 @@ A class with state machine can have the [same code snippets](#capsule_code_snipp
     You can find a sample application that uses a class with a state machine [here]({$vars.github.repo$}/tree/main/art-samples/TrafficLight).
 
 ### Constructor
-By default the initial transition of a class state machine executes at the time of constructing the class-with-statemachine instance. This happens because the generated default constructor will call an operation `rtg_init1()` which contains the code from the initial transition. If you want to wait with "starting" the state machine until a later point in time you need to define your own parameterless constructor which doesn't call this function.
+By default the initial transition of a class state machine will not execute at the time of constructing the class-with-statemachine instance. If you want this to happen, you need to create a constructor with a call to the operation `rtg_init1()` which contains the code from the initial transition. If you want to wait with "starting" the state machine you can instead call `rtg_init1()` at a later point in time, for example from a regular member function of the class.
 
 You can define any constructors you need on a class with a state machine. They are regular C++ constructors and allow to pass initialization data when creating a class-with-statemachine instance. Remember to call the `rtg_init1()` function in all such constructors, if you want the state machine to start at the time of creating the class-with-statemachine instance.
 

docs-sources/building/transformation-configurations.md

@@ -124,7 +124,7 @@ Below is a table that lists all properties that can be used in a TC. Note that m
 | [compileArguments](#compilearguments) | String | N/A 
 | [compileCommand](#compilecommand) | String | "`$(CC)`"
 | [copyrightText](#copyrighttext) | String | N/A 
-| [cppCodeStandard](#cppcodestandard) | Enum string | "C++ 17"
+| [cppCodeStandard](#cppcodestandard) | Enum string | N/A (Compiler Default)
 | [eval](#eval) | TC object | N/A
 | [executableName](#executablename) | String | "`$(TOP_CAPSULE)$(EXEC_EXT)`"
 | [inclusionPaths](#inclusionpaths) | List of strings | []
@@ -189,7 +189,13 @@ All rights reserved!
 You can use a multi-line text with empty lines in the beginning and end as shown above, to make the TC more readable. Such empty lines will be ignored by the code generator.
 
 ### cppCodeStandard
-Defines the C++ language standard to which generated code will conform. The default value for this property is `C++ 17`. Other valid values are `C++ 98`, `C++ 11`, `C++ 14` and `C++ 20`. Note that the latest version of the TargetRTS requires at least C++ 11, so if you use an older code standard you have to set [TargetRTSLocation](#targetrtslocation) to an older version of the TargetRTS that doesn't contain any C++ 11 constructs. If you need to compile generated code with a very old compiler that doesn't even support C++ 98 you can set this preference to `Older than C++ 98`.
+Defines the C++ language standard to which generated C++ code will conform. Valid values for this property are `C++ 98`, `C++ 11`, `C++ 14`, `C++ 17` and `C++ 20`. If you need to compile generated code with a very old compiler that doesn't even support C++ 98 you can set this preference to `Older than C++ 98`.
+
+It's recommended to set this property to be explicit about what C++ code standard to use. Doing so ensures that the code generator generates C++ that complies with the selected code standard, and that the C++ compiler also will compile it with the same code standard. The C++ language server will also use the same code standard to ensure a correct behavior when editing C++ in the UI.
+
+If you don't set the [cppCodeStandard](#cppcodestandard) property, generated code will comply with C++ 17. But in that case no code standard flag will be passed to the compiler, and instead the compiler's default code standard will be used. Refer to the documentation of your compiler to know which code standard it uses by default. The same is true for the language server; it will use a default code standard.
+
+Note that even if the TargetRTS can be compiled also with old C++ compilers, some features will not be available for code standards before C++ 11. 
 
 ### eval
 This is a special property that returns a copy of the TC where all properties with implicit default values have been expanded into real values. It's useful when you want to define a TC property value based on the value of another TC property which has a default value.

docs-sources/validation.md

@@ -1730,6 +1730,12 @@ tc.prerequisites = ["lib2.tcjs"]; // TC_7017 (cycle lib1 -> lib2 -> lib1)
 tc.prerequisites = ["lib1.tcjs"]; // TC_7017 (cycle lib2 -> lib1 -> lib2)
 ```
 
+### TC_7018_withoutCodeStandard
+| Severity | Reason | Quick Fixes
+|----------|:-------------|:-------------
+| Warning | A TC does not specify which C++ code standard to use | N/A
+
+The [`cppCodeStandard`](building/transformation-configurations.md#cppcodestandard) property should be set to ensure that the C++ code generator, the C++ compiler and the C++ language server all agree on which code standard that should be used.
 
 ## Core Validation Rules
 There are certain core rules that run before the semantic validation rules mentioned above. They are responsible for making sure that the Art file is syntactically correct and that all references it contains can be successfully bound to valid Art elements.