// of expression relevant to a particular fix.
//
// TODO(rsc,gri): Replace with go/typechecker.
// Doing that could be an interesting test case for go/typechecker:
// the constraints about working with partial information will
// likely exercise it in interesting ways. The ideal interface would
// be to pass typecheck a map from importpath to package API text

					v.Pos = v.Pos.WithIsStmt()
					l = 0
					break
				}
				if l < v.Pos.Line() {
					// The order of values in a block is not specified so OOO in a block is not interesting,
					// but they do all come before the end of the block, so this disqualifies attaching to end of b_next.
					outOfOrder = true
				}
			}

)

// dummyAddSym adds the named symbol to the loader as if it had been
// read from a Go object file. Note that it allocates a global
// index without creating an associated object reader, so one can't
// do anything interesting with this symbol (such as look at its
// data or relocations).
func addDummyObjSym(t *testing.T, ldr *Loader, or *oReader, name string) Sym {
	idx := uint32(len(ldr.objSyms))
	st := loadState{l: ldr}

provided

	mpz_t zero;

then cgo would rewrite a reference to C.zero by introducing

	var _C_zero *C.mpz_t

and then replacing all instances of C.zero with (*_C_zero).

Cgo's most interesting translation is for functions.  If xxx is a C
function, then cgo rewrites C.xxx into a new function _C_xxx that
calls the C xxx in a standard pthread.  The new function translates

You now have the project setup to build a ${language.raw} ${componentType.raw} which is modularized into multiple subprojects.

== Review the project files

The `settings.gradle(.kts)` file has two interesting lines:

====
include::sample[dir="kotlin",files="settings.gradle.kts[]"]
include::sample[dir="groovy",files="settings.gradle[]"]
====

		t.Errorf(`ReadBytes: %q, %v; want "", io.EOF`, b, err)
	}
}

// Issue 24481.
func TestFdRace(t *testing.T) {
	// This test starts 100 simultaneous goroutines, which could bury a more
	// interesting stack if this or some other test happens to panic. It is also
	// nearly instantaneous, so any latency benefit from running it in parallel
	// would be minimal.

	r, w, err := os.Pipe()
	if err != nil {

	 * of
	 * stars
	 */

	/*
	aligned in middle
	here
		not here
	*/

	/*
	blank line in middle:

	with no leading spaces on blank line.
*/
}


// Some interesting interspersed comments.
// See below for more common cases.
func _(/* this */x/* is *//* an */ int) {
}

func _(/* no params - extra blank before and after comment */) {}

     * even entire message) that simultaneously:
     *
     * - _shouldn't_ be null, so we don't annotate it with @Nullable
     *
     * - _can_ be null without causing a runtime failure (because we don't want the interesting
     *   details of precondition failure to be hidden by an exception we throw about an unexpectedly
     *   null _failure message_)
     *

      time_format %m%d %H:%M:%S.%N
      path /var/log/cluster-autoscaler.log
      pos_file /var/log/gcp-cluster-autoscaler.log.pos
      tag cluster-autoscaler
    </source>

    # Logs from systemd-journal for interesting services.
    # TODO(random-liu): Keep this for compatibility, remove this after
    # cri container runtime rolls out.
    <source>
      @type systemd
      filters [{ "_SYSTEMD_UNIT": "docker.service" }]

	out := []*packages.Package{}

	for _, pkg := range in {
		klog.V(2).Infof("considering pkg: %q", pkg.PkgPath)

		// Discard packages which represent the <pkg>.test result.  They don't seem
		// to hold any interesting source info.
		if strings.HasSuffix(pkg.PkgPath, ".test") {
			klog.V(3).Infof("ignoring testbin pkg: %q", pkg.PkgPath)
			continue
		}

		// Packages which end in "_test" have tests which use the special "_test"