invalidOp  = "invalid operation: "
)

// The poser interface is used to extract the position of type-checker errors.
type poser interface {
	Pos() syntax.Pos
}

func (check *Checker) error(at poser, code Code, msg string) {
	err := check.newError(code)
	err.addf(at, "%s", msg)
	err.report()
}

func (check *Checker) errorf(at poser, code Code, format string, args ...any) {
	err := check.newError(code)

// webInterface holds the state needed for serving a browser based interface.
type webInterface struct {
	prof         *profile.Profile
	copier       profileCopier
	options      *plugin.Options
	help         map[string]string
	settingsFile string
}

func makeWebInterface(p *profile.Profile, copier profileCopier, opt *plugin.Options) (*webInterface, error) {
	settingsFile, err := settingsFileName()
	if err != nil {
		return nil, err
	}

# For reproducibility and easier cross-compilation,
# nothing in std is supposed to use cgo on macOS.
# Check that cgo does not appear as a dependency
# of cmd/go, which imports approximately everything
# in std (certainly everything relevant).
[!GOOS:darwin] skip
go list -deps cmd/go

func hasDots(call *syntax.CallExpr) bool { return call.HasDots }

// dddErrPos returns the node (poser) for reporting an invalid ... use in a call.
func dddErrPos(call *syntax.CallExpr) *syntax.CallExpr {
	// TODO(gri) should use "..." instead of call position
	return call
}

// argErrPos returns the node (poser) for reporting an invalid argument count.
func argErrPos(call *syntax.CallExpr) *syntax.CallExpr { return call }

	// ByWeight lists all keys in Weight, sorted by edge weight from
	// highest to lowest.
	ByWeight []NamedCallEdge
}

func emptyProfile() *Profile {
	// Initialize empty maps/slices for easier use without a requiring a
	// nil check.
	return &Profile{
		NamedEdgeMap: NamedEdgeMap{
			ByWeight: make([]NamedCallEdge, 0),
			Weight:   make(map[NamedCallEdge]int64),
		},
	}
}

      group.places.push(place);
    }

    // Order by decreasing cost (makes it easier to spot heavy functions).
    // Though alphabetical ordering is a potential alternative that will make
    // profile comparisons easier.
    groups.sort(function(a, b) {
      return (b.sumpos + b.sumneg) - (a.sumpos + a.sumneg);
    });

    return groups;
  }

	log.SetPrefix("doc: ")
	telemetry.Start()
	dirsInit()
	err := do(os.Stdout, flag.CommandLine, os.Args[1:])
	if err != nil {
		log.Fatal(err)
	}
}

// do is the workhorse, broken out of main to make testing easier.
func do(writer io.Writer, flagSet *flag.FlagSet, args []string) (err error) {
	flagSet.Usage = usage
	unexported = false
	matchCase = false
	flagSet.StringVar(&chdir, "C", "", "change to `dir` before running command")

		}
	}
	for _, cmd := range exem.Loads {
		raw := cmd.Raw()
		type_ := exem.ByteOrder.Uint32(raw)
		if type_ != LC_BUILD_VERSION {
			continue
		}
		osVer := exem.ByteOrder.Uint32(raw[12:])
		checkMin(osVer)
		sdkVer := exem.ByteOrder.Uint32(raw[16:])
		checkMin(sdkVer)
		found = true
		break
	}
	if !found {
		t.Errorf("no LC_BUILD_VERSION load command found")
	}
}

		if _, err := fsys.Stat(absDir); err != nil {
			if os.IsNotExist(err) {
				// Canonicalize OS-specific errors to errDirectoryNotFound so that error
				// messages will be easier for users to search for.
				return "", &fs.PathError{Op: "stat", Path: absDir, Err: errDirectoryNotFound}
			}
			return "", err
		}
		if _, noGo := err.(*build.NoGoError); noGo {

	// An untyped nil does not need a pointer check, and when
	// _cgoCheckPointer returns the untyped nil the type assertion we
	// are going to insert will fail.  Easier to just skip nil arguments.
	// TODO: Note that this fails if nil is shadowed.
	if id, ok := arg.(*ast.Ident); ok && id.Name == "nil" {
		return false
	}

	return p.hasPointer(f, t, true)
}