internal: rename GetPackage to LegacyGetPackage

Change-Id: Ia9123b6551d950a7ecfdf808e3da5c788512d60a
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/238026
Reviewed-by: Jonathan Amsterdam <jba@google.com>

10 files changed, 35 insertions, 35 deletions

diff --git a/internal/datasource.go b/internal/datasource.go
index 9782f139..db61d69e 100644
--- a/internal/datasource.go
+++ b/internal/datasource.go
@@ -50,10 +50,10 @@ type DataSource interface {
 	// LegacyGetModuleLicenses returns all top-level Licenses for the given modulePath
 	// and version. (i.e., Licenses contained in the module root directory)
 	LegacyGetModuleLicenses(ctx context.Context, modulePath, version string) ([]*licenses.License, error)
-	// GetPackage returns the LegacyVersionedPackage corresponding to the given package
+	// LegacyGetPackage returns the LegacyVersionedPackage corresponding to the given package
 	// pkgPath, modulePath, and version. When multiple package paths satisfy this query, it
 	// should prefer the module with the longest path.
-	GetPackage(ctx context.Context, pkgPath, modulePath, version string) (*LegacyVersionedPackage, error)
+	LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (*LegacyVersionedPackage, error)
 	// LegacyGetPackageLicenses returns all Licenses that apply to pkgPath, within the
 	// module version specified by modulePath and version.
 	LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, version string) ([]*licenses.License, error)
diff --git a/internal/frontend/latest_version.go b/internal/frontend/latest_version.go
index 3a3026fe..67fc90e3 100644
--- a/internal/frontend/latest_version.go
+++ b/internal/frontend/latest_version.go
@@ -40,7 +40,7 @@ func (s *Server) latestVersion(ctx context.Context, packagePath, modulePath, pag
 			return "", err
 		}
 	case "pkg":
-		pkg, err := s.ds.GetPackage(ctx, packagePath, modulePath, internal.LatestVersion)
+		pkg, err := s.ds.LegacyGetPackage(ctx, packagePath, modulePath, internal.LatestVersion)
 		if err != nil {
 			return "", err
 		}
