Code / comment cleanup

Author: ritchiecarroll

src/Tests/Behavioral/ExprSwitch/ExprSwitch.cs

@@ -163,12 +163,54 @@ private static void Main() {
         var matchꞥ2 = false;
         if (next is <= -1) { matchꞥ2 = true;
             fmt.Println("negative");
+            {
+                var exprꞥ3 = getNext();
+                var matchꞥ3 = false;
+                if (exprꞥ3 is 1 or 2) { matchꞥ3 = true;
+                    fmt.Println("sub0 one or two");
+                }
+                if (exprꞥ3 is 3) { matchꞥ3 = true;
+                    fmt.Println("sub0 three");
+                    fallthrough = true;
+                }
+                if (fallthrough || !matchꞥ3) { /* default: */
+                    fmt.Println("sub0 default");
+                }
+            }
+
         }
         if (next is 0) { matchꞥ2 = true;
             fmt.Println("zero");
+            {
+                var nextɅ1 = getNext();
+                var matchꞥ4 = false;
+                if (nextɅ1 is 1 or <= 2) { matchꞥ4 = true;
+                    fmt.Println("sub1 one or two");
+                }
+                if (nextɅ1 is 3) { matchꞥ4 = true;
+                    fmt.Println("sub1 three");
+                    fallthrough = true;
+                }
+                if (fallthrough || !matchꞥ4) { /* default: */
+                    fmt.Println("sub1 default");
+                }
+            }
+
         }
         if (next is 1 or 2) { matchꞥ2 = true;
             fmt.Println("one or two");
+            switch (next) {
+            case 1 or 2:
+                fmt.Println("sub2 one or two");
+                break;
+            case 3:
+                fmt.Println("sub2 three");
+                break;
+            default:
+                fmt.Println("sub2 default");
+                break;
+            }
+
             fallthrough = true;
         }
         if (fallthrough || next >= 3 && next < 100) { matchꞥ2 = true;

src/Tests/Behavioral/ExprSwitch/ExprSwitch.go

@@ -137,10 +137,40 @@ func main() {
 	switch next := getNext(); {
 	case next <= -1:
 		fmt.Println("negative")
-	case next == 0:
+
+        switch getNext() {
+        case 1, 2:
+            fmt.Println("sub0 one or two")
+        case 3:
+            fmt.Println("sub0 three")
+            fallthrough
+        default:
+            fmt.Println("sub0 default")
+        }
+    case next == 0:
 		fmt.Println("zero")
+
+        switch next := getNext(); {
+        case next == 1, next <= 2:
+            fmt.Println("sub1 one or two")
+        case next == 3:
+            fmt.Println("sub1 three")
+            fallthrough
+        default:
+            fmt.Println("sub1 default")
+        }
 	case next == 1, next == 2:
 		fmt.Println("one or two")
+
+        switch next {
+        case 1, 2:
+            fmt.Println("sub2 one or two")
+        case 3:
+            fmt.Println("sub2 three")
+        default:
+            fmt.Println("sub2 default")
+        }
+
 		fallthrough
 	case next >= 3 && next < 100:
 		fmt.Printf("three or greater < 100: %d\n", x)

src/go2cs2/visitStmt.go

@@ -13,9 +13,6 @@ func (v *Visitor) visitStmt(stmt ast.Stmt, parentBlock *ast.BlockStmt) {
 		v.visitBlockStmt(stmtType, true, true)
 	case *ast.BranchStmt:
 		v.visitBranchStmt(stmtType)
-	// CaseClause visited in visitSwitchStmt
-	// case *ast.CaseClause:
-	// 	v.visitCaseClause(stmtType)
 	case *ast.CommClause:
 		v.visitCommClause(stmtType)
 	case *ast.DeclStmt:

src/gocore/golib/array.cs

@@ -41,7 +41,7 @@ public interface IArray : IEnumerable, ICloneable
 
     bool IndexIsValid(nint index)
     {
-        return index >= 0 && index < Length;
+        return index > -1 && index < Length;
     }
 }
 

src/gocore/golib/builtin.cs

@@ -57,10 +57,13 @@ private static class Zero<T>
     public const nint iota = 0;
 
     /// <summary>
-    /// Defines a constant used to represent an untyped integer value.
-    /// Commonly used for expression-based switch target / case values.
+    /// Defines a constant used to represent an always true state.
     /// </summary>
-    public const int ᐧ = 0;
+    /// <remarks>
+    /// Common use is for expression-based switch values where focus is
+    /// on <c>when</c> conditions and not the value itself.
+    /// </remarks>
+    public const bool ᐧ = true;
 
     /// <summary>
     /// Defines a constant to return a tuple that includes a boolean success indicator.

src/gocore/golib/ptr.cs

@@ -67,6 +67,7 @@ public ptr(in T value)
     internal ptr(IArray arrayRef, int index)
     {
         m_arrayRefIndex = (arrayRef, index);
+        m_val = default!;
     }
 
     /// <summary>
@@ -107,17 +108,16 @@ public ref T val
     /// <param name="index">Index of element to get pointer for.</param>
     /// <returns>Pointer to element at specified index.</returns>
     /// <exception cref="InvalidOperationException">Cannot get pointer element at index, type is not an array or slice.</exception>
+    /// <exception cref="IndexOutOfRangeException">Index is out of range for array or slice.</exception>
     public ptr<Telem> at<Telem>(int index)
     {
-        if (m_val is IArray<Telem> array)
-        {
-            if (!array.IndexIsValid(index))
-                throw new IndexOutOfRangeException("Index is out of range for array or slice.");
-
-            return new ptr<Telem>(array, index);
-        }
+        if (m_val is not IArray<Telem> array)
+            throw new InvalidOperationException("Cannot get pointer to element at index, type is not an array or slice.");
+        
+        if (!array.IndexIsValid(index))
+            throw new IndexOutOfRangeException("Index is out of range for array or slice.");
 
-        throw new InvalidOperationException("Cannot get pointer to element at index, type is not an array or slice.");
+        return new ptr<Telem>(array, index);
     }
 
     /// <inheritdoc />
@@ -206,7 +206,7 @@ public override int GetHashCode()
         return value == nil;
     }
 
-    public static bool operator !=(NilType nil, in ptr<T>? value)
+    public static bool operator !=(NilType nil, ptr<T>? value)
     {
         return value != nil;
     }