From 404d0130b7dd656aaf1cbac18d2b0472616c111b Mon Sep 17 00:00:00 2001 From: Simon Mavi Stewart Date: Thu, 27 Nov 2025 12:24:39 +0000 Subject: [PATCH 1/2] [gazelle] Print class names when split packages detected When classes can come from multiple jars it's not always clear which one to use. By printing the class names, we make it easier for users to understand which dependency is actually required. --- java/gazelle/generate.go | 47 ++++++++++++++++++++--------- java/gazelle/generate_test.go | 6 ++-- java/gazelle/private/types/types.go | 1 + java/gazelle/resolve.go | 24 ++++++++++----- 4 files changed, 53 insertions(+), 25 deletions(-) diff --git a/java/gazelle/generate.go b/java/gazelle/generate.go index d81a3d5a..0a30ab17 100644 --- a/java/gazelle/generate.go +++ b/java/gazelle/generate.go @@ -153,11 +153,13 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes // Files and imports for code which isn't tests, and isn't used as helpers in tests. productionJavaFiles := sorted_set.NewSortedSet([]string{}) productionJavaImports := sorted_set.NewSortedSetFn([]types.PackageName{}, types.PackageNameLess) + productionJavaImportedClasses := sorted_set.NewSortedSetFn([]types.ClassName{}, types.ClassNameLess) nonLocalJavaExports := sorted_set.NewSortedSetFn([]types.PackageName{}, types.PackageNameLess) // Files and imports for actual test classes. testJavaFiles := sorted_set.NewSortedSetFn([]javaFile{}, javaFileLess) testJavaImports := sorted_set.NewSortedSetFn([]types.PackageName{}, types.PackageNameLess) + testJavaImportedClasses := sorted_set.NewSortedSetFn([]types.ClassName{}, types.ClassNameLess) // Java Test files which need to be generated separately from any others because they have explicit attribute overrides. separateTestJavaFiles := make(map[javaFile]separateJavaTestReasons) @@ -178,14 +180,14 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes allPackageNames.Add(mJavaPkg.Name) if !mJavaPkg.TestPackage { - addNonLocalImportsAndExports(productionJavaImports, nonLocalJavaExports, mJavaPkg.ImportedClasses, mJavaPkg.ImportedPackagesWithoutSpecificClasses, mJavaPkg.ExportedClasses, mJavaPkg.Name, likelyLocalClassNames) + addNonLocalImportsAndExports(productionJavaImports, productionJavaImportedClasses, nonLocalJavaExports, mJavaPkg.ImportedClasses, mJavaPkg.ImportedPackagesWithoutSpecificClasses, mJavaPkg.ExportedClasses, mJavaPkg.Name, likelyLocalClassNames) for _, f := range mJavaPkg.Files.SortedSlice() { productionJavaFiles.Add(filepath.Join(mRel, f)) } allMains.AddAll(mJavaPkg.Mains) } else { // Tests don't get to export things, as things shouldn't depend on them. - addNonLocalImportsAndExports(testJavaImports, nil, mJavaPkg.ImportedClasses, mJavaPkg.ImportedPackagesWithoutSpecificClasses, mJavaPkg.ExportedClasses, mJavaPkg.Name, likelyLocalClassNames) + addNonLocalImportsAndExports(testJavaImports, testJavaImportedClasses, nil, mJavaPkg.ImportedClasses, mJavaPkg.ImportedPackagesWithoutSpecificClasses, mJavaPkg.ExportedClasses, mJavaPkg.Name, likelyLocalClassNames) for _, f := range mJavaPkg.Files.SortedSlice() { path := filepath.Join(mRel, f) file := javaFile{ @@ -203,9 +205,9 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes allPackageNames.Add(javaPkg.Name) if javaPkg.TestPackage { // Tests don't get to export things, as things shouldn't depend on them. - addNonLocalImportsAndExports(testJavaImports, nil, javaPkg.ImportedClasses, javaPkg.ImportedPackagesWithoutSpecificClasses, javaPkg.ExportedClasses, javaPkg.Name, likelyLocalClassNames) + addNonLocalImportsAndExports(testJavaImports, testJavaImportedClasses, nil, javaPkg.ImportedClasses, javaPkg.ImportedPackagesWithoutSpecificClasses, javaPkg.ExportedClasses, javaPkg.Name, likelyLocalClassNames) } else { - addNonLocalImportsAndExports(productionJavaImports, nonLocalJavaExports, javaPkg.ImportedClasses, javaPkg.ImportedPackagesWithoutSpecificClasses, javaPkg.ExportedClasses, javaPkg.Name, likelyLocalClassNames) + addNonLocalImportsAndExports(productionJavaImports, productionJavaImportedClasses, nonLocalJavaExports, javaPkg.ImportedClasses, javaPkg.ImportedPackagesWithoutSpecificClasses, javaPkg.ExportedClasses, javaPkg.Name, likelyLocalClassNames) } allMains.AddAll(javaPkg.Mains) for _, f := range srcFilenamesRelativeToPackage { @@ -234,6 +236,14 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes } return true }) + nonLocalProductionJavaImportedClasses := productionJavaImportedClasses.Filter(func(c types.ClassName) bool { + for _, n := range allPackageNamesSlice { + if c.PackageName().Name == n.Name { + return false + } + } + return true + }) javaLibraryKind := "java_library" if hasKotlinFiles { @@ -325,7 +335,7 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes } } - l.generateJavaLibrary(args.File, args.Rel, filepath.Base(args.Rel), productionJavaFiles.SortedSlice(), resourcesDirectRef, resourcesRuntimeDep, allPackageNames, nonLocalProductionJavaImports, nonLocalJavaExports, annotationProcessorClasses, false, javaLibraryKind, &res, cfg, args.Config.RepoName) + l.generateJavaLibrary(args.File, args.Rel, filepath.Base(args.Rel), productionJavaFiles.SortedSlice(), resourcesDirectRef, resourcesRuntimeDep, allPackageNames, nonLocalProductionJavaImports, nonLocalProductionJavaImportedClasses, nonLocalJavaExports, annotationProcessorClasses, false, javaLibraryKind, &res, cfg, args.Config.RepoName) } if cfg.GenerateBinary() { @@ -348,7 +358,7 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes srcs = append(srcs, tf.pathRelativeToBazelWorkspaceRoot) } // Test helper libraries typically don't have resources - l.generateJavaLibrary(args.File, args.Rel, filepath.Base(args.Rel), srcs, "", "", packages, testJavaImports, nonLocalJavaExports, annotationProcessorClasses, true, javaLibraryKind, &res, cfg, args.Config.RepoName) + l.generateJavaLibrary(args.File, args.Rel, filepath.Base(args.Rel), srcs, "", "", packages, testJavaImports, testJavaImportedClasses, nonLocalJavaExports, annotationProcessorClasses, true, javaLibraryKind, &res, cfg, args.Config.RepoName) } } @@ -360,7 +370,7 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes case "file": for _, tf := range testJavaFiles.SortedSlice() { separateJavaTestReasons := separateTestJavaFiles[tf] - l.generateJavaTest(args.File, args.Rel, cfg.MavenRepositoryName(), tf, isModule, testJavaImportsWithHelpers, annotationProcessorClasses, nil, separateJavaTestReasons.wrapper, separateJavaTestReasons.attributes, &res) + l.generateJavaTest(args.File, args.Rel, cfg.MavenRepositoryName(), tf, isModule, testJavaImportsWithHelpers, testJavaImportedClasses, annotationProcessorClasses, nil, separateJavaTestReasons.wrapper, separateJavaTestReasons.attributes, &res) } case "suite": @@ -388,6 +398,7 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes packageNames, cfg.MavenRepositoryName(), testJavaImportsWithHelpers, + testJavaImportedClasses, annotationProcessorClasses, cfg.GetCustomJavaTestFileSuffixes(), testHelperJavaFiles.Len() > 0, @@ -405,7 +416,7 @@ func (l javaLang) GenerateRules(args language.GenerateArgs) language.GenerateRes testHelperDep = ptr(testHelperLibname(suiteName)) } separateJavaTestReasons := separateTestJavaFiles[src] - l.generateJavaTest(args.File, args.Rel, cfg.MavenRepositoryName(), src, isModule, testJavaImportsWithHelpers, annotationProcessorClasses, testHelperDep, separateJavaTestReasons.wrapper, separateJavaTestReasons.attributes, &res) + l.generateJavaTest(args.File, args.Rel, cfg.MavenRepositoryName(), src, isModule, testJavaImportsWithHelpers, testJavaImportedClasses, annotationProcessorClasses, testHelperDep, separateJavaTestReasons.wrapper, separateJavaTestReasons.attributes, &res) } } } @@ -510,15 +521,15 @@ func generateProtoLibraries(args language.GenerateArgs, log zerolog.Logger, res // We exclude intra-target imports because otherwise we'd get self-dependencies come resolve time. // toExports is optional and may be nil. All other parameters are required and must be non-nil. -func addNonLocalImportsAndExports(toImports *sorted_set.SortedSet[types.PackageName], toExports *sorted_set.SortedSet[types.PackageName], fromImportedClasses *sorted_set.SortedSet[types.ClassName], fromPackages *sorted_set.SortedSet[types.PackageName], fromExportedClasses *sorted_set.SortedSet[types.ClassName], pkg types.PackageName, localClasses *sorted_set.SortedSet[string]) { +func addNonLocalImportsAndExports(toImports *sorted_set.SortedSet[types.PackageName], toImportedClasses *sorted_set.SortedSet[types.ClassName], toExports *sorted_set.SortedSet[types.PackageName], fromImportedClasses *sorted_set.SortedSet[types.ClassName], fromPackages *sorted_set.SortedSet[types.PackageName], fromExportedClasses *sorted_set.SortedSet[types.ClassName], pkg types.PackageName, localClasses *sorted_set.SortedSet[string]) { toImports.AddAll(fromPackages) - addFilteringOutOwnPackage(toImports, fromImportedClasses, pkg, localClasses) + addFilteringOutOwnPackage(toImports, toImportedClasses, fromImportedClasses, pkg, localClasses) if toExports != nil { - addFilteringOutOwnPackage(toExports, fromExportedClasses, pkg, localClasses) + addFilteringOutOwnPackage(toExports, nil, fromExportedClasses, pkg, localClasses) } } -func addFilteringOutOwnPackage(to *sorted_set.SortedSet[types.PackageName], from *sorted_set.SortedSet[types.ClassName], ownPackage types.PackageName, localOuterClassNames *sorted_set.SortedSet[string]) { +func addFilteringOutOwnPackage(to *sorted_set.SortedSet[types.PackageName], toClasses *sorted_set.SortedSet[types.ClassName], from *sorted_set.SortedSet[types.ClassName], ownPackage types.PackageName, localOuterClassNames *sorted_set.SortedSet[string]) { for _, fromPackage := range from.SortedSlice() { if ownPackage == fromPackage.PackageName() { if localOuterClassNames.Contains(fromPackage.BareOuterClassName()) { @@ -531,6 +542,9 @@ func addFilteringOutOwnPackage(to *sorted_set.SortedSet[types.PackageName], from } to.Add(fromPackage.PackageName()) + if toClasses != nil { + toClasses.Add(fromPackage) + } } } @@ -583,7 +597,7 @@ func accumulateJavaFile(cfg *javaconfig.Config, testJavaFiles, testHelperJavaFil } } -func (l javaLang) generateJavaLibrary(file *rule.File, pathToPackageRelativeToBazelWorkspace, name string, srcsRelativeToBazelWorkspace []string, resourcesDirectRef string, resourcesRuntimeDep string, packages, imports, exports *sorted_set.SortedSet[types.PackageName], annotationProcessorClasses *sorted_set.SortedSet[types.ClassName], testonly bool, javaLibraryRuleKind string, res *language.GenerateResult, cfg *javaconfig.Config, repoName string) { +func (l javaLang) generateJavaLibrary(file *rule.File, pathToPackageRelativeToBazelWorkspace, name string, srcsRelativeToBazelWorkspace []string, resourcesDirectRef string, resourcesRuntimeDep string, packages, imports *sorted_set.SortedSet[types.PackageName], importedClasses *sorted_set.SortedSet[types.ClassName], exports *sorted_set.SortedSet[types.PackageName], annotationProcessorClasses *sorted_set.SortedSet[types.ClassName], testonly bool, javaLibraryRuleKind string, res *language.GenerateResult, cfg *javaconfig.Config, repoName string) { r := rule.NewRule(javaLibraryRuleKind, name) srcs := make([]string, 0, len(srcsRelativeToBazelWorkspace)) @@ -632,6 +646,7 @@ func (l javaLang) generateJavaLibrary(file *rule.File, pathToPackageRelativeToBa resolveInput := types.ResolveInput{ PackageNames: packages, ImportedPackageNames: imports, + ImportedClasses: importedClasses, ExportedPackageNames: exports, AnnotationProcessors: annotationProcessorClasses, } @@ -682,7 +697,7 @@ func (l javaLang) generateJavaBinary(file *rule.File, m types.ClassName, libName }) } -func (l javaLang) generateJavaTest(file *rule.File, pathToPackageRelativeToBazelWorkspace string, mavenRepositoryName string, f javaFile, includePackageInName bool, imports *sorted_set.SortedSet[types.PackageName], annotationProcessorClasses *sorted_set.SortedSet[types.ClassName], depOnTestHelpers *string, wrapper string, extraAttributes map[string]bzl.Expr, res *language.GenerateResult) { +func (l javaLang) generateJavaTest(file *rule.File, pathToPackageRelativeToBazelWorkspace string, mavenRepositoryName string, f javaFile, includePackageInName bool, imports *sorted_set.SortedSet[types.PackageName], importedClasses *sorted_set.SortedSet[types.ClassName], annotationProcessorClasses *sorted_set.SortedSet[types.ClassName], depOnTestHelpers *string, wrapper string, extraAttributes map[string]bzl.Expr, res *language.GenerateResult) { className := f.ClassName() fullyQualifiedTestClass := className.FullyQualifiedClassName() var testName string @@ -742,6 +757,7 @@ func (l javaLang) generateJavaTest(file *rule.File, pathToPackageRelativeToBazel resolveInput := types.ResolveInput{ PackageNames: sorted_set.NewSortedSetFn([]types.PackageName{f.pkg}, types.PackageNameLess), ImportedPackageNames: testImports, + ImportedClasses: importedClasses, AnnotationProcessors: annotationProcessorClasses, } res.Imports = append(res.Imports, resolveInput) @@ -770,7 +786,7 @@ var junit5RuntimeDeps = []string{ "org.junit.platform:junit-platform-reporting", } -func (l javaLang) generateJavaTestSuite(file *rule.File, name string, srcs []string, packageNames *sorted_set.SortedSet[types.PackageName], mavenRepositoryName string, imports *sorted_set.SortedSet[types.PackageName], annotationProcessorClasses *sorted_set.SortedSet[types.ClassName], customTestSuffixes *[]string, hasHelpers bool, res *language.GenerateResult) { +func (l javaLang) generateJavaTestSuite(file *rule.File, name string, srcs []string, packageNames *sorted_set.SortedSet[types.PackageName], mavenRepositoryName string, imports *sorted_set.SortedSet[types.PackageName], importedClasses *sorted_set.SortedSet[types.ClassName], annotationProcessorClasses *sorted_set.SortedSet[types.ClassName], customTestSuffixes *[]string, hasHelpers bool, res *language.GenerateResult) { const ruleKind = "java_test_suite" r := rule.NewRule(ruleKind, name) r.SetAttr("srcs", srcs) @@ -811,6 +827,7 @@ func (l javaLang) generateJavaTestSuite(file *rule.File, name string, srcs []str resolveInput := types.ResolveInput{ PackageNames: packageNames, ImportedPackageNames: suiteImports, + ImportedClasses: importedClasses, AnnotationProcessors: annotationProcessorClasses, } res.Imports = append(res.Imports, resolveInput) diff --git a/java/gazelle/generate_test.go b/java/gazelle/generate_test.go index 418f280c..b07ad0dc 100644 --- a/java/gazelle/generate_test.go +++ b/java/gazelle/generate_test.go @@ -159,7 +159,7 @@ func TestSingleJavaTestFile(t *testing.T) { var res language.GenerateResult l := newTestJavaLang(t) - l.generateJavaTest(nil, "", "maven", f, tc.includePackageInName, stringsToPackageNames(tc.importedPackages), nil, nil, tc.wrapper, nil, &res) + l.generateJavaTest(nil, "", "maven", f, tc.includePackageInName, stringsToPackageNames(tc.importedPackages), nil, nil, nil, tc.wrapper, nil, &res) require.Len(t, res.Gen, 1, "want 1 generated rule") @@ -252,7 +252,7 @@ func TestSuite(t *testing.T) { var res language.GenerateResult l := newTestJavaLang(t) - l.generateJavaTestSuite(nil, "blah", []string{src}, stringsToPackageNames([]string{pkg}), "maven", stringsToPackageNames(tc.importedPackages), nil, nil, false, &res) + l.generateJavaTestSuite(nil, "blah", []string{src}, stringsToPackageNames([]string{pkg}), "maven", stringsToPackageNames(tc.importedPackages), nil, nil, nil, false, &res) require.Len(t, res.Gen, 1, "want 1 generated rule") @@ -309,7 +309,7 @@ func TestAddNonLocalImports(t *testing.T) { depsDst := sorted_set.NewSortedSetFn([]types.PackageName{}, types.PackageNameLess) exportsDst := sorted_set.NewSortedSetFn([]types.PackageName{}, types.PackageNameLess) - addNonLocalImportsAndExports(depsDst, exportsDst, src, sorted_set.NewSortedSetFn[types.PackageName]([]types.PackageName{}, types.PackageNameLess), sorted_set.NewSortedSetFn([]types.ClassName{}, types.ClassNameLess), types.NewPackageName("com.example.a.b"), sorted_set.NewSortedSet([]string{"Foo", "Bar"})) + addNonLocalImportsAndExports(depsDst, nil, exportsDst, src, sorted_set.NewSortedSetFn[types.PackageName]([]types.PackageName{}, types.PackageNameLess), sorted_set.NewSortedSetFn([]types.ClassName{}, types.ClassNameLess), types.NewPackageName("com.example.a.b"), sorted_set.NewSortedSet([]string{"Foo", "Bar"})) want := stringsToPackageNames([]string{ "com.another.a.b", diff --git a/java/gazelle/private/types/types.go b/java/gazelle/private/types/types.go index 444f98b0..5b00ff31 100644 --- a/java/gazelle/private/types/types.go +++ b/java/gazelle/private/types/types.go @@ -110,6 +110,7 @@ func ClassNameLess(l, r ClassName) bool { type ResolveInput struct { PackageNames *sorted_set.SortedSet[PackageName] ImportedPackageNames *sorted_set.SortedSet[PackageName] + ImportedClasses *sorted_set.SortedSet[ClassName] ExportedPackageNames *sorted_set.SortedSet[PackageName] AnnotationProcessors *sorted_set.SortedSet[ClassName] } diff --git a/java/gazelle/resolve.go b/java/gazelle/resolve.go index 49109832..0fece398 100644 --- a/java/gazelle/resolve.go +++ b/java/gazelle/resolve.go @@ -115,17 +115,26 @@ func (jr *Resolver) Resolve(c *config.Config, ix *resolve.RuleIndex, rc *repo.Re } } - jr.populateAttr(c, packageConfig, r, "deps", resolveInput.ImportedPackageNames, ix, isTestRule, from, resolveInput.PackageNames) - jr.populateAttr(c, packageConfig, r, "exports", resolveInput.ExportedPackageNames, ix, isTestRule, from, resolveInput.PackageNames) + jr.populateAttr(c, packageConfig, r, "deps", resolveInput.ImportedPackageNames, resolveInput.ImportedClasses, ix, isTestRule, from, resolveInput.PackageNames) + jr.populateAttr(c, packageConfig, r, "exports", resolveInput.ExportedPackageNames, nil, ix, isTestRule, from, resolveInput.PackageNames) jr.populatePluginsAttr(c, ix, resolveInput, packageConfig, from, isTestRule, r) } -func (jr *Resolver) populateAttr(c *config.Config, pc *javaconfig.Config, r *rule.Rule, attrName string, requiredPackageNames *sorted_set.SortedSet[types.PackageName], ix *resolve.RuleIndex, isTestRule bool, from label.Label, ownPackageNames *sorted_set.SortedSet[types.PackageName]) { +func (jr *Resolver) populateAttr(c *config.Config, pc *javaconfig.Config, r *rule.Rule, attrName string, requiredPackageNames *sorted_set.SortedSet[types.PackageName], importedClasses *sorted_set.SortedSet[types.ClassName], ix *resolve.RuleIndex, isTestRule bool, from label.Label, ownPackageNames *sorted_set.SortedSet[types.PackageName]) { labels := sorted_set.NewSortedSetFn[label.Label]([]label.Label{}, sorted_set.LabelLess) for _, imp := range requiredPackageNames.SortedSlice() { - dep := jr.resolveSinglePackage(c, pc, imp, ix, from, isTestRule, ownPackageNames) + var pkgClasses []string + if importedClasses != nil { + for _, cls := range importedClasses.SortedSlice() { + if cls.PackageName() == imp { + pkgClasses = append(pkgClasses, cls.BareOuterClassName()) + } + } + } + + dep := jr.resolveSinglePackage(c, pc, imp, ix, from, isTestRule, ownPackageNames, pkgClasses) if dep == label.NoLabel { continue } @@ -140,7 +149,7 @@ func (jr *Resolver) populateAttr(c *config.Config, pc *javaconfig.Config, r *rul func (jr *Resolver) populatePluginsAttr(c *config.Config, ix *resolve.RuleIndex, resolveInput types.ResolveInput, packageConfig *javaconfig.Config, from label.Label, isTestRule bool, r *rule.Rule) { pluginLabels := sorted_set.NewSortedSetFn[label.Label]([]label.Label{}, labelLess) for _, annotationProcessor := range resolveInput.AnnotationProcessors.SortedSlice() { - dep := jr.resolveSinglePackage(c, packageConfig, annotationProcessor.PackageName(), ix, from, isTestRule, resolveInput.PackageNames) + dep := jr.resolveSinglePackage(c, packageConfig, annotationProcessor.PackageName(), ix, from, isTestRule, resolveInput.PackageNames, []string{annotationProcessor.BareOuterClassName()}) if dep == label.NoLabel { continue } @@ -206,7 +215,7 @@ func setLabelAttrIncludingExistingValues(r *rule.Rule, attrName string, labels * } } -func (jr *Resolver) resolveSinglePackage(c *config.Config, pc *javaconfig.Config, imp types.PackageName, ix *resolve.RuleIndex, from label.Label, isTestRule bool, ownPackageNames *sorted_set.SortedSet[types.PackageName]) (out label.Label) { +func (jr *Resolver) resolveSinglePackage(c *config.Config, pc *javaconfig.Config, imp types.PackageName, ix *resolve.RuleIndex, from label.Label, isTestRule bool, ownPackageNames *sorted_set.SortedSet[types.PackageName], pkgClasses []string) (out label.Label) { cacheKey := types.NewResolvableJavaPackage(imp, false, false) importSpec := resolve.ImportSpec{Lang: languageName, Imp: cacheKey.String()} if ol, found := resolve.FindRuleWithOverride(c, importSpec, languageName); found { @@ -281,7 +290,7 @@ func (jr *Resolver) resolveSinglePackage(c *config.Config, pc *javaconfig.Config if errors.As(err, &noExternal) { // do not fail, the package might be provided elsewhere } else if errors.As(err, &multipleExternal) { - jr.lang.logger.Error().Msg("Append one of the following to BUILD.bazel:") + jr.lang.logger.Error().Strs("classes", pkgClasses).Msg("Append one of the following to BUILD.bazel:") for _, possible := range multipleExternal.PossiblePackages { jr.lang.logger.Error().Msgf("# gazelle:resolve java %s %s", imp.Name, possible) } @@ -325,6 +334,7 @@ func (jr *Resolver) resolveSinglePackage(c *config.Config, pc *javaconfig.Config jr.lang.logger.Warn(). Str("package", imp.Name). Str("from rule", from.String()). + Strs("classes", pkgClasses). Msg("Unable to find package for import in any dependency") jr.lang.hasHadErrors = true From c6aa567b382f0d978ebc5c41681ddbfdc9af854a Mon Sep 17 00:00:00 2001 From: Simon Mavi Stewart Date: Thu, 27 Nov 2025 13:01:19 +0000 Subject: [PATCH 2/2] Fix failing tests by updating golden test data --- .../testdata/lib_with_unknown_import/expectedStderr.txt | 2 +- java/gazelle/testdata/maven_with_collision/expectedStderr.txt | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/java/gazelle/testdata/lib_with_unknown_import/expectedStderr.txt b/java/gazelle/testdata/lib_with_unknown_import/expectedStderr.txt index b9e0ab30..17890c5f 100644 --- a/java/gazelle/testdata/lib_with_unknown_import/expectedStderr.txt +++ b/java/gazelle/testdata/lib_with_unknown_import/expectedStderr.txt @@ -1,2 +1,2 @@ -{"level":"warn","package":"com.idonotexist","from rule":"//src/main/java/com/example/hello","message":"Unable to find package for import in any dependency"} +{"level":"warn","package":"com.idonotexist","from rule":"//src/main/java/com/example/hello","classes":["MyClass"],"message":"Unable to find package for import in any dependency"} {"level":"fatal","message":"the java extension encountered errors that will create invalid build files"} diff --git a/java/gazelle/testdata/maven_with_collision/expectedStderr.txt b/java/gazelle/testdata/maven_with_collision/expectedStderr.txt index 68d413be..516deb93 100644 --- a/java/gazelle/testdata/maven_with_collision/expectedStderr.txt +++ b/java/gazelle/testdata/maven_with_collision/expectedStderr.txt @@ -1,5 +1,5 @@ -{"level":"error","message":"Append one of the following to BUILD.bazel:"} +{"level":"error","classes":["Ints"],"message":"Append one of the following to BUILD.bazel:"} {"level":"error","message":"# gazelle:resolve java com.google.common.primitives @maven//:com_google_guava_guava"} {"level":"error","message":"# gazelle:resolve java com.google.common.primitives @maven//:com_google_guava_guava_sources"} -{"level":"warn","package":"com.google.common.primitives","from rule":"//src/main/java/com/example/myproject","message":"Unable to find package for import in any dependency"} +{"level":"warn","package":"com.google.common.primitives","from rule":"//src/main/java/com/example/myproject","classes":["Ints"],"message":"Unable to find package for import in any dependency"} {"level":"fatal","message":"the java extension encountered errors that will create invalid build files"}