# and the dependency on c is eagerly loaded.

cp go.mod go.mod.orig
go mod tidy
cmp go.mod.orig go.mod

go list -m all
stdout '^a v0.1.0 '
stdout '^b v0.1.0 '
stdout '^c v0.1.0 '

# After adding a new import of b/y,
# the import of c from b/y should resolve to the version required by b.

cp m.go m.go.orig
cp m.go.new m.go
go mod tidy
cmp go.mod.new go.mod

go list -m all
stdout '^a v0.1.0 '

}

//go:noinline
func (s *SI) test(name string) (*int, error) {
	n := new(int)
	*n = 99
	if err := addUpdate(n, s.M[name].Enabled, "enabled"); err != nil { // this was miscompiled
		return nil, fmt.Errorf(" error adding update for enable flag %t : %s",
			s.M[name].Enabled, err)
	}
	return n, nil
}

//go:noinline
func addUpdate(n *int, in interface{}, s ...string) error {
	if *n != 99 {

source is a memory reference, then it is a load.

MOV{B,H,W,D} variations identify the size as byte, halfword, word, doubleword.

Adding 'Z' to the opcode for a load indicates zero extend; if omitted it is sign extend.
Adding 'U' to a load or store indicates an update of the base register with the offset.
Adding 'BR' to an opcode indicates byte-reversed load or store, or the order opposite

1. *Specify a file on the command line* with the option `-I` or `--init-script` followed by the path to the script.
+
The command line option can appear more than once, each time adding another init script. The build will fail if any files specified on the command line do not exist.
2. *Put a file called `init.gradle(.kts)`* in the `__$<<directory_layout.adoc#dir:gradle_user_home,GRADLE_USER_HOME>>__/` directory.

		return err
	}

	r := &Retract{
		VersionInterval: vi,
	}
	if vi.Low == vi.High {
		r.Syntax = f.Syntax.addLine(nil, "retract", AutoQuote(vi.Low))
	} else {
		r.Syntax = f.Syntax.addLine(nil, "retract", "[", AutoQuote(vi.Low), ",", AutoQuote(vi.High), "]")
	}
	if rationale != "" {
		for _, line := range strings.Split(rationale, "\n") {

        file('gradle/javadocs/jetbrains-annotations/package-list') << ''

        expect:
        succeeds("javadoc")
    }

    @Issue("https://github.com/gradle/gradle/issues/4841")
    def "adding custom javadoc options makes task out-of-date"() {
        given: "a javadoc task without custom options"
        buildFile << """
            task javadoc(type: Javadoc) {

                "reference a platform (" + DOCUMENTATION_REGISTRY.getDocumentationRecommendationFor("platforms", "platforms") + "). " +
                "Disable this check by adding 'dependencies-without-versions' to the suppressed validations of the " + taskPath + " task.");
        }
    }

    public void validateAttributes(String variant, String group, String name, AttributeContainer attributes) {

	if runtime.GOOS == "windows" {
		t.Skip("Skipping test that fails on Windows")
	}

	dsw := NewDesiredStateOfWorld()
	socketPath := "/var/lib/kubelet/device-plugins/test-plugin.sock"
	// Adding the plugin for the first time
	err := dsw.AddOrUpdatePlugin(socketPath)
	if err != nil {
		t.Fatalf("AddOrUpdatePlugin failed. Expected: <no error> Actual: <%v>", err)
	}

Each dialect consists of a set of defined operations which have invariants
placed on them, like: “This is a binary operator, and the inputs and outputs
have the same types.”

## Adding to MLIR

MLIR has no fixed/built-in list of globally known operations (no “intrinsics”).
Dialects can define entirely custom types, which is how MLIR can model things

     *
     * #### Examples
     *
     *  - The name of the module is being changed.
     *  - The module's content roots are being changed, such as adding another source folder to a source module.
     *  - If module A depends on module B and module B is being removed, in addition to the removal event for module B, module A also
     *    receives an update event.
     */