hashed64Def
	hashedDef
	nonPkgDef
	nonPkgRef
)

// objidx
const (
	nilObj = iota
	extObj
	goObjStart
)

// extSymPayload holds the payload (data + relocations) for linker-synthesized
// external symbols (note that symbol value is stored in a separate slice).
type extSymPayload struct {
	name   string // TODO: would this be better as offset into str table?
	size   int64
	ver    int

                platformWithUsageAttribute(runtimeConfiguration, attributes, attributesFactory, Usage.JAVA_RUNTIME, true, shadowedEnforcedPlatformCapability));
        }
        return null;
    }

    /**
     * Synthesizes a "sources" variant since maven metadata cannot represent it
     *
     * @return synthetic metadata for the sources-classifier jar
     */

                startEvent = new TestStartEvent(iTestResult.getStartMillis(), parentId);
            }
        }
        if (startEvent != null) {
            // Synthesize a start event
            resultProcessor.started(new DefaultTestMethodDescriptor(testId, iTestResult.getTestClass().getName(), iTestResult.getName()), startEvent);
        }

// run

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

// Some derived-type expressions require the compiler to synthesize
// function literals to plumb sub-dictionaries appropriately.
// However, when these expressions are inlined, we were constructing
// the function literal bodies with the inline-adjusted positions

	volumeManager volumemanager.VolumeManager

	// statusManager receives updated pod status updates from the podWorker and updates the API
	// status of those pods to match. The statusManager is authoritative for the synthesized
	// status of the pod from the kubelet's perspective (other components own the individual
	// elements of status) and should be consulted by components in preference to assembling

        when:
        processor.testClassFinished(null)

        then:
        1 * target.completed(1, {it.endTime == 1300})
        0 * target._
    }

    def "synthesises a broken test when test class fails and no tests have been started"() {
        def failure = TestFailure.fromTestFrameworkFailure(new RuntimeException())

        given:
        idGenerator.generateId() >>> [1, 2]

stdout '^fmt$'
! stdout foo

go list std
stdout -count=1 '^.+$'
stdout '^fmt$'

! go list .
stderr '^GOROOT/src is not an importable package$'

# In GOPATH mode, 'go list ./...' should synthesize a legacy GOPATH-mode path —
# not a standard-library or empty path — for the errant package.
env GO111MODULE=off
go list ./...
stdout -count=2 '^.+$' # Both 'fmt' and GOROOT/src should be listed.
stdout '^fmt$'

	TTL      uint32      `json:"ttl,omitempty"`

	// Holds info about when the entry was created first.
	CreationDate time.Time `json:"creationDate"`

	// When a SRV record with a "Host: IP-address" is added, we synthesize
	// a srv.Target domain name.  Normally we convert the full Key where
	// the record lives to a DNS name and use this as the srv.Target. When
	// TargetStrip > 0 we strip the left most TargetStrip labels from the
	// DNS name.

			for _, loc := range s.Location {
				for _, line := range loc.Line {
					fns = append(fns, fmt.Sprintf("%s:%d", line.Function.Name, line.Line))
					leaf = line.Function.Name
				}
			}
			// runtime.sigprof synthesizes call stacks when "normal traceback is
			// impossible or has failed", using particular placeholder functions
			// to represent common failure cases. Look for those functions in

		insert = p.goBuild[0]
	} else if len(p.plusBuild) > 0 && p.plusBuild[0] < insert {
		insert = p.plusBuild[0]
	}

	var x constraint.Expr
	switch len(p.goBuild) {
	case 0:
		// Synthesize //go:build expression from // +build lines.
		for _, pos := range p.plusBuild {
			y, err := constraint.Parse(p.commentTextAt(pos))
			if err != nil {
				x = nil
				break
			}
			if x == nil {
				x = y