gp.schedlink.set(newg)
	})

	// Switch to the new goroutine.
	mcall(func(gp *g) {
		// Get newg.
		newg := gp.schedlink.ptr()
		gp.schedlink = 0

		// Park the calling goroutine.
		trace := traceAcquire()
		if trace.ok() {
			// Trace the event before the transition. It may take a
			// stack trace, but we won't own the stack after the
			// transition anymore.
			trace.GoPark(traceBlockDebugCall, 1)
		}

// Copyright 2020 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 p

func _() {
	NewS /* ERROR "cannot infer T" */ ().M()
}

type S struct {}

func NewS[T any]() *S { panic(0) }

package a

type Builder[T any] struct{}

func (r Builder[T]) New() T {
	var v T
	return v
}

func (r Builder[T]) New2() T {
	return r.New()
}

func BuildInt() int {
	return Builder[int]{}.New()

// Copyright 2022 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 b

import "./a"

	assert.Equal(t, w.Mesh(), m)

	doneCh := make(chan struct{}, 1)

	var newM *meshconfig.MeshConfig
	w.AddMeshHandler(func() {
		newM = w.Mesh()
		close(doneCh)
	})

	// Change the file to trigger the update.
	m.IngressClass = "foo"
	writeMessage(t, path, m)

	select {
	case <-doneCh:
		assert.Equal(t, newM, m)
		assert.Equal(t, w.Mesh(), newM)
		break
	case <-time.After(time.Second * 5):

Information about previous Istio vulnerabilities can be found on the
[Security Bulletins] page.

[Support Announcements]: https://istio.io/news/support/
[Istio Security Vulnerabilities]: https://istio.io/about/security-vulnerabilities/
[Security Bulletins]: https://istio.io/news/security/

		t.Fatalf("errors happened when update: %v", err)
	}

	var user4 User
	DB.Preload("Company").Preload("Manager").Find(&user4, "id = ?", user.ID)
	CheckUser(t, user4, user)

	user.Company.Name += "new2"
	user.Manager.Name += "new2"
	if err := DB.Session(&gorm.Session{FullSaveAssociations: true}).Select("`Company`").Save(&user).Error; err != nil {
		t.Fatalf("errors happened when update: %v", err)
	}

	var user5 User

git init

at 2018-04-25T11:00:57-04:00
git add go.mod new.go p1 p2
git commit -m 'initial commit'
git branch -m master

git log --oneline --decorate=short
cmp stdout .git-log

-- .git-log --
36cc50a (HEAD -> master) initial commit
-- go.mod --
module "vcs-test.golang.org/git/modlegacy1-new.git/v2"
-- new.go --
package new

import _ "vcs-test.golang.org/git/modlegacy1-new.git/v2/p2"
-- p1/p1.go --
package p1

// license that can be found in the LICENSE file.

package main

import (
	"sync"
	"time"
)

type B struct {
	pid int
	f   func() (uint64, error)
	wg  sync.WaitGroup
	v   uint64
}

func newB(pid int) *B {
	return &B{
		pid: pid,
	}
}

//go:noinline
func Sq(i int) uint64 {
	S++
	return uint64(i * i)
}

type RO func(*B)

var ROSL = []RO{
	Bad(),
}

func Bad() RO {

}

type R struct {
	cM *CM
}

type CM int

type A string

func (m *CM) NewA(ctx context.Context, cN string, nn *nAO, opts ...NAO) (*A, error) {
	for _, o := range opts {
		o(nn)
	}
	s := A("foo")
	return &s, nil
}

func (r *R) CA(ctx context.Context, cN string, nn *nAO) (*int, error) {
	cA, err := r.cM.NewA(ctx, cN, nn, WEA(), WEA())
	if err == nil {
		return nil, err
	}
	println(cA)
	x := int(42)