comment for Expression

src/Neo.Compiler.CSharp/MethodConvert/Expression/AnonymousObjectCreationExpression.cs

@@ -18,6 +18,21 @@ namespace Neo.Compiler;
 
 partial class MethodConvert
 {
+    /// <summary>
+    /// Methods for converting the creation of an object of an anonymous type into a series of instructions.
+    /// </summary>
+    /// <param name="model">The semantic model providing context and information about the anonymous object creation.</param>
+    /// <param name="expression">The syntax representation of the  anonymous object creation statement being converted.</param>
+    /// <remarks>
+    /// Anonymous types provide a convenient way to encapsulate a set of read-only properties into a single object without having to explicitly define a type first. The type name is generated by the compiler and is not available at the source code level. The type of each property is inferred by the compiler.
+    /// </remarks>
+    /// <example>
+    /// The following example shows an anonymous type that is initialized with two properties named Amount and Message.
+    /// <code>
+    /// var v = new { Amount = 108, Message = "Hello" };
+    /// Runtime.Log(v.Amount + v.Message);
+    /// </code>
+    /// </example>
     private void ConvertAnonymousObjectCreationExpression(SemanticModel model, AnonymousObjectCreationExpressionSyntax expression)
     {
         AddInstruction(OpCode.NEWARRAY0);

src/Neo.Compiler.CSharp/MethodConvert/Expression/ArrayCreationExpression.cs

@@ -19,6 +19,28 @@ namespace Neo.Compiler;
 
 partial class MethodConvert
 {
+    /// <summary>
+    /// Converts the code for constructing arrays and initializing arrays into a sequence of instructions.
+    /// This method includes analyzing the array length, array type, array dimension and initial data.
+    /// </summary>
+    /// <param name="model">The semantic model providing context and information about the array creation.</param>
+    /// <param name="expression">The syntax representation of the array creation statement being converted.</param>
+    /// <exception cref="CompilationException">Only one-dimensional arrays are supported, otherwise an exception is thrown.</exception>
+    /// <remarks>
+    /// When the array is initialized to null, this code converts it to "array length" + OpCode.NEWBUFFER (only for byte[]) or  OpCode.NEWARRAY_T.
+    /// When the array is not initialized to null, this code converts the initialized constants one by one in reverse order, then adds the "array length" and OpCode.PACK
+    /// </remarks>
+    /// <example>
+    /// Example of a array creation syntax:
+    /// <code>
+    /// var array = new byte[4];
+    /// </code>
+    /// The compilation result of the example code is: OpCode.PUSH4, OpCode.NEWBUFFER
+    /// <code>
+    /// var array = new int[4] { 5, 6, 7, 8};
+    /// </code>
+    /// The compilation result of the example code is: OpCode.PUSH8, OpCode.PUSH7, OpCode.PUSH6, OpCode.PUSH5, OpCode.PUSH4, OpCode.PACK
+    /// </example>
     private void ConvertArrayCreationExpression(SemanticModel model, ArrayCreationExpressionSyntax expression)
     {
         ArrayRankSpecifierSyntax specifier = expression.Type.RankSpecifiers[0];

src/Neo.Compiler.CSharp/MethodConvert/Expression/AssignmentExpression.cs

@@ -17,6 +17,26 @@ namespace Neo.Compiler;
 
 partial class MethodConvert
 {
+    /// <summary>
+    /// The assignment operator = assigns the value of its right-hand operand to a variable,
+    /// a property, or an indexer element given by its left-hand operand.
+    /// The result of an assignment expression is the value assigned to the left-hand operand.
+    /// The type of the right-hand operand must be the same as the type of the left-hand operand or implicitly convertible to it.
+    /// The null-coalescing assignment operator ??= assigns the value of its right-hand operand to its left-hand operand only if the left-hand operand evaluates to null.
+    /// The ??= operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-null.
+    /// </summary>
+    /// <param name="model">The semantic model providing context and information about assignment expression.</param>
+    /// <param name="expression">The syntax representation of the assignment expression statement being converted.</param>
+    /// <example>
+    /// The assignment operator = is right-associative, that is, an expression of the form
+    /// <code>
+    /// a = b = c
+    /// </code>
+    /// is evaluated as
+    /// <code>
+    /// a = (b = c)
+    /// </code>
+    /// </example>
     private void ConvertAssignmentExpression(SemanticModel model, AssignmentExpressionSyntax expression)
     {
         switch (expression.OperatorToken.ValueText)

src/Neo.Compiler.CSharp/MethodConvert/Expression/BinaryExpression.cs

@@ -19,6 +19,26 @@ namespace Neo.Compiler;
 
 partial class MethodConvert
 {
+    /// <summary>
+    /// The conditional logical OR operator ||, also known as the "short-circuiting" logical OR operator, computes the logical OR of its operands.
+    /// The result of x || y is true if either x or y evaluates to true.
+    /// Otherwise, the result is false. If x evaluates to true, y isn't evaluated.
+    /// 
+    /// The conditional logical AND operator &&, also known as the "short-circuiting" logical AND operator, computes the logical AND of its operands.
+    /// The result of x && y is true if both x and y evaluate to true.
+    /// Otherwise, the result is false. If x evaluates to false, y isn't evaluated.
+    ///
+    /// The is operator checks if the run-time type of an expression result is compatible with a given type. The is operator also tests an expression result against a pattern.
+    ///
+    /// The as operator explicitly converts the result of an expression to a given reference or nullable value type. If the conversion isn't possible, the as operator returns null. Unlike a cast expression, the as operator never throws an exception.
+    /// 
+    /// The null-coalescing operator ?? returns the value of its left-hand operand if it isn't null;
+    /// otherwise, it evaluates the right-hand operand and returns its result.
+    /// The ?? operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-null. 
+    /// </summary>
+    /// <param name="model">The semantic model providing context and information about binary expression.</param>
+    /// <param name="expression">The syntax representation of the binary expression statement being converted.</param>
+    /// <exception cref="CompilationException">If an unsupported operator is encountered</exception>
     private void ConvertBinaryExpression(SemanticModel model, BinaryExpressionSyntax expression)
     {
         switch (expression.OperatorToken.ValueText)

src/Neo.Compiler.CSharp/MethodConvert/Expression/TupleExpression.cs

@@ -18,6 +18,21 @@ namespace Neo.Compiler;
 
 partial class MethodConvert
 {
+    /// <summary>
+    /// Converts the code for tuple type into a sequence of instructions.
+    /// </summary>
+    /// <param name="model">The semantic model providing context and information about the tuple type.</param>
+    /// <param name="expression">The syntax representation of the tuple type statement being converted.</param>
+    /// <example>
+    /// The tuples feature provides concise syntax to group multiple data elements in a lightweight data structure.
+    /// The following example shows how you can declare a tuple variable, initialize it, and access its data members:
+    /// <code>
+    /// (string, int) t1 = ("chris", 3);
+    /// Runtime.Log($"Tuple with elements {t1.Item1} and {t1.Item2}.");
+    /// (string Name, int Count) t2 = ("chris", 3);
+    /// Runtime.Log($"Sum of {t2.Name} elements is {t2.Count}.");
+    /// </code>
+    /// </example>
     private void ConvertTupleExpression(SemanticModel model, TupleExpressionSyntax expression)
     {
         AddInstruction(OpCode.NEWSTRUCT0);