Updated channel handling for specified direction (send or receive)

src/Tests/Behavioral/SelectStatement/SelectStatement.cs

@@ -24,17 +24,21 @@ private static void fibonacci(channel<nint> f, channel<nint> quit) {
     nint x = 0;
     nint y = 1;
     while (ᐧ) {
-        switch (WhenAny(f.ᐸꟷ(x), quit.Receiving)) {
+        switch (WhenAny(f.ᐸꟷ(x, ꟷ), quit.Receiving)) {
         case 0:
             (x, y) = (y, x + y);
             break;
-        case 1 when ᐸꟷ(quit, OK).ok:
+        case 1 when ᐸꟷ(quit, ꟷ).ok:
             fmt.Println("quit");
             return;
         }
     }
 }
 
+private static void sendOnly(channel/*<-*/<@string> s) {
+    s.ᐸꟷ("output"u8);
+}
+
 private static void Main() {
     var ch = new channel<nint>(2);
     ch.ᐸꟷ(1);
@@ -71,6 +75,9 @@ private static void Main() {
         quit.ᐸꟷ(0);
     });
     fibonacci(f, quit);
+    var mychanl = new channel<@string>(1);
+    goǃ(_ => sendOnly(mychanl));
+    fmt.Println(ᐸꟷ(mychanl));
 }
 
 } // end main_package

src/Tests/Behavioral/SelectStatement/SelectStatement.go

@@ -33,6 +33,10 @@ func fibonacci(f, quit chan int) {
 	}
 }
 
+func sendOnly(s chan<- string) {
+    s <- "output"
+}
+
 func main() {
 	ch := make(chan int, 2)
 
@@ -76,4 +80,11 @@ func main() {
 		quit <- 0
 	}()
 	fibonacci(f, quit)
+
+    mychanl := make(chan string)
+
+    // function converts bidirectional channel to send only channel
+    go sendOnly(mychanl)
+
+    fmt.Println(<-mychanl)
 }

src/go2cs2/ToDo.md

@@ -18,7 +18,7 @@
   b) Handle `case a[f()] = <-c4: // same as: case t := <-c4 { a[f()] = t }`
   c) Handle multi-valued assignment form of (with OK to test for closed channel).
   d) Test `nil` channel which is never ready for communication
