//
// lostcancel: check cancel func returned by context.WithCancel is called
//
// The cancellation function returned by context.WithCancel, WithTimeout,
// and WithDeadline must be called or the new context will remain live
// until its parent context is cancelled.
// (The background context is never cancelled.)

                println "$person.name lives in $person.address.city"
            }
        }
    }
    barry(Person) {
        address.city = 'unknown'
    }
    barry {
        address {
            city = 'Melbourne'
        }
    }
}
'''

        when:
        run "show"

        then:
        output.contains("barry lives in Melbourne")
    }

// run

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

// Issue 7944:
// Liveness bitmaps said b was live at call to g,
// but no one told the register optimizer.

package main

import "runtime"

func f(b []byte) {
	for len(b) > 0 {
		n := len(b)
		n = f1(n)
		f2(b[n:])
		b = b[n:]
	}
	g()
}

    )
}

dependencies {
    api(projects.serviceProvider)
    api(project(":core-api"))
    api(project(":core"))
    api(project(":ide")) {
        because("To pick up various builders (which should live somewhere else)")
        api(project(":tooling-api"))
    }

    implementation(projects.baseServices)
    implementation(project(":file-collections"))
    implementation(project(":language-native"))

// Issue 12411. Loss of AX during %.

package main

func main() {
	x := f(4)
	if x != 0 {
		println("BUG: x=", x)
	}
}

//go:noinline
func f(x int) int {
	// AX was live on entry to one of the % code generations,
	// and the % code generation smashed it.
	return ((2 * x) % 3) % (2 % ((x << 2) ^ (x % 3)))

	// mark all live revisions
	live := map[string]bool{}
	if current != nil {
		live[current.Name] = true
	}
	if update != nil {
		live[update.Name] = true
	}
	for i := range pods {
		live[getPodRevision(pods[i])] = true
	}
	// collect live revisions and historic revisions
	for i := range revisions {
		if !live[revisions[i].Name] {

  Set<N> nodes();

  /** Returns all edges in this network, in the order specified by {@link #edgeOrder()}. */
  Set<E> edges();

  /**
   * Returns a live view of this network as a {@link Graph}. The resulting {@link Graph} will have
   * an edge connecting node A to node B if this {@link Network} has an edge connecting A to B.
   *

			},
		},
	}

	for _, tc := range testCases {
		f.Reset()
		live := f.Live()
		accessor, err := meta.Accessor(live)
		if err != nil {
			t.Fatalf("%v: couldn't get accessor: %v", tc.name, err)
		}
		accessor.SetManagedFields(tc.input)
		if err := f.Update(live, "no-op-update"); err != nil {
			t.Fatalf("%v: failed to do no-op update to object: %v", tc.name, err)
		}

	liveAccessor, err := meta.Accessor(liveObj)
	if err != nil {
		return nil, err
	}

	// We take the managedFields of the live object in case the request tries to
	// manually set managedFields via a subresource.
	if ignoreManagedFieldsFromRequestObject {
		return emptyManagedFieldsOnErr(DecodeManagedFields(liveAccessor.GetManagedFields()))
	}

// license that can be found in the LICENSE file.

package main

import "runtime"

type T [10]int

var m map[*T]int

//go:noinline
func F() {
	m = map[*T]int{
		K(): V(), // the key temp should be live across call to V
	}
}

//go:noinline
func V() int { runtime.GC(); runtime.GC(); runtime.GC(); return 123 }

//go:noinline
func K() *T {
	p := new(T)
	runtime.SetFinalizer(p, func(*T) { println("FAIL") })