// compiledir

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

// Issue 5910: parsing of unnamed struct types
// in inlined bodies was broken.

// compiledir

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

// Tests that unexported fields of unnamed types have different PkgPath values.

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

// Issue 8148.  A typedef of an unnamed struct didn't work when used
// with an exported Go function.  No runtime test; just make sure it
// compiles.

package cgotest

/*
typedef struct { int i; } T;
int get8148(void);
*/
import "C"

//export issue8148Callback

    }

    def "can register unnamed output files"() {
        when:
        outputs.files("a", "b")
        then:
        outputs.files.files == files('a', "b")
        outputs.fileProperties*.propertyName == ['$1$1', '$1$2']
        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a"), file("b")]
    }

    def "can register unnamed output files with property name"() {
        when:

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

// This directory contains a pair of packages that triggered
// a compiler crash in gollvm (problem in handling an inlinable
// method with unnamed parameter). See issue 31637 for details.

		updateTime time.Time
		expect     map[string]int
	}{
		about:   "this one",
		updates: map[string]int{"gopher": 10}, // ERROR "unknown field updates in struct literal of type|unknown field .*updates.* in .*unnamed struct.*"
	}

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

// Issue 6140: compiler incorrectly rejects method values
// whose receiver has an unnamed interface type.

package p

type T *interface {
	m() int
}

var x T

var _ = (*x).m

var y interface {
	m() int
}

var _ = y.m

type I interface {
	String() string
}

# If port is unnamed or port name doesn't follow <protocol>[-<suffix>], the analyzer will report warning.
apiVersion: v1
kind: Service
metadata:
  name: my-service1
  namespace: my-namespace1
spec:
  selector:
    app: my-service1
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
    - protocol: TCP
      port: 8081
      targetPort: 8081
---
apiVersion: v1
kind: Service
metadata:
  name: my-service2

// gccgo compiler crash building the equality and hash functions for a
// type when a return statement requires a conversion to interface
// type of a call of function defined in a different package that
// returns an unnamed type.

# library contains "foo1", "foo2", ..., "foo20", from which "foo1" and "foo11"
# were mapped to the same name "foo110" in the bug.
node {
  name: "unnamed"
  op: "foo1"
}
node {
  name: "unnamed1"
  op: "foo11"
}
library {
  function {
    signature {
      name: "foo1"
    }
  }
  function {
    signature {
      name: "foo2"
    }
  }
  function {