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

// Embedding of stand-alone type parameters is not permitted.

package p

type (
        _[P any] interface{ *P | []P | chan P | map[string]P }
        _[P any] interface{ P /* ERROR "term cannot be a type parameter" */ }

        templateName: 'santaTrackerAndroidBuild',
        pathToChange: 'common/src/main/java/com/google/android/apps/santatracker/AudioPlayer.kt',
        taskToRunForChange: ':santa-tracker:assembleDebug'
    )

    static final NOW_IN_ANDROID = new IncrementalAndroidTestProject(
        templateName: 'nowInAndroidBuild',

}

// This example shows how to encode an interface value. The key
// distinction from regular types is to register the concrete type that
// implements the interface.
func Example_interface() {
	var network bytes.Buffer // Stand-in for the network.

	// We must register the concrete type for the encoder and decoder (which would
	// normally be on a separate machine from the encoder). On each end, this tells the

				}

				if !Identical(u, t.typ) {
					check.errorf(tlist[i], InvalidUnion, "invalid use of ~ (underlying type of %s is %s)", t.typ, u)
					continue
				}
			}

			// Stand-alone embedded interfaces are ok and are handled by the single-type case
			// in the beginning. Embedded interfaces with tilde are excluded above. If we reach

// -half        add values using two half-digit additions
// -opt         optimize memory allocation through reuse
// -short       only print the first 10 digits of very large fibonacci numbers

// Command fibo is a stand-alone test and benchmark to
// evaluate the performance of bignum arithmetic written
// entirely in Go.
package main

import (
	"flag"
	"fmt"
	"math/big" // only used for printing
	"os"
	"strconv"

	f := f1[int]
	f(int(0), new(int))
	f1(int(0), new(int))
}

func f2[A any, B interface{[]A}](A, B) {}
func _() {
	f := f2[byte]
	f(byte(0), []byte{})
	f2(byte(0), []byte{})
}

// Embedding stand-alone type parameters is not permitted for now. Disabled.
// func f3[A any, B interface{~C}, C interface{~*A}](A, B, C)
// func _() {
// 	f := f3[int]
// 	var x int
// 	f(x, &x, &x)
// 	f3(x, &x, &x)
// }

type (
	// Tilde is not permitted on defined types or interfaces.
	foo int
	bar any
	_ interface{foo}
	_ interface{~ /* ERROR "invalid use of ~" */ foo }
	_ interface{~ /* ERROR "invalid use of ~" */ bar }
)

// Stand-alone type parameters are not permitted as elements or terms in unions.
type (
	_[T interface{ *T } ] struct{}        // ok
	_[T interface{ int | *T } ] struct{}  // ok

    CodeGeneratingSignatureTreeVisitor(CodeBlock.Builder result) {
        this.result = result;
    }

    /**
     * @param paramIndex index of the parameter in the signatures, -1 stands for the receiver
     */
    void visit(SignatureTree current, int paramIndex) {
        CallInterceptionRequest leafInCurrent = current.getLeafOrNull();
        if (leafInCurrent != null) {

     *
     * @return the description, must not be empty.
     */
    String getDescription();

    /**
     * <p>Sets the description of the operation. This should be a full, stand-alone description of the operation.
     *
     * <p>This must be called before {@link #started()}.
     *
     * @param description The description.
     */
    ProgressLogger setDescription(String description);

        <plugins>
            <!--
            Both "org.apache" and "org.codehaus" are default providers of MOJO plugins
            which are especially dedicated to Maven projects.
            The MOJO stands for "Maven plain Old Java Object".
            Each mojo is an executable goal in Maven, and a plugin is a distribution of
            one or more related mojos.