internal: rename ModuleInfo to LegacyModuleInfo

ModuleInfo is renamed to LegacyModuleInfo, as a step towards
deprecating LegacyReadmeFilePath and LegacyReadmeContents.

In a follow up CL, we will add ModuleInfo as an embedded struct
to LegacyModuleInfo.

Change-Id: Ie452420448eec1d13edaf62e548df0b9e2cbbe4b
Reviewed-on: https://team-review.git.corp.google.com/c/golang/discovery/+/766479
CI-Result: Cloud Build <devtools-proctor-result-processor@system.gserviceaccount.com>
Reviewed-by: Jonathan Amsterdam <jba@google.com>

8 files changed, 41 insertions, 41 deletions

diff --git a/internal/postgres/details.go b/internal/postgres/details.go
index b6763f1a..c075582b 100644
--- a/internal/postgres/details.go
+++ b/internal/postgres/details.go
@@ -73,21 +73,21 @@ func (db *DB) GetPackagesInModule(ctx context.Context, modulePath, version strin
 // GetTaggedVersionsForPackageSeries returns a list of tagged versions sorted in
 // descending semver order. This list includes tagged versions of packages that
 // have the same v1path.
-func (db *DB) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.LegacyModuleInfo, error) {
 	return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
 // GetPseudoVersionsForPackageSeries returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order. This list includes
 // pseudo-versions of packages that have the same v1path.
-func (db *DB) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.LegacyModuleInfo, error) {
 	return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypePseudo})
 }
 
 // getPackageVersions returns a list of versions sorted in descending semver
 // order. The version types included in the list are specified by a list of
 // VersionTypes.
