type T2[P any] struct {
        f P
        g int // int should still be in scope chain
}

type List[P any] []P

// Pending clarification of #46477 we disallow aliases
// of generic types.
type A2 = List // ERROR "cannot use generic type"
var _ A2[int]
var _ A2

type A3 = List[int]
var _ A3

// Parameterized type instantiations

var x int

	// connection to the server for a subsequent "keep-alive" request.
	if respBody != nil {
		// Drain any remaining Body and then close the connection.
		// Without this closing connection would disallow re-using
		// the same connection for future uses.
		//  - http://stackoverflow.com/a/17961593/4465767
		defer respBody.Close()
		xioutil.DiscardReader(respBody)
	}

// errorcheck

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

// Verify allowed and disallowed conversions.
// Does not compile.

package main

// everything here is legal except the ERROR line

var c chan int
var d1 chan<- int = c
var d2 = (chan<- int)(c)

var e *[4]int
var f1 []int = e[0:]
var f2 = []int(e[0:])

# https://golang.org/issue/44776
# The '+' character should be disallowed in module paths, but allowed in package
# paths within valid modules.

# 'go list' accepts package paths with pluses.
cp go.mod.orig go.mod
go get example.net/cmd
go list example.net/cmd/x++

# 'go list -m' rejects module paths with pluses.
! go list -versions -m 'example.net/bad++'
stderr '^go: malformed module path "example.net/bad\+\+": invalid char ''\+''$'

        }
    }

    private final File javaHome;

    @Inject
    public SpecificInstallationToolchainSpec(File javaHome) {
        super();
        this.javaHome = javaHome;

        // disallow changing property values
        finalizeProperties();
    }

    public static SpecificInstallationToolchainSpec fromJavaHome(ObjectFactory objectFactory, File javaHome) {
        if (javaHome.exists()) {

	s := &S1{1}
	var i I1 = s
	i.Put(2)
	check(i.Get() == 1, "f3 i")
	check(s.i == 1, "f3 s")
}

type S2 struct { i int }
func (p *S2) Get() int { return p.i }
func (p *S2) Put(i int) { p.i = i }

// Disallowed by restriction of values going to pointer receivers
// func f4() {
//	 s := S2{1}
//	 var i I1 = s
//	 i.Put(2)
//	 check(i.Get() == 2, "f4 i")
//	 check(s.i == 1, "f4 s")
// }

func f5() {
	s := S2{1}

        when:
        container.create("a", container.type, method)
        then:
        noExceptionThrown()

        where:
        methods << getQueryMethods() + getMutatingMethods()
    }

    def "disallow mutating from register with type actions using #mutatingMethods.key"() {
        setupContainerDefaults()
        String methodUnderTest = mutatingMethods.key
        Closure method = bind(mutatingMethods.value)

        parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        parser.setFeature("http://xml.org/sax/features/namespaces", false)
        parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false)
        this.resultsNode = parser.parse(testResultsFile)

        resultsNode.testsuite.each { Node suiteNode ->
            def suite = new Suite(suiteNode)
            suites.put(suite.name, suite)

/**
 * A {@link org.gradle.api.file.ConfigurableFileCollection} that can be used as a task input property. Caches the matching set of files during task execution, and discards the result after task execution.
 *
 * TODO - disallow further changes to this collection once task has started
 * TODO - keep the file entries to snapshot later, to avoid a stat on each file during snapshot
 */

import org.gradle.internal.service.scopes.Scope;

@EventScope(Scope.BuildTree.class)
public interface ExecutionAccessListener {

    /**
     * Called when accessing the injected service of type that disallowed during execution phase (eg. Project).
     */
    void disallowedAtExecutionInjectedServiceAccessed(Class<?> injectedServiceType, String getterName, String consumer);