package p

type T struct {
	a, b, c int
	E
}

type E struct{}

func (T) b()  {} // ERROR "field and method named b|redeclares struct field name|field and method with the same name b"
func (*T) E() {} // ERROR "field and method named E|redeclares struct field name|field and method with the same name E"

func _() {
	var x T
	_ = x.a
	_ = x.b // no follow-on error here
	x.b()   // no follow-on error here
	_ = x.c

        n1.toString() == "a"
        n2.toString() == "b"

        n1.is(factory.named(Named, "a"))
        n2.is(factory.named(Named, "b"))
    }

    def "can unpack and recreate Named instance"() {
        expect:
        def n1 = factory.named(Named, "a")
        n1 instanceof Managed
        n1.publicType() == Named
        n1.isImmutable()
        def state = n1.unpackState()
        state == "a"

                    name: 'api',
                    usage: objects.named(Usage, 'api'),
                    dependencies: configurations.implementation.allDependencies,
                    attributes: testAttributes))

            comp.usages.add(new TestUsage(
                    name: 'impl',
                    usage: objects.named(Usage, 'api'),

                    }
                    attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, "foo"))
                }
                dependencyScope("deps")
                resolvable("res") {
                    extendsFrom(deps)
                    attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, "foo"))
                }
            }

            dependencies {

namespace experimental {
namespace cc {

// SignatureDefFunctions are functions that correspond to either:
// "signatures" saved from a TF2 SavedModel APIs:
// https://github.com/tensorflow/tensorflow/blob/8ce0600f58ed84a8c84a7bbdb014d1f09e44f4c8/tensorflow/python/saved_model/save.py#L830-L854
// Or the "SignatureDefMap" saved from TF1 SavedModel APIs:

// named "foo", while "a/foo" is unavailable.
func ParseFiles(filenames ...string) (*Template, error) {
	return parseFiles(nil, readFileOS, filenames...)
}

// ParseFiles parses the named files and associates the resulting templates with
// t. If an error occurs, parsing stops and the returned template is nil;
// otherwise it is t. There must be at least one file.

			log.Fatal(err)
		}
		if _, err := f.Write(crash); err != nil {
			log.Fatal(err)
		}
		if err := f.Close(); err != nil {
			log.Fatal(err)
		}
		log.Fatalf("saved crash report at %s", f.Name())
	}

	// This is the application process.
	// Fork+exec the same executable in monitor mode.
	exe, err := os.Executable()
	if err != nil {
		log.Fatal(err)
	}
	cmd := exec.Command(exe, "-test.run=ExampleSetCrashOutput_monitor")

// RUN: tf-opt %s --tf-saved-model-add-functions-for-exported-names --split-input-file | FileCheck %s

// CHECK-LABEL @export_three
module @export_three attributes {tf_saved_model.semantics} {
  // CHECK: func @a
  // CHECK-SAME: i32
  // CHECK-SAME: f32
  // CHECK-SAME: tensor<i32>
  // CHECK: [[tuple:%.*]]:2 = call @f
  // CHECK: return [[tuple]]#0, [[tuple]]#1
  // CHECK-SAME: tensor<i8>
  // CHECK-SAME: tensor<i16>
  // CHECK: func @b

 They must not be standard packages (like fmt), meta-patterns (std, cmd,
 all), or relative or absolute file paths.

 - All arguments must have the same version suffix. Different queries are not
 allowed, even if they refer to the same version.

 - All arguments must refer to packages in the same module at the same version.

 - Package path arguments must refer to main packages. Pattern arguments
 will only match main packages.

// Receiver parameter types are ignored. Named (defined) types are only equal if they
// are pointer-equal - i.e. there must be a unique types.Type for each specific named
// type. Also, a type containing a shape type is considered identical to another type
// (shape or not) if their underlying types are the same, or they are both pointers.
func Identical(t1, t2 *Type) bool {
	return identical(t1, t2, 0, nil)