-func getPackageVersions(ctx context.Context, db *DB, pkgPath string, versionTypes []version.Type) (_ []*internal.ModuleInfo, err error) {
+func getPackageVersions(ctx context.Context, db *DB, pkgPath string, versionTypes []version.Type) (_ []*internal.LegacyModuleInfo, err error) {
 	defer derrors.Wrap(&err, "DB.getPackageVersions(ctx, db, %q, %v)", pkgPath, versionTypes)
 
 	baseQuery := `
@@ -126,9 +126,9 @@ func getPackageVersions(ctx context.Context, db *DB, pkgPath string, versionType
 	}
 	defer rows.Close()
 
-	var versionHistory []*internal.ModuleInfo
+	var versionHistory []*internal.LegacyModuleInfo
 	for rows.Next() {
-		var mi internal.ModuleInfo
+		var mi internal.LegacyModuleInfo
 		if err := rows.Scan(&mi.ModulePath, &mi.Version, &mi.CommitTime); err != nil {
 			return nil, fmt.Errorf("row.Scan(): %v", err)
 		}
@@ -154,20 +154,20 @@ func versionTypeExpr(vts []version.Type) string {
 
 // GetTaggedVersionsForModule returns a list of tagged versions sorted in
 // descending semver order.
-func (db *DB) GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.LegacyModuleInfo, error) {
 	return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
 // GetPseudoVersionsForModule returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order.
-func (db *DB) GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.LegacyModuleInfo, error) {
 	return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypePseudo})
 }
 
 // getModuleVersions returns a list of versions sorted in descending semver
 // order. The version types included in the list are specified by a list of
 // VersionTypes.
-func getModuleVersions(ctx context.Context, db *DB, modulePath string, versionTypes []version.Type) (_ []*internal.ModuleInfo, err error) {
+func getModuleVersions(ctx context.Context, db *DB, modulePath string, versionTypes []version.Type) (_ []*internal.LegacyModuleInfo, err error) {
 	// TODO(b/139530312): get information for parent modules.
 	defer derrors.Wrap(&err, "getModuleVersions(ctx, db, %q, %v)", modulePath, versionTypes)
 
@@ -189,9 +189,9 @@ func getModuleVersions(ctx context.Context, db *DB, modulePath string, versionTy
 		queryEnd = `LIMIT 10;`
 	}
 	query := fmt.Sprintf(baseQuery, versionTypeExpr(versionTypes), queryEnd)
-	var vinfos []*internal.ModuleInfo
+	var vinfos []*internal.LegacyModuleInfo
 	collect := func(rows *sql.Rows) error {
-		var mi internal.ModuleInfo
+		var mi internal.LegacyModuleInfo
 		if err := rows.Scan(&mi.ModulePath, &mi.Version, &mi.CommitTime); err != nil {
 			return err
 		}
@@ -423,7 +423,7 @@ func compareLicenses(i, j *licenses.Metadata) bool {
 
 // GetModuleInfo fetches a Version from the database with the primary key
 // (module_path, version).
-func (db *DB) GetModuleInfo(ctx context.Context, modulePath string, version string) (_ *internal.ModuleInfo, err error) {
+func (db *DB) GetModuleInfo(ctx context.Context, modulePath string, version string) (_ *internal.LegacyModuleInfo, err error) {
 	defer derrors.Wrap(&err, "GetModuleInfo(ctx, %q, %q)", modulePath, version)
 
 	query := `
@@ -458,7 +458,7 @@ func (db *DB) GetModuleInfo(ctx context.Context, modulePath string, version stri
 	}
 
 	var (
-		mi       internal.ModuleInfo
+		mi       internal.LegacyModuleInfo
 		hasGoMod sql.NullBool
 	)
 	row := db.db.QueryRow(ctx, query, args...)
@@ -474,7 +474,7 @@ func (db *DB) GetModuleInfo(ctx context.Context, modulePath string, version stri
 	return &mi, nil
 }
 
-func setHasGoMod(mi *internal.ModuleInfo, nb sql.NullBool) {
+func setHasGoMod(mi *internal.LegacyModuleInfo, nb sql.NullBool) {
 	// The safe default value for HasGoMod is true, because search will penalize modules that don't have one.
 	// This is temporary: when has_go_mod is fully populated, we'll make it NOT NULL.
 	mi.HasGoMod = true
diff --git a/internal/postgres/details_test.go b/internal/postgres/details_test.go
index 5ab23a49..b4b4ce23 100644
--- a/internal/postgres/details_test.go
+++ b/internal/postgres/details_test.go
@@ -81,7 +81,7 @@ func TestPostgres_GetVersionInfo_Latest(t *testing.T) {
 			if tc.wantIndex >= len(tc.modules) {
 				t.Fatal("wantIndex too large")
 			}
-			wantVI := &tc.modules[tc.wantIndex].ModuleInfo
+			wantVI := &tc.modules[tc.wantIndex].LegacyModuleInfo
 			if diff := cmp.Diff(wantVI, gotVI, cmpopts.EquateEmpty(), cmp.AllowUnexported(source.Info{})); diff != "" {
 				t.Errorf("mismatch (-want +got):\n%s", diff)
 			}
@@ -193,7 +193,7 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
 		name, path, modulePath string
 		numPseudo              int
 		modules                []*internal.Module
-		wantTaggedVersions     []*internal.ModuleInfo
+		wantTaggedVersions     []*internal.LegacyModuleInfo
 	}{
 		{
 			name:       "want_releases_and_prereleases_only",
@@ -201,7 +201,7 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
 			modulePath: modulePath1,
 			numPseudo:  12,
 			modules:    testModules,
-			wantTaggedVersions: []*internal.ModuleInfo{
+			wantTaggedVersions: []*internal.LegacyModuleInfo{
 				{
 					ModulePath: modulePath2,
 					Version:    "v2.1.0",
@@ -241,7 +241,7 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			defer ResetTestDB(testDB, t)
 
-			var wantPseudoVersions []*internal.ModuleInfo
+			var wantPseudoVersions []*internal.LegacyModuleInfo
 			for i := 0; i < tc.numPseudo; i++ {
 
 				pseudo := fmt.Sprintf("v0.0.0-201806111833%02d-d8887717615a", i+1)
@@ -253,7 +253,7 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
 				// GetPseudoVersions should only return the 10 most recent pseudo versions,
 				// if there are more than 10 in the database
 				if i < 10 {
-					wantPseudoVersions = append(wantPseudoVersions, &internal.ModuleInfo{
+					wantPseudoVersions = append(wantPseudoVersions, &internal.LegacyModuleInfo{
 						ModulePath: modulePath1,
 						Version:    fmt.Sprintf("v0.0.0-201806111833%02d-d8887717615a", tc.numPseudo-i),
 						CommitTime: sample.CommitTime,
diff --git a/internal/postgres/directory.go b/internal/postgres/directory.go
index f82508cb..fbec3af1 100644
--- a/internal/postgres/directory.go
+++ b/internal/postgres/directory.go
@@ -57,7 +57,7 @@ func (db *DB) GetDirectoryNew(ctx context.Context, path, modulePath, version str
 			AND m.module_path = $2
 			AND m.version = $3;`
 	var (
-		mi                         internal.ModuleInfo
+		mi                         internal.LegacyModuleInfo
 		dir                        internal.DirectoryNew
 		readme                     internal.Readme
 		doc                        internal.Documentation
@@ -125,8 +125,8 @@ func (db *DB) GetDirectoryNew(ctx context.Context, path, modulePath, version str
 	}
 
 	return &internal.VersionedDirectory{
-		ModuleInfo:   mi,
-		DirectoryNew: dir,
+		LegacyModuleInfo: mi,
+		DirectoryNew:     dir,
 	}, nil
 }
 
@@ -185,7 +185,7 @@ func (db *DB) GetDirectory(ctx context.Context, dirPath, modulePath, version str
 
 	var (
 		packages []*internal.LegacyPackage
-		mi       = internal.ModuleInfo{LegacyReadmeContents: internal.StringFieldMissing}
+		mi       = internal.LegacyModuleInfo{LegacyReadmeContents: internal.StringFieldMissing}
 	)
 	collect := func(rows *sql.Rows) error {
 		var (
@@ -243,9 +243,9 @@ func (db *DB) GetDirectory(ctx context.Context, dirPath, modulePath, version str
 		return packages[i].Path < packages[j].Path
 	})
 	return &internal.LegacyDirectory{
-		Path:       dirPath,
-		ModuleInfo: mi,
-		Packages:   packages,
+		Path:             dirPath,
+		LegacyModuleInfo: mi,
+		Packages:         packages,
 	}, nil
 }
 
diff --git a/internal/postgres/directory_test.go b/internal/postgres/directory_test.go
index 71922071..544dde22 100644
--- a/internal/postgres/directory_test.go
+++ b/internal/postgres/directory_test.go
@@ -252,7 +252,7 @@ func TestGetDirectory(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			mi := sample.ModuleInfo(tc.wantModulePath, tc.wantVersion)
+			mi := sample.LegacyModuleInfo(tc.wantModulePath, tc.wantVersion)
 			var wantPackages []*internal.LegacyPackage
 			for _, suffix := range tc.wantSuffixes {
 				pkg := sample.LegacyPackage(tc.wantModulePath, suffix)
@@ -264,9 +264,9 @@ func TestGetDirectory(t *testing.T) {
 			})
 
 			wantDirectory := &internal.LegacyDirectory{
-				ModuleInfo: *mi,
-				Packages:   wantPackages,
-				Path:       tc.dirPath,
+				LegacyModuleInfo: *mi,
+				Packages:         wantPackages,
+				Path:             tc.dirPath,
 			}
 			opts := []cmp.Option{
 				cmpopts.EquateEmpty(),
@@ -312,7 +312,7 @@ func TestGetDirectoryNew(t *testing.T) {
 
 	newVdir := func(path, modulePath, version string, readme *internal.Readme, pkg *internal.PackageNew) *internal.VersionedDirectory {
 		return &internal.VersionedDirectory{
-			ModuleInfo: *sample.ModuleInfo(modulePath, version),
+			LegacyModuleInfo: *sample.LegacyModuleInfo(modulePath, version),
 			DirectoryNew: internal.DirectoryNew{
 				Path:              path,
 				V1Path:            path,
diff --git a/internal/postgres/insert_module_test.go b/internal/postgres/insert_module_test.go
index 99a5bf02..7e9f01f6 100644
--- a/internal/postgres/insert_module_test.go
+++ b/internal/postgres/insert_module_test.go
@@ -88,7 +88,7 @@ func TestInsertModule(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			if diff := cmp.Diff(test.module.ModuleInfo, *got, cmp.AllowUnexported(source.Info{})); diff != "" {
+			if diff := cmp.Diff(test.module.LegacyModuleInfo, *got, cmp.AllowUnexported(source.Info{})); diff != "" {
 				t.Fatalf("testDB.GetModuleInfo(%q, %q) mismatch (-want +got):\n%s", test.module.ModulePath, test.module.Version, diff)
 			}
 
@@ -117,12 +117,12 @@ func TestInsertModule(t *testing.T) {
 					t.Fatal(err)
 				}
 				want := internal.VersionedDirectory{
-					DirectoryNew: *dir,
-					ModuleInfo:   test.module.ModuleInfo,
+					DirectoryNew:     *dir,
+					LegacyModuleInfo: test.module.LegacyModuleInfo,
 				}
 				opts := cmp.Options{
-					cmpopts.IgnoreFields(internal.ModuleInfo{}, "LegacyReadmeFilePath"),
-					cmpopts.IgnoreFields(internal.ModuleInfo{}, "LegacyReadmeContents"),
+					cmpopts.IgnoreFields(internal.LegacyModuleInfo{}, "LegacyReadmeFilePath"),
+					cmpopts.IgnoreFields(internal.LegacyModuleInfo{}, "LegacyReadmeContents"),
 					cmpopts.IgnoreFields(licenses.Metadata{}, "Coverage"),
 					cmp.AllowUnexported(source.Info{}),
 				}
@@ -211,7 +211,7 @@ func TestInsertModuleErrors(t *testing.T) {
 
 func TestPostgres_ReadAndWriteModuleOtherColumns(t *testing.T) {
 	// Verify that InsertModule correctly populates the columns in the versions
-	// table that are not in the ModuleInfo struct.
+	// table that are not in the LegacyModuleInfo struct.
 	defer ResetTestDB(testDB, t)
 	ctx := context.Background()
 
diff --git a/internal/postgres/package.go b/internal/postgres/package.go
index 0c26f5b0..e342dd43 100644
--- a/internal/postgres/package.go
+++ b/internal/postgres/package.go
@@ -141,7 +141,7 @@ func (db *DB) GetPackage(ctx context.Context, pkgPath, modulePath, version strin
 		&pkg.V1Path, pq.Array(&licenseTypes), pq.Array(&licensePaths), &pkg.LegacyPackage.IsRedistributable,
 		database.NullIsEmpty(&pkg.DocumentationHTML), &pkg.GOOS, &pkg.GOARCH, &pkg.Version,
 		&pkg.CommitTime, database.NullIsEmpty(&pkg.LegacyReadmeFilePath), database.NullIsEmpty(&pkg.LegacyReadmeContents),
-		&pkg.ModulePath, &pkg.VersionType, jsonbScanner{&pkg.SourceInfo}, &pkg.ModuleInfo.IsRedistributable,
+		&pkg.ModulePath, &pkg.VersionType, jsonbScanner{&pkg.SourceInfo}, &pkg.LegacyModuleInfo.IsRedistributable,
 		&hasGoMod)
 	if err != nil {
 		if err == sql.ErrNoRows {
@@ -149,7 +149,7 @@ func (db *DB) GetPackage(ctx context.Context, pkgPath, modulePath, version strin
 		}
 		return nil, fmt.Errorf("row.Scan(): %v", err)
 	}
-	setHasGoMod(&pkg.ModuleInfo, hasGoMod)
+	setHasGoMod(&pkg.LegacyModuleInfo, hasGoMod)
 	lics, err := zipLicenseMetadata(licenseTypes, licensePaths)
 	if err != nil {
 		return nil, err
diff --git a/internal/postgres/package_test.go b/internal/postgres/package_test.go
index 817a8025..88996cad 100644
--- a/internal/postgres/package_test.go
+++ b/internal/postgres/package_test.go
@@ -45,8 +45,8 @@ func TestGetPackage(t *testing.T) {
 	checkPackage := func(got *internal.LegacyVersionedPackage, pkgPath, modulePath, version string) {
 		t.Helper()
 		want := &internal.LegacyVersionedPackage{
-			ModuleInfo:    *sample.ModuleInfo(modulePath, version),
-			LegacyPackage: *sample.LegacyPackage(modulePath, suffix(pkgPath, modulePath)),
+			LegacyModuleInfo: *sample.LegacyModuleInfo(modulePath, version),
+			LegacyPackage:    *sample.LegacyPackage(modulePath, suffix(pkgPath, modulePath)),
 		}
 		want.Imports = nil
 		opts := cmp.Options{
diff --git a/internal/postgres/path_test.go b/internal/postgres/path_test.go
index 485ba6db..c7a19416 100644
--- a/internal/postgres/path_test.go
+++ b/internal/postgres/path_test.go
@@ -44,7 +44,7 @@ func TestGetPathInfo(t *testing.T) {
 		pkgName := path.Base(testModule.packageSuffix)
 		pkgPath := path.Join(testModule.module, testModule.packageSuffix)
 		m := &internal.Module{
-			ModuleInfo: internal.ModuleInfo{
+			LegacyModuleInfo: internal.LegacyModuleInfo{
 				ModulePath:  testModule.module,
 				Version:     testModule.version,
 				VersionType: vtype,