var r io.Reader

	_, _ = r.(io.Writer)

	switch r.(type) {
	case io.Writer:
	}

	// Issue 2827.
	switch _ := r.(type) { // ERROR "invalid variable name _|no new variables?"
	}
}

func noninterface() {
	var i int
	switch i.(type) { // ERROR "cannot type switch on non-interface value|not an interface"
	case string:
	case int:
	}

	type S struct {
		name string
	}
	var s S

v3;
package nointerface
pkgpath nointerface
types 3 2 133 17
type 1 "I" <type -11>
 func /*nointerface*/ (p <esc:0x1> <type 2>) Get () <type -11>
 func (p <esc:0x1> <type 2>) Set (v <type -11>)

// Copyright 2018 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 nointerface

type I int

//go:nointerface
func (p *I) Get() int { return int(*p) }

	if !ok {
		return 0, fmt.Errorf("invalid max log size")
	}
	return maxSize, nil
}

type containerLogManager struct {
	runtimeService   internalapi.RuntimeService
	osInterface      kubecontainer.OSInterface
	policy           LogRotatePolicy
	clock            clock.Clock
	mutex            sync.Mutex
	queue            workqueue.TypedRateLimitingInterface[string]
	maxWorkers       int

var emptyInterface = Interface{complete: true, tset: &topTypeSet}

// NewInterface returns a new interface for the given methods and embedded types.
// NewInterface takes ownership of the provided methods and may modify their types
// by setting missing receivers.
//
// Deprecated: Use NewInterfaceType instead which allows arbitrary embedded types.
func NewInterface(methods []*Func, embeddeds []*Named) *Interface {

func NewFakeHostStatsProviderWithData(fakeStats map[string]*volume.Metrics, osInterface kubecontainer.OSInterface) HostStatsProvider {
	return &fakeHostStatsProvider{
		fakeStats:   fakeStats,
		osInterface: osInterface,
	}
}

func (f *fakeHostStatsProvider) getPodLogStats(podNamespace, podName string, podUID types.UID, rootFsInfo *cadvisorapiv2.FsInfo) (*statsapi.FsStats, error) {

}

// NewHostStatsProvider returns a new HostStatsProvider type struct.
func NewHostStatsProvider(osInterface kubecontainer.OSInterface, podEtcHostsPathFunc PodEtcHostsPathFunc, podLogsDirectory string) HostStatsProvider {
	return hostStatsProvider{
		osInterface:         osInterface,
		podEtcHostsPathFunc: podEtcHostsPathFunc,
		podLogsDirectory:    podLogsDirectory,
	}
}

	ctx := context.Background()
	recorder := &record.FakeRecorder{}
	logManager, err := logs.NewContainerLogManager(runtimeService, osInterface, "1", 2, 10, metav1.Duration{Duration: 10 * time.Second})
	if err != nil {

	})
	method := NewField(src.NoXPos, LocalPkg.Lookup("Error"), sig)
	return NewInterface([]*Field{method})
}

// makeComparableInterface makes the predefined "comparable" interface in the
// built-in package. It has a unique name, but no methods.
func makeComparableInterface() *Type {
	return NewInterface(nil)

  }];
}

//===----------------------------------------------------------------------===//
// TFL op interface for stateful operands.

def TFL_StatefulOp : OpInterface<"StatefulOpInterface"> {
  let description = [{
    Interface for ops that are stateful and need to identify stateful operands.

    Stateful operands correspond to TF's variables semantics. An op that has 1