-  e) Handle channels with specified direction (send or receive)
+  e) ~~Handle channels with specified direction (send or receive)~~
 11) ~~Complete send statement implementation (`visitSendStmt`)~~
 12) Complete struct interfaces and embedding (will need C# GoType code converter work)
 13) Complete interface inheritance (will need C# GoType code converter work)

src/go2cs2/main.go

@@ -119,6 +119,7 @@ const ShadowVarMarker = "\u0394"             // Variants: Δ Ʌ ꞥ
 const CapturedVarMarker = "\u0297"           // Variants: ʗ ɔ ᴄ
 const TempVarMarker = "\u1D1B"               // Variants: ᴛ Ŧ ᵀ
 const TrueMarker = "\u1427"                  // Variants: ᐧ true
+const OverloadDiscriminator = "\uA7F7"       // Variants: ꟷ false
 const ElipsisOperator = "\uA4F8\uA4F8\uA4F8" // Variants: ꓸꓸꓸ ᐧᐧᐧ
 const ChannelLeftOp = "\u1438\uA7F7"         // Example: `ch.ᐸꟷ(val)` for `ch <- val`
 const ChannelRightOp = "\uA7F7\u1433"        // Example: `ch.ꟷᐳ(out var val)` for `val := <-ch`
@@ -860,6 +861,13 @@ func convertToCSFullTypeName(typeName string) string {
 		return fmt.Sprintf("%s.channel<%s>", RootNamespace, convertToCSTypeName(typeName[5:]))
 	}
 
+	if strings.HasPrefix(typeName, "chan<- ") {
+		return fmt.Sprintf("%s.channel/*<-*/<%s>", RootNamespace, convertToCSTypeName(typeName[7:]))
+	}
+
+	if strings.HasPrefix(typeName, "<-chan ") {
+		return fmt.Sprintf("%s./*<-*/channel<%s>", RootNamespace, convertToCSTypeName(typeName[7:]))
+	}
 	if typeName == "func()" {
 		return "System.Action"
 	}

src/go2cs2/visitSelectStmt.go

@@ -71,6 +71,12 @@ func (v *Visitor) visitSelectStmt(selectStmt *ast.SelectStmt, source ParentBlock
 
 				v.targetFile.WriteRune('(')
 				v.targetFile.WriteString(v.convExpr(sendStmt.Value, nil))
+
+				if v.options.useChannelOperators {
+					v.targetFile.WriteString(", ")
+					v.targetFile.WriteString(OverloadDiscriminator)
+				}
+
 				v.targetFile.WriteRune(')')
 				handled = true
 			} else if exprStmt, ok := comClause.Comm.(*ast.ExprStmt); ok {
@@ -149,7 +155,9 @@ func (v *Visitor) visitSelectStmt(selectStmt *ast.SelectStmt, source ParentBlock
 								v.targetFile.WriteString(ChannelLeftOp)
 								v.targetFile.WriteRune('(')
 								v.targetFile.WriteString(v.convExpr(unaryExpr.X, nil))
-								v.targetFile.WriteString(", OK).ok")
+								v.targetFile.WriteString(", ")
+								v.targetFile.WriteString(OverloadDiscriminator)
+								v.targetFile.WriteString(").ok")
 							} else {
 								v.targetFile.WriteString(v.convExpr(unaryExpr.X, nil))
 								v.targetFile.WriteString(".Received(out _)")

src/gocore/golib/builtin.cs

@@ -66,19 +66,10 @@ private static class Zero<T>
     public const bool ᐧ = true;
 
     /// <summary>
-    /// Defines a constant to return a tuple that includes a boolean success indicator.
+    /// Defines a constant used as a discriminator for accessing overloads with
+    /// different return types.
     /// </summary>
-    public const bool OK = false;
-
-    /// <summary>
-    /// Defines a constant to return a tuple that includes an error indicator.
-    /// </summary>
-    public const bool ERR = false;
-
-    /// <summary>
-    /// Defines a constant to return a tuple that includes a value.
-    /// </summary>
-    public const bool VAL = false;
+    public const bool ꟷ = false;
 
     /// <summary>
     /// nil is a predeclared identifier representing the zero value for a pointer, channel,

src/gocore/golib/channel.cs

@@ -220,14 +220,30 @@ public bool TrySend(in T value, CancellationToken cancellationToken)
     /// </summary>
     /// <param name="value">Value to send.</param>
     /// <remarks>
-    /// For a buffered channel, method will block the current thread
-    /// if channel is full.
+    /// For a buffered channel, method will block the current thread if channel is full.
     /// </remarks>
     public void Send(in T value)
     {
         Send(value, CancellationToken.None);
     }
 
+    /// <summary>
+    /// Sends an item to channel. 
+    /// </summary>
+    /// <param name="value">Value to send.</param>
+    /// <remarks>
+    /// <para>
+    /// For a buffered channel, method will block the current thread if channel is full.
+    /// </para>
+    /// <para>
+    /// Defines a Go style channel Send operation.
+    /// </para>
+    /// </remarks>
+    public void ᐸꟷ(in T value)
+    {
+        Send(value, CancellationToken.None);
+    }
+
     /// <summary>
     /// Queues an item to channel for sending during select operation returning
     /// a wait handle that is set when the send operation is complete.
@@ -255,11 +271,12 @@ private void ProcessSendQueue(object? state)
     /// a wait handle that is set when the send operation is complete.
     /// </summary>
     /// <param name="value">Value to send.</param>
+    /// <param name="_">Overload discriminator for different return type.</param>
     /// <returns>Wait handle for queued send operation.</returns>
     /// <remarks>
     /// Defines a Go style channel Send operation.
     /// </remarks>
-    public WaitHandle ᐸꟷ(in T value)
+    public WaitHandle ᐸꟷ(in T value, bool _)
     {
         return Sending(value);
     }

src/gocore/golib/golib.csproj

@@ -52,6 +52,8 @@
     <Using Include="System.Numerics.Complex" Alias="complex128" />
     <Using Include="System.Int32" Alias="rune" />
     <Using Include="System.UIntPtr" Alias="uintptr" />
+    <Using Include="System.Numerics.BigInteger" Alias="GoUntyped" />
+    <Using Include="System.ComponentModel.DescriptionAttribute" Alias="GoTag" />
 
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
   </ItemGroup>