# We can promote the implicit requirement by getting the importing package.
# NOTE: the hint recommends getting the imported package (tested below) since
# it's more obvious and doesn't require -d. However, that adds an '// indirect'
# comment on the requirement.
go get m/use-indirect
cmp go.mod go.mod.use
cp go.mod.orig go.mod

# We can also promote implicit requirements using 'go get' on them, or their

func (*Buffer) Read() {}

type Reader interface {
	Read()
}

func f() *Buffer { return nil }

func g() Reader {
	// implicit interface conversion in assignment during return
	return f()
}

func h() (b *Buffer, ok bool) { return }

func i() (r Reader, ok bool) {
	// implicit interface conversion in multi-assignment during return
	return h()
}

_f4loop:
	CMP	TMP, TS
	BHS	_f1tail

	MOVW.P	4(FROM), TMP1	/* implicit write back */
	MOVW.P	TMP1, 4(TS)	/* implicit write back */
	B	_f4loop

_f1tail:
	CMP	TS, TE
	BEQ	_return

	MOVBU.P	1(FROM), TMP	/* implicit write back */
	MOVBU.P	TMP, 1(TS)	/* implicit write back */
	B	_f1tail

_return:
	MOVW	to+0(FP), R0
	RET

_bunaligned:

    /**
     * <p>Adds an artifact to this dependency.</p>
     *
     * <p>If no artifact is added to a dependency, an implicit default artifact is used. This default artifact has the
     * same name as the module and its type and extension is {@code jar}. If at least one artifact is explicitly added,
     * the implicit default artifact won't be used any longer.</p>
     *
     * @return this
     */

            Component(providerAccessors, "Accessors", "Collects Project Schema, generates Accessors source and bytecode")
            Component(providerImports, "Implicit Imports", "Includes Gradle's default imports")


            Rel_Neighbor(providerFactory, providerExecution, "Delegates to")
            Rel(providerExecution, providerScriptTemplates, "Uses", "script API for compilation")

    public AbstractHeaderExportingSourceSet() {
        this.exportedHeaders = objectFactory.sourceDirectorySet("exported", "exported headers");
        this.implicitHeaders = objectFactory.sourceDirectorySet("implicit", "implicit headers");
    }

    @Override
    public SourceDirectorySet getExportedHeaders() {
        return exportedHeaders;
    }

    @Override
    public SourceDirectorySet getImplicitHeaders() {

#
# (The fix in golang.org/issue/29004 didn't completely fix the underlying issue:
# cmd/go/internal/load adds a bunch of implicit dependencies
# based on various heuristics, and, due to a bug described in
# https://golang.org/issue/31544#issuecomment-490607180,
# those implicit dependencies are not added early enough during
# loading to properly affect the import graph.)
go build runtime/cgo

go build -x -o main main.go

	B	_f32loop

_4tail:
	SUB	$3, TOE, TMP	/* do remaining words if possible */
_4loop:
	CMP	TMP, TO
	BHS	_1tail

	MOVW.P	R0, 4(TO)		/* implicit write back */
	B	_4loop

_1tail:
	CMP	TO, TOE
	BEQ	_return

	MOVBU.P	R0, 1(TO)		/* implicit write back */
	B	_1tail

_return:

     * - Resolved subject and input paths relative to the target element.
     * - Resolves subject type references relative to the target element.
     * - Adds implicit inputs.
     *
     * The returned action invokes the provided action with a {@link ModelRuleInvoker} contextualized with implicit inputs.
     */
    ModelAction contextualize(MethodRuleAction action);

    ModelPath getScope();

 * where the single parameter is passed as the implicit receiver of the
 * invocation ({@code this} in Kotlin, {@code delegate} in Groovy) as if
 * the lambda expression was an extension method of the parameter type.
 *
 * <pre>
 *     // copySpec(Action&lt;CopySpec&gt;)
 *     copySpec {
 *         from("./sources") // the given CopySpec is the implicit receiver
 *     }
 * </pre>
 *
 * @since 3.5
 */