Laura Kassovic <******@****.***> 1701107622 -0800

kind: VirtualService
metadata:
  name: a
spec:
  hosts:
  - a
  http:
  # (This 'match' clause started as a work-around, because WaitUntilCallable() times out if
  # all destinations have a subset.  We are now using it for testing.)
  - match:
    - headers:
        end-user:
          exact: jason
    route:
    - destination:
        host: a
  # Fallthrough
  - route:
    - destination:

// Copyright 2021 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 a

type A[T any] struct {
}

func (a A[T]) F() {
	_ = a

func (mo MarshalOptions) MarshalNext(in interface{}) error {
	a := new(arshaler)
	a.marshal = func(MarshalOptions) error { return nil }
	return a.marshal(mo)
}

type arshaler struct {
	marshal func(MarshalOptions) error
}

type typedArshalers[Options any] struct {
	m M
}

func (a *typedArshalers[Options]) lookup(fnc func(Options) error) (func(Options) error, bool) {
	a.m.Load(nil)
	return fnc, false
}

type M struct {}

// 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 a

type A struct {
	New func() any
}

func NewA(i int) *A {
	return &A{
		New: func() any {
			_ = i
			return nil
		},
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package issue9510a

/*
static double csquare(double a, double b) {
	__complex__ double d;
	__real__ d = a;
	__imag__ d = b;
	return __real__ (d * d);
}
*/
import "C"

func F(a, b float64) float64 {
	return float64(C.csquare(C.double(a), C.double(b)))

// 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.

// Test that inlining a function literal that captures both a type
// switch case variable and another local variable works correctly.

package a

func F(p *int, x any) func() {
	switch x := x.(type) {
	case int:
		return func() {
			*p += x
		}
	}
	return nil

// 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 a

// Type I is the first basic test for the issue, which relates to a type that is recursive
// via a type constraint.  (In this test, I -> IConstraint -> MyStruct -> I.)
type JsonRaw []byte

type MyStruct struct {
	x *I[JsonRaw]
}

type IConstraint interface {

// Copyright 2021 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 a

type ATypeWithALoooooongName interface { // a long name, so the type descriptor symbol name is mangled
	M()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type S struct{}

func callClosure(closure func()) {
	closure()
}

func (s *S) M() {
	callClosure(func() {
		defer f(s.m) // prevent closures to be inlined.
	})
}

func (s *S) m() {}

//go:noinline