#include "tensorflow/core/platform/test.h"

namespace tf {
namespace libtf {
namespace impl {

TEST(StringTest, TestBasicInterning) {
  String s1("foo");
  String s2("foo");
  EXPECT_EQ(&s1.str(), &s2.str());
}

}  // namespace impl
}  // namespace libtf

	A3 [10]A4
	A4 A2

	A5 [10]A6
	A6 *A5

	// slices
	L0 []L0

	// structs
	S0 /* ERROR "invalid recursive type: S0 refers to itself" */ struct{ _ S0 }
	S1 /* ERROR "invalid recursive type: S1 refers to itself" */ struct{ S1 }
	S2 struct{ _ *S2 }
	S3 struct{ *S3 }

	S4 /* ERROR "invalid recursive type" */ struct{ S5 }
	S5 struct{ S6 }
	S6 S4

	// pointers
	P0 *P0

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

package p

func f[_ comparable]() {}

type S1 struct{ x int }
type S2 struct{ x any }
type S3 struct{ x [10]interface{ m() } }

func _[P1 comparable, P2 S2]() {
	_ = f[S1]
	_ = f[S2]
	_ = f[S3]

	type L1 struct { x P1 }
	type L2 struct { x P2 }
	_ = f[L1]
	_ = f[L2 /* ERROR "L2 does not satisfy comparable" */ ]
}

// compile

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

type (
	s  = struct{ f func(s1) }
	s1 = struct{ i I }
)

type I interface {
	S() *s

// A simplified version of the code in the original report.
type S[T any] struct{}
var V = S[any]{}
func (fs *S[T]) M(V.M /* ERROR "V.M is not a type" */) {}

// Other minimal reproducers.
type S1[T any] V1.M /* ERROR "V1.M is not a type" */
type V1 = S1[any]

type S2[T any] struct{}
type V2 = S2[any]
func (fs *S2[T]) M(x V2.M /* ERROR "V2.M is not a type" */ ) {}

// The following still panics, as the selector is reached from check.expr

		~uint|~uint8|~uint16|~uint32|~uint64|~uintptr|
		~float32|~float64|
		~complex64|~complex128
}

func DotProduct[T Numeric](s1, s2 []T) T {
	if len(s1) != len(s2) {
		panic("DotProduct: slices of unequal length")
	}
	var r T
	for i := range s1 {
		r += s1[i] * s2[i]
	}
	return r
}

// NumericAbs matches numeric types with an Abs method.
type NumericAbs[T any] interface {
	Numeric

}

func _[P map[int]int]() {
	type A = P
	var m A
	clear(m) // don't report an error for m
}

type S1 struct {
	x int "S1.x"
}

type S2 struct {
	x int "S2.x"
}

func _[P1 S1, P2 S2]() {
	type A = P1
	var p A
	_ = P2(p) // conversion must be valid
}

func _[P1 S1, P2 S2]() {
	var p P1
	type A = P2
	_ = A(p) // conversion must be valid
}

func _[P int | string]() {

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

package main

import (
	"./p0"
	"./p1"
)

var (
	_ p0.T0 = p0.S0{}
	_ p0.T0 = p1.S1{}
	_ p0.T0 = p1.NewT0()
	_ p0.T0 = p1.NewT1() // same as p1.S1{}
)

	}
	if ps.val() != 2 {
		println("ps.val:", ps.val())
		panic("fail")
	}
	if (*S1).val(ps) != 2 {
		println("(*S1).val(ps):", (*S1).val(ps))
		panic("fail")
	}
	if i.val() != 3 {
		println("i.val:", i.val())
		panic("fail")
	}
	if I.val(i) != 3 {
		println("I.val(i):", I.val(i))
		panic("fail")
	}
	if (*I).val(&i) != 3 {
		println("(*I).val(&i):", (*I).val(&i))
		panic("fail")
	}
	if pi.val() != 4 {

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

package main

import (
	"fmt"
)

func f(s1, s2 string) { fmt.Printf("%s %s", s1, s2) }

func main() {
	f([2]string{"a", "b"}...) // ERROR "invalid use of .*[.][.][.]|cannot use [.][.][.] in call to non-variadic"