@TargetGradleVersion("=3.0")
    def "can use plugin built with Gradle 3.2.1 with old version"() {
        expect:
        buildPluginWith("3.2.1")
        assertWorks()
    }

    private void assertWorks() {
        // So we don't try to use a classpath distribution
        toolingApi.requireDaemons()

        withConnector {
            // TestKit builds that use debug will set this to true

type Value /* ERROR "Value already declared through dot-import of package reflect" */ struct{}

var _ = fmt.Println // use "fmt"

func _() {
	f1.Println() // use "fmt"
}

func _() {
	_ = func() {
		f2.Println() // use "fmt"
	}

 */

package org.gradle.internal.deprecation;

import java.util.Locale;

public enum ConfigurationDeprecationType {
    DEPENDENCY_DECLARATION("use", true),
    CONSUMPTION("use attributes to consume", false),
    RESOLUTION("resolve", true),
    ARTIFACT_DECLARATION("use", true);

    public final String usage;
    public final boolean inUserCode;

    ConfigurationDeprecationType(String usage, boolean inUserCode) {

not use beta APIs, unless you [repackage] them. **If your
code is a library, we strongly recommend using the [Guava Beta Checker] to
ensure that you do not use any `@Beta` APIs!**

[Guava Beta Checker]: https://github.com/google/guava-beta-checker

<!-- References -->

    /**
     * The original symbol for this signature.
     */
    public abstract val symbol: S

    /**
     * The use-site-substituted return type.
     */
    public abstract val returnType: KaType

    /**
     * The use-site-substituted extension receiver type.
     */
    public abstract val receiverType: KaType?

    /**
     * A [CallableId] of a substituted symbol
     */

stderr 'panic: panic called with nil argument'

-- go.work.21 --
go 1.21
use .
use ./q

-- go.work.20 --
go 1.20
use .
use ./q

-- go.mod.21 --
go 1.21
module m
require q v1.0.0
replace q => ./q
require rsc.io/panicnil v1.0.0

-- go.mod.20 --
go 1.20
module m
require q v1.0.0
replace q => ./q
require rsc.io/panicnil v1.0.0

-- p.go --

// NewLegacyKeccak256 creates a new Keccak-256 hash.
//
// Only use this function if you require compatibility with an existing cryptosystem
// that uses non-standard padding. All other users should use New256 instead.
func NewLegacyKeccak256() hash.Hash { return &state{rate: 136, outputLen: 32, dsbyte: 0x01} }

// NewLegacyKeccak512 creates a new Keccak-512 hash.
//
// Only use this function if you require compatibility with an existing cryptosystem

# Templates

You can use any template engine you want with **FastAPI**.

A common choice is Jinja2, the same one used by Flask and other tools.

There are utilities to configure it easily that you can use directly in your **FastAPI** application (provided by Starlette).

## Install dependencies

Install `jinja2`:

<div class="termy">

```console
$ pip install jinja2

---> 100%
```

</div>

// Copyright 2022 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 net

import (
	"os"
	"sync/atomic"
	"time"
	_ "unsafe"
)

// defaultNS is the default name servers to use in the absence of DNS configuration.
//
// defaultNS should be an internal detail,
// but widely used packages access it using linkname.

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

// This file contains CRC32 algorithms that are not specific to any architecture
// and don't use hardware acceleration.
//
// The simple (and slow) CRC32 implementation only uses a 256*4 bytes table.
//
// The slicing-by-8 algorithm is a faster implementation that uses a bigger