golang.org/x/pkgsite/internal.ModuleInfo.Version (field)

73 uses

	golang.org/x/pkgsite/internal (current package)
		discovery.go#L46: 	Version           string
		latest.go#L69: 	mi.Retracted, mi.RetractionRationale = isRetracted(li.GoModFile, mi.Version)

	golang.org/x/pkgsite/internal/fetch
		fetch.go#L321: 			Version:           resolvedVersion,
		unit.go#L53: 					Version:           version,

	golang.org/x/pkgsite/internal/frontend
		directory.go#L140: 			URL:      constructUnitURL(pm.Path, um.ModulePath, linkVersion(um.Version, um.ModulePath)),
		doc.go#L30: 		ResolvedVersion: u.Version,
		imports.go#L43: 			Version:    resolvedVersion,
		license.go#L44: 	return &LicensesDetails{Licenses: transformLicenses(um.ModulePath, um.Version, u.LicenseContents)}, nil
		main.go#L154: 				log.Errorf(ctx, "fetchMainDetails(%q, %q, %q): %v", um.Path, um.ModulePath, um.Version, err)
		main.go#L177: 		modReadme, err := ds.GetModuleReadme(ctx, unit.ModulePath, unit.Version)
		main.go#L190: 	versionType, err := version.ParseType(um.Version)
		main.go#L195: 	isStableVersion := semver.Major(um.Version) != "v0" && versionType == version.TypeRelease
		main.go#L252: 	defer derrors.Wrap(&err, "readmeContent(%q, %q, %q)", u.Path, u.ModulePath, u.Version)
		main.go#L269: 	log.Errorf(ctx, "unit %s (%s@%s) missing documentation source", u.Path, u.ModulePath, u.Version)
		overview.go#L76: 	defer derrors.Wrap(&err, "LegacyReadmeHTML(%s@%s)", mi.ModulePath, mi.Version)
		readme.go#L67: 	defer derrors.WrapAndReport(&err, "ProcessReadme(%q, %q, %q)", u.Path, u.ModulePath, u.Version)
		tabs.go#L79: 	defer derrors.Wrap(&err, "fetchDetailsForUnit(r, %q, ds, um=%q,%q,%q)", tab, um.Path, um.ModulePath, um.Version)
		tabs.go#L87: 		return fetchImportsDetails(ctx, ds, um.Path, um.ModulePath, um.Version)
		unit.go#L182: 	lv := linkVersion(um.Version, um.ModulePath)
		unit.go#L191: 		DisplayVersion:        displayVersion(um.Version, um.ModulePath),
		unit.go#L275: 	return constructUnitURL(um.Path, um.ModulePath, linkVersion(um.Version, um.ModulePath))
		versions.go#L111: 		return constructUnitURL(versionPath, mi.ModulePath, linkVersion(mi.Version, mi.ModulePath))
		versions.go#L157: 		major := semver.Major(mi.Version)
		versions.go#L160: 			major, err = stdlib.MajorVersionForVersion(mi.Version)
		versions.go#L171: 		} else if version.IsIncompatible(mi.Version) {
		versions.go#L172: 			major = semver.Major(mi.Version)
		versions.go#L179: 			Incompatible: version.IsIncompatible(mi.Version),
		versions.go#L184: 			Version:    linkVersion(mi.Version, mi.ModulePath),
		versions.go#L185: 			IsMinor:    isMinor(mi.Version),
		versions.go#L191: 		if sv := sh.SymbolsAtVersion(mi.Version); sv != nil {

	golang.org/x/pkgsite/internal/godoc
		render.go#L217: 		ResolvedVersion: u.Version,

	golang.org/x/pkgsite/internal/localdatasource
		datasource.go#L155: 			Version:           fetch.LocalVersion,

	golang.org/x/pkgsite/internal/postgres
		details.go#L195: 	if err := scan(&mi.ModulePath, &mi.Version, &mi.CommitTime,
		insert_module.go#L41: 		derrors.WrapStack(&err, "DB.InsertModule(ctx, Module(%q, %q))", m.ModulePath, m.Version)
		insert_module.go#L76: 	defer derrors.WrapStack(&err, "saveModule(ctx, tx, Module(%q, %q))", m.ModulePath, m.Version)
		insert_module.go#L137: 		isLatest = m.Version == latest
		insert_module.go#L172: 			log.Infof(ctx, "%s@%s: not inserting into search documents", m.ModulePath, m.Version)
		insert_module.go#L215: 	defer derrors.WrapStack(&err, "insertModule(ctx, %q, %q)", m.ModulePath, m.Version)
		insert_module.go#L220: 	versionType, err := version.ParseType(m.Version)
		insert_module.go#L245: 		m.Version,
		insert_module.go#L247: 		version.ForSorting(m.Version),
		insert_module.go#L253: 		version.IsIncompatible(m.Version),
		insert_module.go#L264: 	defer derrors.WrapStack(&err, "insertLicenses(ctx, %q, %q)", m.ModulePath, m.Version)
		insert_module.go#L302: 	defer derrors.WrapStack(&err, "insertImportsUnique(%q, %q)", m.ModulePath, m.Version)
		insert_module.go#L330: 	defer derrors.WrapStack(&err, "insertUnits(ctx, tx, %q, %q)", m.ModulePath, m.Version)
		insert_module.go#L420: 	versionType, err := version.ParseType(m.Version)
		insert_module.go#L425: 		return insertSymbols(ctx, db, m.ModulePath, m.Version, pathToID, pathToDocIDToDoc)
		insert_module.go#L770: 				derrors.WrapStack(&err, "validateModule(%q, %q)", m.ModulePath, m.Version)
		insert_module.go#L779: 	if m.Version == "" {
		insert_module.go#L789: 		if !semver.IsValid(m.Version) {
		insert_module.go#L797: 		return fmt.Errorf("cannot insert module %q: %s", m.Version, strings.Join(errReasons, ", "))
		insert_module.go#L828: 	defer derrors.WrapStack(&err, "comparePaths(ctx, %q, %q)", m.ModulePath, m.Version)
		insert_module.go#L829: 	dbPaths, err := db.getPathsInModule(ctx, m.ModulePath, m.Version)
		search.go#L630: 	defer derrors.WrapStack(&err, "upsertSearchDocuments(ctx, %q, %q)", mod.ModulePath, mod.Version)
		search.go#L640: 			Version:     mod.Version,
		search.go#L653: 		if err := upsertSearchDocumentSymbols(ctx, ddb, pkg.Path, mod.ModulePath, mod.Version); err != nil {
		test_helper.go#L224: 		lmv = addLatest(ctx, t, db, m.ModulePath, m.Version, goMod)
		unit.go#L99: 		&um.Version,
		unit.go#L246: 	defer derrors.WrapStack(&err, "GetUnit(ctx, %q, %q, %q, %v)", um.Path, um.ModulePath, um.Version, bc)
		unit.go#L261: 	unitID, err := db.getUnitID(ctx, um.Path, um.ModulePath, um.Version)
		unit.go#L426: 	defer derrors.WrapStack(&err, "getUnitWithAllFields(ctx, %q, %q, %q)", um.Path, um.ModulePath, um.Version)
		unit.go#L454: 	}, um.Path, um.ModulePath, um.Version)
		version.go#L163: 		latest.MinorVersion = latestUnitMeta.Version
		version.go#L171: 			latest.MinorVersion = um.Version

	golang.org/x/pkgsite/internal/proxydatasource
		datasource.go#L206: 	latest.MinorVersion = latestUnitMeta.Version
		details.go#L19: 	defer derrors.Wrap(&err, "GetUnit(%q, %q, %q)", um.Path, um.ModulePath, um.Version)
		details.go#L20: 	return ds.getUnit(ctx, um.Path, um.ModulePath, um.Version, bc)
		details.go#L54: 			Version:           inVersion,

	golang.org/x/pkgsite/internal/testing/sample
		sample.go#L212: 		UnitMeta:        *UnitMeta(m.ModulePath, m.ModulePath, m.Version, "", m.IsRedistributable),
		sample.go#L247: 	AddUnit(m, UnitForPackage(pkg.Path, m.ModulePath, m.Version, pkg.Name, pkg.IsRedistributable))
		sample.go#L261: 			AddUnit(m, UnitEmpty(pth, m.ModulePath, m.Version))
		sample.go#L280: 		Version:    versionString,
		sample.go#L358: 			Version:           version,