// tag::main-block[]
plugins {
    id 'java-gradle-plugin'
}

gradlePlugin {
    plugins {
        myPlugins {
            id = 'my-plugin'
            implementationClass = 'my.MyPlugin'
        }
    }
}

	F_SETLKW                      = 0x7
	F_SETLKW64                    = 0xd
	F_SETOWN                      = 0x9
	F_TEST                        = 0x3
	F_TLOCK                       = 0x2
	F_TSTLK                       = 0xf
	F_ULOCK                       = 0x0
	F_UNLCK                       = 0x3
	F_WRLCK                       = 0x2
	HUPCL                         = 0x400
	IBSHIFT                       = 0x10

  // and return-as-yield CF don't belong to us.
  for (Block& block : region->getBlocks()) {
    for (Operation& op : block.getOperations()) {
      if (op.hasTrait<OpTrait::ReturnLike>()) result = &op;
    }
  }
  return result;
}

void EraseReturnOperands(Region* region, llvm::BitVector& erase) {
  for (Block& block : region->getBlocks()) {
    for (Operation& op : block.getOperations()) {

	wk.mu.Lock()

	ft := wk.watchedFiles[path]
	if ft == nil {
		wk.mu.Unlock()
		return fmt.Errorf("path %s not found", path)
	}

	delete(wk.watchedFiles, path)
	wk.mu.Unlock()

	wk.retireTrackerCh <- ft
	return nil
}

func (wk *worker) eventChannel(path string) chan fsnotify.Event {
	wk.mu.RLock()
	defer wk.mu.RUnlock()

	if ft := wk.watchedFiles[path]; ft != nil {

	}

	// Set of blocks we're moving, by ID.
	move := map[ID]struct{}{}

	// Map from block ID to the moving blocks that should
	// come right after it.
	after := map[ID][]*Block{}

	// Check each loop header and decide if we want to move it.
	for _, loop := range loopnest.loops {
		b := loop.header
		var p *Block // b's in-loop predecessor
		for _, e := range b.Preds {
			if e.b.Kind != BlockPlain {
				continue

// be picked up correctly.

// testInterface can be asserted to check that a type originates
// from this test group.
type testInterface interface {
	InAESPackage() bool
}

// testBlock implements the cipher.Block interface and any *Able
// interfaces that need to be tested.
type testBlock struct{}

func (*testBlock) BlockSize() int      { return 0 }
func (*testBlock) Encrypt(a, b []byte) {}
func (*testBlock) Decrypt(a, b []byte) {}

      FUN name:run visibility:public modality:FINAL <> () returnType:kotlin.Unit
        EXPRESSION_BODY
          BLOCK type=kotlin.Unit origin=null
            CALL 'public final fun call (block: kotlin.Function1<kotlin.Int, kotlin.Int>): kotlin.Unit [inline] declared in <root>' type=kotlin.Unit origin=null
              block: FUN_EXPR type=kotlin.Function1<kotlin.Int, kotlin.Int> origin=LAMBDA

 *   <li>If a {@code Throwable} is thrown in the try block, no exceptions that occur when attempting
 *       to close resources will be thrown from the finally block. The throwable from the try block
 *       will be thrown.
 *   <li>If no exceptions or errors were thrown in the try block, the <i>first</i> exception thrown
 *       by an attempt to close a resource will be thrown.

// MODULE: context

// FILE: context.kt
fun test() {
    <caret_context>val x = 0
}

inline fun call(block: (Int) -> Int) {
    System.out.println(block(5))
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION

plugins {
    id 'java-gradle-plugin'
}
// end::use-java-gradle-plugin-plugin[]

// tag::gradle-plugin-block[]
gradlePlugin {
    plugins {
        simplePlugin {
            id = 'org.gradle.sample.simple-plugin'
            implementationClass = 'org.gradle.sample.SimplePlugin'
        }
    }
}