Merge remote-tracking branch 'upstream/master'

Author: actions-user

src/cmd/compile/internal/ssa/_gen/ARM64.rules

@@ -1385,16 +1385,18 @@
 (CSNEG [cc] x y (InvertFlags cmp)) => (CSNEG [arm64Invert(cc)] x y cmp)
 
 // absorb flag constants into boolean values
-(Equal         (FlagConstant [fc])) => (MOVDconst [b2i(fc.eq())])
-(NotEqual      (FlagConstant [fc])) => (MOVDconst [b2i(fc.ne())])
-(LessThan      (FlagConstant [fc])) => (MOVDconst [b2i(fc.lt())])
-(LessThanU     (FlagConstant [fc])) => (MOVDconst [b2i(fc.ult())])
-(LessEqual     (FlagConstant [fc])) => (MOVDconst [b2i(fc.le())])
-(LessEqualU    (FlagConstant [fc])) => (MOVDconst [b2i(fc.ule())])
-(GreaterThan   (FlagConstant [fc])) => (MOVDconst [b2i(fc.gt())])
-(GreaterThanU  (FlagConstant [fc])) => (MOVDconst [b2i(fc.ugt())])
-(GreaterEqual  (FlagConstant [fc])) => (MOVDconst [b2i(fc.ge())])
-(GreaterEqualU (FlagConstant [fc])) => (MOVDconst [b2i(fc.uge())])
+(Equal             (FlagConstant [fc])) => (MOVDconst [b2i(fc.eq())])
+(NotEqual          (FlagConstant [fc])) => (MOVDconst [b2i(fc.ne())])
+(LessThan          (FlagConstant [fc])) => (MOVDconst [b2i(fc.lt())])
+(LessThanU         (FlagConstant [fc])) => (MOVDconst [b2i(fc.ult())])
+(LessEqual         (FlagConstant [fc])) => (MOVDconst [b2i(fc.le())])
+(LessEqualU        (FlagConstant [fc])) => (MOVDconst [b2i(fc.ule())])
+(GreaterThan       (FlagConstant [fc])) => (MOVDconst [b2i(fc.gt())])
+(GreaterThanU      (FlagConstant [fc])) => (MOVDconst [b2i(fc.ugt())])
+(GreaterEqual      (FlagConstant [fc])) => (MOVDconst [b2i(fc.ge())])
+(GreaterEqualU     (FlagConstant [fc])) => (MOVDconst [b2i(fc.uge())])
+(LessThanNoov      (FlagConstant [fc])) => (MOVDconst [b2i(fc.ltNoov())])
+(GreaterEqualNoov  (FlagConstant [fc])) => (MOVDconst [b2i(fc.geNoov())])
 
 // absorb InvertFlags into boolean values
 (Equal            (InvertFlags x)) => (Equal x)

src/cmd/compile/internal/ssa/rewriteARM64.go