diff --git a/internal/frontend/package.go b/internal/frontend/package.go
index 099c581d..e5461b32 100644
--- a/internal/frontend/package.go
+++ b/internal/frontend/package.go
@@ -36,7 +36,7 @@ func (s *Server) servePackagePage(w http.ResponseWriter, r *http.Request, pkgPat
 	//   3. If there is another version that contains this package path: serve a
 	//      404 and suggest these versions.
 	//   4. Just serve a 404
-	pkg, err := s.ds.GetPackage(ctx, pkgPath, modulePath, version)
+	pkg, err := s.ds.LegacyGetPackage(ctx, pkgPath, modulePath, version)
 	if err == nil {
 		return s.servePackagePageWithPackage(ctx, w, r, pkg, version)
 	}
@@ -65,14 +65,14 @@ func (s *Server) servePackagePage(w http.ResponseWriter, r *http.Request, pkgPat
 		// whatever response we resolve below might be inconsistent or misleading.
 		return fmt.Errorf("checking for directory: %v", err)
 	}
-	_, err = s.ds.GetPackage(ctx, pkgPath, modulePath, internal.LatestVersion)
+	_, err = s.ds.LegacyGetPackage(ctx, pkgPath, modulePath, internal.LatestVersion)
 	if err == nil {
 		return pathFoundAtLatestError(ctx, "package", pkgPath, version)
 	}
 	if !errors.Is(err, derrors.NotFound) {
 		// Unlike the error handling for LegacyGetDirectory above, we don't serve an
 		// InternalServerError here. The reasoning for this is that regardless of
-		// the result of GetPackage(..., "latest"), we're going to serve a NotFound
+		// the result of LegacyGetPackage(..., "latest"), we're going to serve a NotFound
 		// response code. So the semantics of the endpoint are the same whether or
 		// not we get an unexpected error from GetPackage -- we just don't serve a
 		// more informative error response.
diff --git a/internal/frontend/search.go b/internal/frontend/search.go
index f25fbb77..b8966cd8 100644
--- a/internal/frontend/search.go
+++ b/internal/frontend/search.go
@@ -154,7 +154,7 @@ func searchRequestRedirectPath(ctx context.Context, ds internal.DataSource, quer
 		return fmt.Sprintf("/mod/%s", requestedPath)
 	}
 
-	pkg, err := ds.GetPackage(ctx, requestedPath, internal.UnknownModulePath, internal.LatestVersion)
+	pkg, err := ds.LegacyGetPackage(ctx, requestedPath, internal.UnknownModulePath, internal.LatestVersion)
 	if err == nil {
 		return fmt.Sprintf("/%s", pkg.Path)
 	} else if !errors.Is(err, derrors.NotFound) {
diff --git a/internal/postgres/insert_module_test.go b/internal/postgres/insert_module_test.go
index fb3e8092..bdbbbe5f 100644
--- a/internal/postgres/insert_module_test.go
+++ b/internal/postgres/insert_module_test.go
@@ -94,7 +94,7 @@ func checkModule(ctx context.Context, t *testing.T, want *internal.Module) {
 	}
 
 	for _, wantp := range want.LegacyPackages {
-		got, err := testDB.GetPackage(ctx, wantp.Path, want.ModulePath, want.Version)
+		got, err := testDB.LegacyGetPackage(ctx, wantp.Path, want.ModulePath, want.Version)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -106,7 +106,7 @@ func checkModule(ctx context.Context, t *testing.T, want *internal.Module) {
 			cmpopts.EquateEmpty(),
 		}
 		if diff := cmp.Diff(*wantp, got.LegacyPackage, opts...); diff != "" {
-			t.Fatalf("testDB.GetPackage(%q, %q) mismatch (-want +got):\n%s", wantp.Path, want.Version, diff)
+			t.Fatalf("testDB.LegacyGetPackage(%q, %q) mismatch (-want +got):\n%s", wantp.Path, want.Version, diff)
 		}
 	}
 
diff --git a/internal/postgres/package.go b/internal/postgres/package.go
index 803b45d8..8f1e310e 100644
--- a/internal/postgres/package.go
+++ b/internal/postgres/package.go
@@ -16,7 +16,7 @@ import (
 	"golang.org/x/pkgsite/internal/stdlib"
 )
 
-// GetPackage returns the a package from the database with the corresponding
+// LegacyGetPackage returns the a package from the database with the corresponding
 // pkgPath, modulePath and version.
 //
 // If version = internal.LatestVersion, the package corresponding to
@@ -41,8 +41,8 @@ import (
 // The returned error may be checked with
 // errors.Is(err, derrors.InvalidArgument) to determine if it was caused by an
 // invalid path or version.
-func (db *DB) GetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
-	defer derrors.Wrap(&err, "DB.GetPackage(ctx, %q, %q)", pkgPath, version)
+func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
+	defer derrors.Wrap(&err, "DB.LegacyGetPackage(ctx, %q, %q)", pkgPath, version)
 	if pkgPath == "" || modulePath == "" || version == "" {
 		return nil, fmt.Errorf("none of pkgPath, modulePath, or version can be empty: %w", derrors.InvalidArgument)
 	}
diff --git a/internal/postgres/package_test.go b/internal/postgres/package_test.go
index 88996cad..61cb6fab 100644
--- a/internal/postgres/package_test.go
+++ b/internal/postgres/package_test.go
@@ -19,7 +19,7 @@ import (
 	"golang.org/x/pkgsite/internal/testing/sample"
 )
 
-func TestGetPackage(t *testing.T) {
+func TestLegacyGetPackage(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
 	defer cancel()
 
@@ -56,7 +56,7 @@ func TestGetPackage(t *testing.T) {
 			cmpopts.IgnoreFields(licenses.Metadata{}, "Coverage"),
 		}
 		if diff := cmp.Diff(want, got, opts...); diff != "" {
-			t.Errorf("testDB.GetPackage(ctx, %q, %q, %q) mismatch (-want +got):\n%s", pkgPath, modulePath, version, diff)
+			t.Errorf("testDB.LegacyGetPackage(ctx, %q, %q, %q) mismatch (-want +got):\n%s", pkgPath, modulePath, version, diff)
 		}
 	}
 
@@ -188,7 +188,7 @@ func TestGetPackage(t *testing.T) {
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			got, err := testDB.GetPackage(ctx, tc.pkgPath, tc.modulePath, tc.version)
+			got, err := testDB.LegacyGetPackage(ctx, tc.pkgPath, tc.modulePath, tc.version)
 			if tc.wantNotFoundErr {
 				if !errors.Is(err, derrors.NotFound) {
 					t.Fatalf("want derrors.NotFound; got = %v", err)
@@ -203,7 +203,7 @@ func TestGetPackage(t *testing.T) {
 	}
 }
 
-func TestGetPackageInvalidArguments(t *testing.T) {
+func TestLegacyGetPackageInvalidArguments(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
 	defer cancel()
 
@@ -227,7 +227,7 @@ func TestGetPackageInvalidArguments(t *testing.T) {
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			got, err := testDB.GetPackage(ctx, tc.modulePath+"/package", tc.modulePath, tc.version)
+			got, err := testDB.LegacyGetPackage(ctx, tc.modulePath+"/package", tc.modulePath, tc.version)
 			if !errors.Is(err, derrors.InvalidArgument) {
 				t.Fatalf("want %v; got = \n%+v, %v", derrors.InvalidArgument, got, err)
 			}
diff --git a/internal/proxydatasource/datasource.go b/internal/proxydatasource/datasource.go
index ee3cd5e3..583a66de 100644
--- a/internal/proxydatasource/datasource.go
+++ b/internal/proxydatasource/datasource.go
@@ -107,7 +107,7 @@ func (ds *DataSource) GetDirectoryNew(ctx context.Context, dirPath, modulePath,
 // GetImports returns package imports as extracted from the module zip.
 func (ds *DataSource) GetImports(ctx context.Context, pkgPath, modulePath, version string) (_ []string, err error) {
 	defer derrors.Wrap(&err, "GetImports(%q, %q, %q)", pkgPath, modulePath, version)
-	vp, err := ds.GetPackage(ctx, pkgPath, modulePath, version)
+	vp, err := ds.LegacyGetPackage(ctx, pkgPath, modulePath, version)
 	if err != nil {
 		return nil, err
 	}
@@ -131,12 +131,12 @@ func (ds *DataSource) LegacyGetModuleLicenses(ctx context.Context, modulePath, v
 	return filtered, nil
 }
 
-// GetPackage returns a LegacyVersionedPackage for the given pkgPath and version. If
+// LegacyGetPackage returns a LegacyVersionedPackage for the given pkgPath and version. If
 // such a package exists in the cache, it will be returned without querying the
 // proxy. Otherwise, the proxy is queried to find the longest module path at
 // that version containing the package.
-func (ds *DataSource) GetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
-	defer derrors.Wrap(&err, "GetPackage(%q, %q)", pkgPath, version)
+func (ds *DataSource) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
+	defer derrors.Wrap(&err, "LegacyGetPackage(%q, %q)", pkgPath, version)
 
 	var m *internal.Module
 	if modulePath != internal.UnknownModulePath {
diff --git a/internal/proxydatasource/datasource_test.go b/internal/proxydatasource/datasource_test.go
index 01814964..621a5c77 100644
--- a/internal/proxydatasource/datasource_test.go
+++ b/internal/proxydatasource/datasource_test.go
@@ -111,7 +111,7 @@ func TestDataSource_GetImports(t *testing.T) {
 func TestDataSource_GetPackage_Latest(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
-	got, err := ds.GetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, internal.LatestVersion)
+	got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, internal.LatestVersion)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -145,10 +145,10 @@ func TestDataSource_LegacyGetModuleLicenses(t *testing.T) {
 	}
 }
 
-func TestDataSource_GetPackage(t *testing.T) {
+func TestDataSource_LegacyGetPackage(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
-	got, err := ds.GetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, "v1.2.0")
+	got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, "v1.2.0")
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/internal/worker/fetch_test.go b/internal/worker/fetch_test.go
index 7c96b303..9139c23d 100644
--- a/internal/worker/fetch_test.go
+++ b/internal/worker/fetch_test.go
@@ -460,11 +460,11 @@ func TestSkipIncompletePackage(t *testing.T) {
 	}
 
 	pkgFoo := modulePath + "/foo"
-	if _, err := testDB.GetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
+	if _, err := testDB.LegacyGetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
 		t.Errorf("got %v, want nil", err)
 	}
 	pkgBar := modulePath + "/bar"
-	if _, err := testDB.GetPackage(ctx, pkgBar, internal.UnknownModulePath, version); !errors.Is(err, derrors.NotFound) {
+	if _, err := testDB.LegacyGetPackage(ctx, pkgBar, internal.UnknownModulePath, version); !errors.Is(err, derrors.NotFound) {
 		t.Errorf("got %v, want NotFound", err)
 	}
 }
@@ -528,15 +528,15 @@ func TestTrimLargeCode(t *testing.T) {
 	}
 
 	pkgFoo := modulePath + "/foo"
-	if _, err := testDB.GetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
+	if _, err := testDB.LegacyGetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
 		t.Errorf("got %v, want nil", err)
 	}
 	pkgBar := modulePath + "/bar"
-	if _, err := testDB.GetPackage(ctx, pkgBar, internal.UnknownModulePath, version); err != nil {
+	if _, err := testDB.LegacyGetPackage(ctx, pkgBar, internal.UnknownModulePath, version); err != nil {
 		t.Errorf("got %v, want nil", err)
 	}
 	pkgBaz := modulePath + "/baz"
-	if _, err := testDB.GetPackage(ctx, pkgBaz, internal.UnknownModulePath, version); err != nil {
+	if _, err := testDB.LegacyGetPackage(ctx, pkgBaz, internal.UnknownModulePath, version); err != nil {
 		t.Errorf("got %v, want nil", err)
 	}
 }
@@ -560,7 +560,7 @@ func TestFetch_V1Path(t *testing.T) {
 	if _, err := FetchAndUpdateState(ctx, "my.mod/foo", "v1.0.0", proxyClient, sourceClient, testDB); err != nil {
 		t.Fatalf("FetchAndUpdateState: %v", err)
 	}
-	pkg, err := testDB.GetPackage(ctx, "my.mod/foo", internal.UnknownModulePath, "v1.0.0")
+	pkg, err := testDB.LegacyGetPackage(ctx, "my.mod/foo", internal.UnknownModulePath, "v1.0.0")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -611,7 +611,7 @@ func TestReFetch(t *testing.T) {
 		t.Fatalf("FetchAndUpdateState(%q, %q, %v, %v, %v): %v", modulePath, version, proxyClient, sourceClient, testDB, err)
 	}
 
-	if _, err := testDB.GetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
+	if _, err := testDB.LegacyGetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
 		t.Error(err)
 	}
 
@@ -656,12 +656,12 @@ func TestReFetch(t *testing.T) {
 			GOARCH:            "amd64",
 		},
 	}
-	got, err := testDB.GetPackage(ctx, pkgBar, internal.UnknownModulePath, version)
+	got, err := testDB.LegacyGetPackage(ctx, pkgBar, internal.UnknownModulePath, version)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(internal.LegacyPackage{}, "DocumentationHTML"), cmp.AllowUnexported(source.Info{})); diff != "" {
-		t.Errorf("testDB.GetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", pkgBar, version, diff)
+		t.Errorf("testDB.LegacyGetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", pkgBar, version, diff)
 	}
 
 	// Now re-fetch and verify that contents were overwritten.
@@ -1061,7 +1061,7 @@ func TestFetchAndInsertModule(t *testing.T) {
 				t.Fatalf("testDB.GetModuleInfo(ctx, %q, %q) mismatch (-want +got):\n%s", test.modulePath, test.version, diff)
 			}
 
-			gotPkg, err := testDB.GetPackage(ctx, test.pkg, internal.UnknownModulePath, test.version)
+			gotPkg, err := testDB.LegacyGetPackage(ctx, test.pkg, internal.UnknownModulePath, test.version)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1070,7 +1070,7 @@ func TestFetchAndInsertModule(t *testing.T) {
 				return gotPkg.Licenses[i].FilePath < gotPkg.Licenses[j].FilePath
 			})
 			if diff := cmp.Diff(test.want, gotPkg, cmpopts.IgnoreFields(internal.LegacyPackage{}, "DocumentationHTML"), cmp.AllowUnexported(source.Info{})); diff != "" {
-				t.Errorf("testDB.GetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", test.pkg, test.version, diff)
+				t.Errorf("testDB.LegacyGetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", test.pkg, test.version, diff)
 			}
 			if got, want := gotPkg.DocumentationHTML, test.want.DocumentationHTML; len(want) == 0 && len(got) != 0 {
 				t.Errorf("got non-empty documentation but want empty:\ngot: %q\nwant: %q", got, want)