golang
diff --git a/‎src/time/abs_test.go
Copy file name to clipboard
+183Lines changed: 183 additions & 0 deletions b/‎src/time/abs_test.go
Copy file name to clipboard
+183Lines changed: 183 additions & 0 deletions
diff --git a/‎src/time/format.go
Copy file name to clipboard
+19-15Lines changed: 19 additions & 15 deletions b/‎src/time/format.go
Copy file name to clipboard
+19-15Lines changed: 19 additions & 15 deletions
diff --git a/‎src/time/format_rfc3339.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎src/time/format_rfc3339.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎src/time/linkname_test.go
Copy file name to clipboard
+41Lines changed: 41 additions & 0 deletions b/‎src/time/linkname_test.go
Copy file name to clipboard
+41Lines changed: 41 additions & 0 deletions
@@ -0,0 +1,183 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package time
+
+type testingT interface {
+	Error(args ...any)
+	Errorf(format string, args ...any)
+	Fail()
+	FailNow()
+	Failed() bool
+	Fatal(args ...any)
+	Fatalf(format string, args ...any)
+	Helper()
+	Log(args ...any)
+	Logf(format string, args ...any)
+	Skip(args ...any)
+	SkipNow()
+	Skipf(format string, args ...any)
+}
+
+var InternalTests = []struct {
+	Name string
+	Test func(testingT)
+}{
+	{"AbsDaysSplit", testAbsDaysSplit},
+	{"AbsYdaySplit", testAbsYdaySplit},
+	{"AbsDate", testAbsDate},
+	{"DateToAbsDays", testDateToAbsDays},
+	{"DaysIn", testDaysIn},
+	{"DaysBefore", testDaysBefore},
+}
+
+func testAbsDaysSplit(t testingT) {
+	isLeap := func(year uint64) bool {
+		return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+	}
+	bad := 0
+	wantYear := uint64(0)
+	wantYday := absYday(0)
+	for days := range absDays(1e6) {
+		century, cyear, yday := days.split()
+		if century != absCentury(wantYear/100) || cyear != absCyear(wantYear%100) || yday != wantYday {
+			t.Errorf("absDays(%d).split() = %d, %d, %d, want %d, %d, %d",
+				days, century, cyear, yday,
+				wantYear/100, wantYear%100, wantYday)
+			if bad++; bad >= 20 {
+				t.Fatalf("too many errors")
+			}
+		}
+		end := absYday(365)
+		if isLeap(wantYear + 1) {
+			end = 366
+		}
+		if wantYday++; wantYday == end {
+			wantYear++
+			wantYday = 0
+		}
+	}
+}
+
+func testAbsYdaySplit(t testingT) {
+	ends := []int{31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29}
+	bad := 0
+	wantMonth := absMonth(3)
+	wantDay := 1
+	for yday := range absYday(366) {
+		month, day := yday.split()
+		if month != wantMonth || day != wantDay {
+			t.Errorf("absYday(%d).split() = %d, %d, want %d, %d", yday, month, day, wantMonth, wantDay)
+			if bad++; bad >= 20 {
+				t.Fatalf("too many errors")
+			}
+		}
+		if wantDay++; wantDay > ends[wantMonth-3] {
+			wantMonth++
+			wantDay = 1
+		}
+	}
+}
+
+func testAbsDate(t testingT) {
+	ends := []int{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+	isLeap := func(year int) bool {
+		y := uint64(year) + absoluteYears
+		return y%4 == 0 && (y%100 != 0 || y%400 == 0)
+	}
+	wantYear := 0
+	wantMonth := March
+	wantMday := 1
+	wantYday := 31 + 29 + 1
+	bad := 0
+	absoluteYears := int64(absoluteYears)
+	for days := range absDays(1e6) {
+		year, month, mday := days.date()
+		year += int(absoluteYears)
+		if year != wantYear || month != wantMonth || mday != wantMday {
+			t.Errorf("days(%d).date() = %v, %v, %v, want %v, %v, %v", days,
+				year, month, mday,
+				wantYear, wantMonth, wantMday)
+			if bad++; bad >= 20 {
+				t.Fatalf("too many errors")
+			}
+		}
+
+		year, yday := days.yearYday()
+		year += int(absoluteYears)
+		if year != wantYear || yday != wantYday {
+			t.Errorf("days(%d).yearYday() = %v, %v, want %v, %v, ", days,
+				year, yday,
+				wantYear, wantYday)
+			if bad++; bad >= 20 {
+				t.Fatalf("too many errors")
+			}
+		}
+
+		if wantMday++; wantMday == ends[wantMonth-1]+1 || wantMonth == February && wantMday == 29 && !isLeap(year) {
+			wantMonth++
+			wantMday = 1
+		}
+		wantYday++
+		if wantMonth == December+1 {
+			wantYear++
+			wantMonth = January
+			wantMday = 1
+			wantYday = 1
+		}
+	}
+}
+
+func testDateToAbsDays(t testingT) {
+	isLeap := func(year int64) bool {
+		return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+	}
+	wantDays := absDays(marchThruDecember)
+	bad := 0
+	for year := int64(1); year < 10000; year++ {
+		days := dateToAbsDays(year-absoluteYears, January, 1)
+		if days != wantDays {
+			t.Errorf("dateToAbsDays(abs %d, Jan, 1) = %d, want %d", year, days, wantDays)
+			if bad++; bad >= 20 {
+				t.Fatalf("too many errors")
+			}
+		}
+		wantDays += 365
+		if isLeap(year) {
+			wantDays++
+		}
+	}
+}
+
+func testDaysIn(t testingT) {
+	isLeap := func(year int) bool {
+		return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+	}
+	want := []int{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+	bad := 0
+	for year := 0; year <= 1600; year++ {
+		for m := January; m <= December; m++ {
+			w := want[m]
+			if m == February && isLeap(year) {
+				w++
+			}
+			d := daysIn(m, year-800)
+			if d != w {
+				t.Errorf("daysIn(%v, %d) = %d, want %d", m, year-800, d, w)
+				if bad++; bad >= 20 {
+					t.Fatalf("too many errors")
+				}
+			}
+		}
+	}
+}
+
+func testDaysBefore(t testingT) {
+	for m, want := range []int{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365} {
+		d := daysBefore(Month(m + 1))
+		if d != want {
+			t.Errorf("daysBefore(%d) = %d, want %d", m, d, want)
+		}
+	}
+}
@@ -140,7 +140,7 @@ const (
 	stdDay                                         // "2"
 	stdUnderDay                                    // "_2"
 	stdZeroDay                                     // "02"
-	stdUnderYearDay                                // "__2"
+	stdUnderYearDay          = iota + stdNeedYday  // "__2"
 	stdZeroYearDay                                 // "002"
 	stdHour                  = iota + stdNeedClock // "15"
 	stdHour12                                      // "3"
@@ -168,7 +168,8 @@ const (
 	stdFracSecond9                                 // ".9", ".99", ..., trailing zeros omitted
 
 	stdNeedDate       = 1 << 8             // need month, day, year
-	stdNeedClock      = 2 << 8             // need hour, minute, second
+	stdNeedYday       = 1 << 9             // need yday
+	stdNeedClock      = 1 << 10            // need hour, minute, second
 	stdArgShift       = 16                 // extra argument in high bits, above low stdArgShift
 	stdSeparatorShift = 28                 // extra argument in high 4 bits for fractional second separators
 	stdMask           = 1<<stdArgShift - 1 // mask out argument
@@ -574,9 +575,9 @@ func (t Time) String() string {
 // GoString implements [fmt.GoStringer] and formats t to be printed in Go source
 // code.
 func (t Time) GoString() string {
-	abs := t.abs()
-	year, month, day, _ := absDate(abs, true)
-	hour, minute, second := absClock(abs)
+	abs := t.absSec()
+	year, month, day := abs.days().date()
+	hour, minute, second := abs.clock()
 
 	buf := make([]byte, 0, len("time.Date(9999, time.September, 31, 23, 59, 59, 999999999, time.Local)"))
 	buf = append(buf, "time.Date("...)
@@ -664,13 +665,14 @@ func (t Time) AppendFormat(b []byte, layout string) []byte {
 }
 
 func (t Time) appendFormat(b []byte, layout string) []byte {
-	var (
-		name, offset, abs = t.locabs()
+	name, offset, abs := t.locabs()
+	days := abs.days()
 
+	var (
 		year  int = -1
 		month Month
 		day   int
-		yday  int
+		yday  int = -1
 		hour  int = -1
 		min   int
 		sec   int
@@ -689,13 +691,15 @@ func (t Time) appendFormat(b []byte, layout string) []byte {
 
 		// Compute year, month, day if needed.
 		if year < 0 && std&stdNeedDate != 0 {
-			year, month, day, yday = absDate(abs, true)
-			yday++
+			year, month, day = days.date()
+		}
+		if yday < 0 && std&stdNeedYday != 0 {
+			_, yday = days.yearYday()
 		}
 
 		// Compute hour, minute, second if needed.
 		if hour < 0 && std&stdNeedClock != 0 {
-			hour, min, sec = absClock(abs)
+			hour, min, sec = abs.clock()
 		}
 
 		switch std & stdMask {
@@ -717,9 +721,9 @@ func (t Time) appendFormat(b []byte, layout string) []byte {
 		case stdZeroMonth:
 			b = appendInt(b, int(month), 2)
 		case stdWeekDay:
-			b = append(b, absWeekday(abs).String()[:3]...)
+			b = append(b, days.weekday().String()[:3]...)
 		case stdLongWeekDay:
-			s := absWeekday(abs).String()
+			s := days.weekday().String()
 			b = append(b, s...)
 		case stdDay:
 			b = appendInt(b, day, 0)
@@ -1350,10 +1354,10 @@ func parse(layout, value string, defaultLocation, local *Location) (Time, error)
 		}
 		if m == 0 {
 			m = (yday-1)/31 + 1
-			if int(daysBefore[m]) < yday {
+			if daysBefore(Month(m+1)) < yday {
 				m++
 			}
-			d = yday - int(daysBefore[m-1])
+			d = yday - daysBefore(Month(m))
 		}
 		// If month, day already seen, yday's m, d must match.
 		// Otherwise, set them from m, d.
 
@@ -19,7 +19,7 @@ func (t Time) appendFormatRFC3339(b []byte, nanos bool) []byte {
 	_, offset, abs := t.locabs()
 
 	// Format date.
-	year, month, day, _ := absDate(abs, true)
+	year, month, day := abs.days().date()
 	b = appendInt(b, year, 4)
 	b = append(b, '-')
 	b = appendInt(b, int(month), 2)
@@ -29,7 +29,7 @@ func (t Time) appendFormatRFC3339(b []byte, nanos bool) []byte {
 	b = append(b, 'T')
 
 	// Format time.
-	hour, min, sec := absClock(abs)
+	hour, min, sec := abs.clock()
 	b = appendInt(b, hour, 2)
 	b = append(b, ':')
 	b = appendInt(b, min, 2)
 
@@ -0,0 +1,41 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package time_test
+
+import (
+	"testing"
+	"time"
+	_ "unsafe" // for linkname
+)
+
+//go:linkname timeAbs time.Time.abs
+func timeAbs(time.Time) uint64
+
+//go:linkname absClock time.absClock
+func absClock(uint64) (hour, min, sec int)
+
+//go:linkname absDate time.absDate
+func absDate(uint64, bool) (year int, month time.Month, day int, yday int)
+
+func TestLinkname(t *testing.T) {
+	tm := time.Date(2006, time.January, 2, 15, 4, 5, 6, time.UTC)
+	abs := timeAbs(tm)
+	// wantAbs should be Jan 1 based, not Mar 1 based.
+	// See absolute time description in time.go.
+	const wantAbs = 9223372029851535845 // NOT 9223372029877973939
+	if abs != wantAbs {
+		t.Fatalf("timeAbs(2006-01-02 15:04:05 UTC) = %d, want %d", abs, uint64(wantAbs))
+	}
+
+	year, month, day, yday := absDate(abs, true)
+	if year != 2006 || month != time.January || day != 2 || yday != 1 {
+		t.Errorf("absDate() = %v, %v, %v, %v, want 2006, January, 2, 1", year, month, day, yday)
+	}
+
+	hour, min, sec := absClock(abs)
+	if hour != 15 || min != 4 || sec != 5 {
+		t.Errorf("absClock() = %v, %v, %v, 15, 4, 5", hour, min, sec)
+	}
+}