@@ -288,11 +288,17 @@ func withCancel(parent Context) *cancelCtx {
 func Cause(c Context) error {
 	if cc, ok := c.Value(&cancelCtxKey).(*cancelCtx); ok {
 		cc.mu.Lock()
-		defer cc.mu.Unlock()
-		return cc.cause
+		cause := cc.cause
+		cc.mu.Unlock()
+		if cause != nil {
+			return cause
+		}
+		// Either this context is not canceled,
+		// or it is canceled and the cancellation happened in a
+		// custom context implementation rather than a *cancelCtx.
 	}
-	// There is no cancelCtxKey value, so we know that c is
-	// not a descendant of some Context created by WithCancelCause.
+	// There is no cancelCtxKey value with a cause, so we know that c is
+	// not a descendant of some canceled Context created by WithCancelCause.
 	// Therefore, there is no specific cause to return.
 	// If this is not one of the standard Context types,
 	// it might still have an error even though it won't have a cause.

src/context/context.go

@@ -798,6 +798,45 @@ func TestCause(t *testing.T) {
 			err:   nil,
 			cause: nil,
 		},
+		{
+			name: "parent of custom context not canceled",
+			ctx: func() Context {
+				ctx, _ := WithCancelCause(Background())
+				ctx, cancel2 := newCustomContext(ctx)
+				cancel2()
+				return ctx
+			},
+			err:   Canceled,
+			cause: Canceled,
+		},
+		{
+			name: "parent of custom context is canceled before",
+			ctx: func() Context {
+				ctx, cancel1 := WithCancelCause(Background())
+				ctx, cancel2 := newCustomContext(ctx)
+				cancel1(parentCause)
+				cancel2()
+				return ctx
+			},
+			err:   Canceled,
+			cause: parentCause,
+		},
+		{
+			name: "parent of custom context is canceled after",
+			ctx: func() Context {
+				ctx, cancel1 := WithCancelCause(Background())
+				ctx, cancel2 := newCustomContext(ctx)
+				cancel2()
+				cancel1(parentCause)
+				return ctx
+			},
+			err: Canceled,
+			// This isn't really right: the child context was canceled before
+			// the parent context, and shouldn't inherit the parent's cause.
+			// However, since the child is a custom context, Cause has no way
+			// to tell which was canceled first and returns the parent's cause.
+			cause: parentCause,
+		},
 	} {
 		test := test
 		t.Run(test.name, func(t *testing.T) {
@@ -1089,3 +1128,52 @@ func TestAfterFuncCalledAsynchronously(t *testing.T) {
 		t.Fatalf("AfterFunc not called after context is canceled")
 	}
 }
+
+// customContext is a custom Context implementation.
+type customContext struct {
+	parent Context
+
+	doneOnce sync.Once
+	donec    chan struct{}
+	err      error
+}
+
+func newCustomContext(parent Context) (Context, CancelFunc) {
+	c := &customContext{
+		parent: parent,
+		donec:  make(chan struct{}),
+	}
+	AfterFunc(parent, func() {
+		c.doneOnce.Do(func() {
+			c.err = parent.Err()
+			close(c.donec)
+		})
+	})
+	return c, func() {
+		c.doneOnce.Do(func() {
+			c.err = Canceled
+			close(c.donec)
+		})
+	}
+}
+
+func (c *customContext) Deadline() (time.Time, bool) {
+	return c.parent.Deadline()
+}
+
+func (c *customContext) Done() <-chan struct{} {
+	return c.donec
+}
+
+func (c *customContext) Err() error {
+	select {
+	case <-c.donec:
+		return c.err
+	default:
+		return nil
+	}
+}
+
+func (c *customContext) Value(key any) any {
+	return c.parent.Value(key)
+}

src/context/x_test.go

@@ -33,11 +33,11 @@ func SortImports(fset *token.FileSet, f *File) {
 		for j, s := range d.Specs {
 			if j > i && lineAt(fset, s.Pos()) > 1+lineAt(fset, d.Specs[j-1].End()) {
 				// j begins a new run. End this one.
-				specs = append(specs, sortSpecs(fset, f, d.Specs[i:j])...)
+				specs = append(specs, sortSpecs(fset, f, d, d.Specs[i:j])...)
 				i = j
 			}
 		}
-		specs = append(specs, sortSpecs(fset, f, d.Specs[i:])...)
+		specs = append(specs, sortSpecs(fset, f, d, d.Specs[i:])...)
 		d.Specs = specs
 
 		// Deduping can leave a blank line before the rparen; clean that up.
@@ -109,7 +109,7 @@ type cgPos struct {
 	cg   *CommentGroup
 }
 
-func sortSpecs(fset *token.FileSet, f *File, specs []Spec) []Spec {
+func sortSpecs(fset *token.FileSet, f *File, d *GenDecl, specs []Spec) []Spec {
 	// Can't short-circuit here even if specs are already sorted,
 	// since they might yet need deduplication.
 	// A lone import, however, may be safely ignored.
@@ -207,7 +207,11 @@ func sortSpecs(fset *token.FileSet, f *File, specs []Spec) []Spec {
 			deduped = append(deduped, s)
 		} else {
 			p := s.Pos()
-			fset.File(p).MergeLine(lineAt(fset, p))
+			// This function is exited early when len(specs) <= 1,
+			// so d.Rparen must be populated (d.Rparen.IsValid() == true).
+			if l := lineAt(fset, p); l != lineAt(fset, d.Rparen) {
+				fset.File(p).MergeLine(l)
+			}
 		}
 	}
 	specs = deduped

src/go/ast/import.go

@@ -79,3 +79,44 @@ import (
 		}
 	})
 }
+
+func TestIssue69183(t *testing.T) {
+	const src = `package A
+import (
+"a"//a
+"a")
+`
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "test.go", src, parser.ParseComments|parser.SkipObjectResolution)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ast.SortImports(fset, f) // should not panic
+}
+
+func TestSortImportsSameLastLine(t *testing.T) {
+	const src = `package A
+import (
+"a"//a
+"a")
+func a() {}
+`
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "test.go", src, parser.ParseComments|parser.SkipObjectResolution)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ast.SortImports(fset, f)
+	fd := f.Decls[1].(*ast.FuncDecl)
+	fdPos := fset.Position(fd.Pos())
+	// After SortImports, the Position of the func, should still be at Column == 1.
+	// This is related to the issue: https://go.dev/issue/69183, we were merging lines
+	// incorrectly, which caused the position to be Column = 6, Line = 4.
+	if fdPos.Column != 1 {
+		t.Errorf("invalid fdPos.Column = %v; want = 1", fdPos.Column)
+	}
+	if fdPos.Line != 5 {
+		t.Errorf("invalid fdPos.Line = %v; want = 5", fdPos.Line)
+	}
+}

