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

// Test that exporting composite literals with implicit
// types doesn't crash the typechecker when running over
// inlined function bodies containing such literals.

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

// Issue 5614: exported data for inlining may miss
// named types when used in implicit conversion to
// their underlying type.

// as under Go 1.16, but under 1.16 its (implicit) external test dependencies
// are higher.
module example.com/m

go 1.17

replace (
	example.net/lazy v0.1.0 => ./lazy
	example.net/requireincompatible v0.1.0 => ./requireincompatible
)

require example.net/lazy v0.1.0
-- implicit.go --
package implicit

import _ "example.net/lazy"
-- lazy/go.mod --

import javax.annotation.Nullable;

/**
 * Interface for services which support recording the "implicit inputs" they generate.
 * Whenever a rule calls a service, it may have side effects that needs to be taken
 * into account when checking if the rule is up-to-date. For example, if a rule performs
 * an HTTP query, we know that there is an implicit input to the rule which is the result
 * of the HTTP query (the external resource).
 *

//    "/job:localhost/replica:0/task:0/device:GPU:1"}
// Then executing an operation on CUSTOM:0 will execute it on GPU:0 and GPU:1.
//
// Implicit copies onto `device_name` are allowed, replicating the value once
// per device in `underlying_devices`. Implicit copies off of the device throw
// an error.
//
// All component tensors must have the same dtype. Currently they must also have

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

// Logical operation on named boolean type returns the same type,
// supporting an implicit conversion to an interface type.  This used
// to crash gccgo.

package p

type B bool

func (b B) M() {}

type I interface {
	M()
}

func F(a, b B) I {
	return a && b

    }

    /**
     * A method that helps performance of selection by quickly checking if a
     * metadata container only contains a single, shadowed (the implicit) capability.
     *
     * @return {@code true} if the variant only contains the implicit capability
     */
    private static boolean fastContainsImplicitCapability(ImmutableSet<ImmutableCapability> capabilities) {
        if (capabilities.isEmpty()) {

// Test case for go.dev/issue/34946: Better synchronization of
// parser for function declarations that start their
// body's opening { on a new line.

package p

// accept Allman/BSD-style declaration but complain
// (implicit semicolon between signature and body)
func _() int
{ /* ERROR "unexpected semicolon or newline before {" */
	{ return 0 }
}

func _() {}

func _(); { /* ERROR "unexpected semicolon or newline before {" */ }

	y := Load(Param("y"), GP64())

	carry := GP64()
	XORQ(carry, carry) // zero out carry

	for i := 0; i < bits/64; i++ {
		Comment("Iteration " + strconv.Itoa(i))
		hi, lo := RDX, RAX // implicit MULQ inputs and outputs
		MOVQ(x.Offset(i*8), lo)
		MULQ(y)
		ADDQ(z.Offset(i*8), lo)
		ADCQ(Imm(0), hi)
		ADDQ(carry, lo)
		ADCQ(Imm(0), hi)
		MOVQ(hi, carry)
		MOVQ(lo, z.Offset(i*8))
	}

// errorcheck -0 -l -d=wb

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

// Test write barrier for implicit assignments to result parameters
// that have escaped to the heap.

package issue13587

import "errors"

func escape(p *error)

func F() (err error) {
	escape(&err)