*: remove remaining stale references to synthetic timestamps

Informs #101938.

Release note: None

pkg/kv/kvpb/api.proto

@@ -2300,8 +2300,8 @@ message SubsumeResponse {
   //    through a range merge, to make the merge less disruptive to writes on
   //    the post-merge range because the timestamp cache won't be bumped as
   //    high.
-  // 2. it can transfer information about reads with synthetic timestamps, which
-  //    are not otherwise captured by the FreezeStart clock timestamp.
+  // 2. it can transfer information about reads with future-time timestamps,
+  //    which are not otherwise captured by the FreezeStart clock timestamp.
   kv.kvserver.readsummary.ReadSummary read_summary = 7;
 }
 

pkg/kv/kvpb/errors.go

@@ -1139,7 +1139,7 @@ func (e *ReadWithinUncertaintyIntervalError) RetryTimestamp() hlc.Timestamp {
 	// advance the txn's timestamp up to the local uncertainty limit on the node
 	// which hit the error. This ensures that no future read after the retry on
 	// this node (ignoring lease complications in ComputeLocalUncertaintyLimit
-	// and values with synthetic timestamps) will throw an uncertainty error,
+	// and values with future-time timestamps) will throw an uncertainty error,
 	// even when reading other keys.
 	//
 	// Note that if the request was not able to establish a local uncertainty
@@ -1153,9 +1153,9 @@ func (e *ReadWithinUncertaintyIntervalError) RetryTimestamp() hlc.Timestamp {
 	// In general, we expect the local uncertainty limit, if set, to be above
 	// the uncertainty value's timestamp. So we expect this Forward to advance
 	// ts. However, this is not always the case. The one exception is if the
-	// uncertain value had a synthetic timestamp, so it was compared against the
-	// global uncertainty limit to determine uncertainty (see IsUncertain). In
-	// such cases, we're ok advancing just past the value's timestamp. Either
+	// uncertain value had a future-time timestamp, so it was compared against
+	// the global uncertainty limit to determine uncertainty (see IsUncertain).
+	// In such cases, we're ok advancing just past the value's timestamp. Either
 	// way, we won't see the same value in our uncertainty interval on a retry.
 	ts.Forward(e.LocalUncertaintyLimit.ToTimestamp())
 	return ts

pkg/kv/kvserver/client_replica_test.go

@@ -76,12 +76,12 @@ import (
 
 // TestReplicaClockUpdates verifies that the leaseholder updates its clocks
 // when executing a command to the command's timestamp, as long as the
-// request timestamp is from a clock (i.e. is not synthetic).
+// request timestamp is from a clock (i.e. is not in the future).
 func TestReplicaClockUpdates(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 	defer log.Scope(t).Close(t)
 
-	run := func(t *testing.T, write bool, synthetic bool) {
+	run := func(t *testing.T, write bool, futureTime bool) {
 		const numNodes = 3
 		var manuals []*hlc.HybridManualClock
 		var clocks []*hlc.Clock
@@ -123,7 +123,7 @@ func TestReplicaClockUpdates(t *testing.T) {
 		// MaxOffset.
 		reqTS := clocks[0].Now().Add(clocks[0].MaxOffset().Nanoseconds()/2, 0)
 		h := kvpb.Header{Timestamp: reqTS}
-		if !synthetic {
+		if !futureTime {
 			h.Now = hlc.ClockTimestamp(reqTS)
 		}
 
@@ -144,13 +144,13 @@ func TestReplicaClockUpdates(t *testing.T) {
 		// practice an assertion against followers' clocks being updated is very
 		// difficult to make without being flaky because it's difficult to prevent
 		// other channels (background work, etc.) from carrying the clock update.
-		expUpdated := !synthetic
+		expUpdated := !futureTime
 		require.Equal(t, expUpdated, reqTS.Less(clocks[0].Now()))
 	}
 
 	testutils.RunTrueAndFalse(t, "write", func(t *testing.T, write bool) {
-		testutils.RunTrueAndFalse(t, "synthetic", func(t *testing.T, synthetic bool) {
-			run(t, write, synthetic)
+		testutils.RunTrueAndFalse(t, "future-time", func(t *testing.T, futureTime bool) {
+			run(t, write, futureTime)
 		})
 	})
 }

pkg/kv/kvserver/intentresolver/intent_resolver.go

@@ -442,10 +442,6 @@ func (ir *IntentResolver) MaybePushTransactions(
 		return nil, b.MustPErr()
 	}
 
-	// TODO(nvanbenschoten): if we succeed because the transaction has already
-	// been pushed _past_ where we were pushing, we need to set the synthetic
-	// bit. This is part of #36431.
-
 	br := b.RawResponse()
 	pushedTxns := make(map[uuid.UUID]*roachpb.Transaction, len(br.Responses))
 	for _, resp := range br.Responses {

pkg/kv/kvserver/kvserverpb/proposer_kv.proto

@@ -218,8 +218,8 @@ message ReplicatedEvalResult {
   // 1. it can transfer a higher-resolution snapshot of the reads on the range
   //    through a lease transfer, to make the lease transfers less disruptive to
   //    writes because the timestamp cache won't be bumped as high.
-  // 2. it can transfer information about reads with synthetic timestamps, which
-  //    are not otherwise captured by the new lease's start time.
+  // 2. it can transfer information about reads with future-time timestamps,
+  //    which are not otherwise captured by the new lease's start time.
   //
   // When a ReadSummary is set in a ReplicatedEvalResult, there is always also a
   // write to the RangePriorReadSummaryKey in the RaftCommand.WriteBatch. The

pkg/roachpb/data.go

@@ -966,9 +966,6 @@ func MakeTransaction(
 	omitInRangefeeds bool,
 ) Transaction {
 	u := uuid.FastMakeV4()
-	// TODO(nvanbenschoten): technically, gul should be a synthetic timestamp.
-	// Make this change in v21.2 when all nodes in a cluster are guaranteed to
-	// be aware of synthetic timestamps by addressing the TODO in Timestamp.Add.
 	gul := now.Add(maxOffsetNs, 0)
 
 	return Transaction{

pkg/roachpb/data.proto

@@ -194,8 +194,8 @@ message MergeTrigger {
   //    through a range merge, to make the merge less disruptive to writes on
   //    the post-merge range because the timestamp cache won't be bumped as
   //    high.
-  // 2. it can transfer information about reads with synthetic timestamps, which
-  //    are not otherwise captured by the FreezeStart clock timestamp.
+  // 2. it can transfer information about reads with future-time timestamps,
+  //    which are not otherwise captured by the FreezeStart clock timestamp.
   //
   // When a RightReadSummary is set in ReplicatedEvalResult.Merge.Trigger, there
   // is always also a write to the RangePriorReadSummaryKey in the corresponding

pkg/storage/pebble_mvcc_scanner.go

@@ -549,8 +549,8 @@ func (p *pebbleMVCCScanner) init(
 	p.uncertainty = ui
 	// We must check uncertainty even if p.ts >= local_uncertainty_limit
 	// because the local uncertainty limit cannot be applied to values with
-	// synthetic timestamps. We are only able to skip uncertainty checks if
-	// p.ts >= global_uncertainty_limit.
+	// future-time timestamps with earlier local timestamps. We are only able
+	// to skip uncertainty checks if p.ts >= global_uncertainty_limit.
 	p.checkUncertainty = p.ts.Less(p.uncertainty.GlobalLimit)
 }
 
@@ -1394,9 +1394,9 @@ func (p *pebbleMVCCScanner) seekVersion(
 			// is set to the transaction's global uncertainty limit, so we are
 			// seeking based on the worst-case uncertainty, but values with a
 			// time in the range (uncertainty.LocalLimit, uncertainty.GlobalLimit]
-			// are only uncertain if their timestamps are synthetic. Meanwhile,
-			// any value with a time in the range (ts, uncertainty.LocalLimit]
-			// is uncertain.
+			// are only uncertain if they have an earlier local timestamp that is
+			// before uncertainty.LocalLimit. Meanwhile, any value with a time in
+			// the range (ts, uncertainty.LocalLimit] is uncertain.
 			localTS := p.curUnsafeValue.GetLocalTimestamp(p.curUnsafeKey.Timestamp)
 			if p.uncertainty.IsUncertain(p.curUnsafeKey.Timestamp, localTS) {
 				return p.uncertaintyError(p.curUnsafeKey.Timestamp, localTS), false