src/go/ast/import_test.go

@@ -254,6 +254,9 @@ type Info struct {
 	//
 	// For an embedded field, Defs returns the field *Var it defines.
 	//
+	// In ill-typed code, such as a duplicate declaration of the
+	// same name, Defs may lack an entry for a declaring identifier.
+	//
 	// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
 	Defs map[*ast.Ident]Object
 

src/go/types/api.go

@@ -17,7 +17,7 @@ import (
 func runtime_mapaccess1_fast32(typ *abi.SwissMapType, m *Map, key uint32) unsafe.Pointer {
 	if race.Enabled && m != nil {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapaccess1)
+		pc := abi.FuncPCABIInternal(runtime_mapaccess1_fast32)
 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
 	}
 
@@ -86,7 +86,7 @@ func runtime_mapaccess1_fast32(typ *abi.SwissMapType, m *Map, key uint32) unsafe
 func runtime_mapaccess2_fast32(typ *abi.SwissMapType, m *Map, key uint32) (unsafe.Pointer, bool) {
 	if race.Enabled && m != nil {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapaccess1)
+		pc := abi.FuncPCABIInternal(runtime_mapaccess2_fast32)
 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
 	}
 
@@ -198,7 +198,7 @@ func runtime_mapassign_fast32(typ *abi.SwissMapType, m *Map, key uint32) unsafe.
 	}
 	if race.Enabled {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapassign)
+		pc := abi.FuncPCABIInternal(runtime_mapassign_fast32)
 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
 	}
 	if m.writing != 0 {
@@ -332,7 +332,7 @@ func runtime_mapassign_fast32ptr(typ *abi.SwissMapType, m *Map, key unsafe.Point
 	}
 	if race.Enabled {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapassign)
+		pc := abi.FuncPCABIInternal(runtime_mapassign_fast32ptr)
 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
 	}
 	if m.writing != 0 {
@@ -458,7 +458,7 @@ outer:
 func runtime_mapdelete_fast32(typ *abi.SwissMapType, m *Map, key uint32) {
 	if race.Enabled {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapassign)
+		pc := abi.FuncPCABIInternal(runtime_mapdelete_fast32)
 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
 	}
 

src/internal/runtime/maps/runtime_fast32_swiss.go

@@ -17,7 +17,7 @@ import (
 func runtime_mapaccess1_fast64(typ *abi.SwissMapType, m *Map, key uint64) unsafe.Pointer {
 	if race.Enabled && m != nil {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapaccess1)
+		pc := abi.FuncPCABIInternal(runtime_mapaccess1_fast64)
 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
 	}
 
@@ -86,7 +86,7 @@ func runtime_mapaccess1_fast64(typ *abi.SwissMapType, m *Map, key uint64) unsafe
 func runtime_mapaccess2_fast64(typ *abi.SwissMapType, m *Map, key uint64) (unsafe.Pointer, bool) {
 	if race.Enabled && m != nil {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapaccess1)
+		pc := abi.FuncPCABIInternal(runtime_mapaccess2_fast64)
 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
 	}
 
@@ -198,7 +198,7 @@ func runtime_mapassign_fast64(typ *abi.SwissMapType, m *Map, key uint64) unsafe.
 	}
 	if race.Enabled {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapassign)
+		pc := abi.FuncPCABIInternal(runtime_mapassign_fast64)
 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
 	}
 	if m.writing != 0 {
@@ -370,7 +370,7 @@ func runtime_mapassign_fast64ptr(typ *abi.SwissMapType, m *Map, key unsafe.Point
 	}
 	if race.Enabled {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapassign)
+		pc := abi.FuncPCABIInternal(runtime_mapassign_fast64ptr)
 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
 	}
 	if m.writing != 0 {
@@ -497,7 +497,7 @@ outer:
 func runtime_mapdelete_fast64(typ *abi.SwissMapType, m *Map, key uint64) {
 	if race.Enabled {
 		callerpc := sys.GetCallerPC()
-		pc := abi.FuncPCABIInternal(runtime_mapassign)
+		pc := abi.FuncPCABIInternal(runtime_mapdelete_fast64)
 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
 	}