// the new line is added after the block containing hint
// (or hint itself, if not in a block).
//
// If no hint is provided, addLine appends the line to the end of
// the last block with a matching first token,
// or to the end of the file if no such block exists.
func (x *FileSyntax) addLine(hint Expr, tokens ...string) *Line {
	if hint == nil {
		// If no hint given, add to the last statement of the given type.
	Loop:

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.

                "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)
	}

import org.gradle.api.artifacts.repositories.IvyArtifactRepository;
import org.gradle.api.artifacts.repositories.MavenArtifactRepository;
import org.gradle.declarative.dsl.model.annotations.Adding;
import org.gradle.internal.HasInternalProtocol;

import java.util.Map;

/**
 * A {@code RepositoryHandler} manages a set of repositories, allowing repositories to be defined and queried.
 */
@HasInternalProtocol

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

type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer

// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
type SharedInformerFactory interface {
	Start(stopCh <-chan struct{})
	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
}

        }

        @Override
        public PatternSet create() {
            return new InternalPatternSet(patternSpecFactory);
        }
    }

    // This is only required to avoid adding a new public constructor to the public `PatternSet` type.
    private static class InternalPatternSet extends PatternSet {
        public InternalPatternSet(PatternSpecFactory patternSpecFactory) {

import org.gradle.util.TestUtil
import spock.lang.Specification

class EclipseProjectTest extends Specification {

    def eclipseProject = TestUtil.newInstance(EclipseProject, Mock(XmlFileContentMerger))

    def "allows adding linked resources"() {
        when:
        eclipseProject.linkedResource(name: 'foo', type: 'folder', location: '/stuff/foo')
        eclipseProject.linkedResource(name: 'bar', type: 'uri', locationUri: 'file:///stuff/bar')

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