From 04f8e8315506650245480862c65003906f61b485 Mon Sep 17 00:00:00 2001
From: Tharun Rajendran <tharunrajendran@Tharuns-MacBook-Pro.local>
Date: Thu, 14 Dec 2023 12:45:47 +0530
Subject: [PATCH] Cleanup dead code and incorrect use of go routine in context
 pkg

---
 internal/context.go | 104 ++++----------------------------------------
 1 file changed, 9 insertions(+), 95 deletions(-)

diff --git a/internal/context.go b/internal/context.go
index 8480d5077..32dde60b9 100644
--- a/internal/context.go
+++ b/internal/context.go
@@ -198,13 +198,14 @@ func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
 
 // NewDisconnectedContext returns a new context that won't propagate parent's cancellation to the new child context.
 // One common use case is to do cleanup work after workflow is canceled.
-//  err := workflow.ExecuteActivity(ctx, ActivityFoo).Get(ctx, &activityFooResult)
-//  if err != nil && temporal.IsCanceledError(ctx.Err()) {
-//    // activity failed, and workflow context is canceled
-//    disconnectedCtx, _ := workflow.NewDisconnectedContext(ctx);
-//    workflow.ExecuteActivity(disconnectedCtx, handleCancellationActivity).Get(disconnectedCtx, nil)
-//    return err // workflow return CanceledError
-//  }
+//
+//	err := workflow.ExecuteActivity(ctx, ActivityFoo).Get(ctx, &activityFooResult)
+//	if err != nil && temporal.IsCanceledError(ctx.Err()) {
+//	  // activity failed, and workflow context is canceled
+//	  disconnectedCtx, _ := workflow.NewDisconnectedContext(ctx);
+//	  workflow.ExecuteActivity(disconnectedCtx, handleCancellationActivity).Get(disconnectedCtx, nil)
+//	  return err // workflow return CanceledError
+//	}
 func NewDisconnectedContext(parent Context) (ctx Context, cancel CancelFunc) {
 	c := newCancelCtx(parent)
 	return c, func() { c.cancel(true, ErrCanceled) }
@@ -236,14 +237,7 @@ func propagateCancel(parent Context, child canceler) {
 			p.childrenLock.Unlock()
 		}
 	} else {
-		go func() {
-			s := NewSelector(parent)
-			s.AddReceive(parent.Done(), func(c ReceiveChannel, more bool) {
-				child.cancel(false, parent.Err())
-			})
-			s.AddReceive(child.Done(), func(c ReceiveChannel, more bool) {})
-			s.Select(parent)
-		}()
+		panic("cancelCtx not found")
 	}
 }
 
@@ -255,9 +249,6 @@ func parentCancelCtx(parent Context) (*cancelCtx, bool) {
 		switch c := parent.(type) {
 		case *cancelCtx:
 			return c, true
-		// TODO: Uncomment once timer story is implemented
-		//case *timerCtx:
-		//	return c.cancelCtx, true
 		case *valueCtx:
 			parent = c.Context
 		default:
@@ -345,83 +336,6 @@ func (c *cancelCtx) cancel(removeFromParent bool, err error) {
 	}
 }
 
-// Commented out until workflow time API is exposed.
-// WithDeadline returns a copy of the parent context with the deadline adjusted
-// to be no later than d.  If the parent's deadline is already earlier than d,
-// WithDeadline(parent, d) is semantically equivalent to parent.  The returned
-// context's Done channel is closed when the deadline expires, when the returned
-// cancel function is called, or when the parent context's Done channel is
-// closed, whichever happens first.
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete.
-//func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
-//	if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
-//		// The current deadline is already sooner than the new one.
-//		return WithCancel(parent)
-//	}
-//	c := &timerCtx{
-//		cancelCtx: newCancelCtx(parent),
-//		deadline:  deadline,
-//	}
-//	propagateCancel(parent, c)
-//	d := deadline.Sub(time.Now())
-//	if d <= 0 {
-//		c.cancel(true, DeadlineExceeded) // deadline has already passed
-//		return c, func() { c.cancel(true, Canceled) }
-//	}
-//	if c.err == nil {
-//		c.timer = time.AfterFunc(d, func() {
-//			c.cancel(true, DeadlineExceeded)
-//		})
-//	}
-//	return c, func() { c.cancel(true, Canceled) }
-//}
-//
-//// A timerCtx carries a timer and a deadline.  It embeds a cancelCtx to
-//// implement Done and Err.  It implements cancel by stopping its timer then
-//// delegating to cancelCtx.cancel.
-//type timerCtx struct {
-//	*cancelCtx
-//	timer *time.Timer // Under cancelCtx.mu.
-//
-//	deadline time.Time
-//}
-//
-//func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
-//	return c.deadline, true
-//}
-//
-//func (c *timerCtx) String() string {
-//	return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now()))
-//}
-//
-//func (c *timerCtx) cancel(removeFromParent bool, err error) {
-//	c.cancelCtx.cancel(false, err)
-//	if removeFromParent {
-//		// Remove this timerCtx from its parent cancelCtx's children.
-//		removeChild(c.cancelCtx.Context, c)
-//	}
-//	if c.timer != nil {
-//		c.timer.Stop()
-//		c.timer = nil
-//	}
-//}
-//
-// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete:
-//
-// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
-// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
-// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
-// 		return slowOperation(ctx)
-// 	}
-//func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
-//	return WithDeadline(parent, time.Now().Add(timeout))
-//}
-
 // WithValue returns a copy of parent in which the value associated with key is
 // val.
 //