blob: dd59c894eec9157eed6654ea2d8cea0a88f6ab8c [file] [log] [blame]
Liz Kammer620dea62021-04-14 17:36:10 -04001// Copyright 2015 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package android
16
17import (
Liz Kammer620dea62021-04-14 17:36:10 -040018 "fmt"
Spandan Dasdc7d7f72023-09-28 21:23:30 +000019 "os"
Liz Kammer620dea62021-04-14 17:36:10 -040020 "path/filepath"
21 "strings"
22
Chris Parsons953b3562021-09-20 15:14:39 -040023 "android/soong/bazel"
24
Liz Kammer620dea62021-04-14 17:36:10 -040025 "github.com/google/blueprint"
26 "github.com/google/blueprint/pathtools"
27)
28
29// bazel_paths contains methods to:
30// * resolve Soong path and module references into bazel.LabelList
31// * resolve Bazel path references into Soong-compatible paths
32//
33// There is often a similar method for Bazel as there is for Soong path handling and should be used
34// in similar circumstances
35//
Usta Shresthadb46a9b2022-07-11 11:29:56 -040036// Bazel Soong
37// ==============================================================
38// BazelLabelForModuleSrc PathForModuleSrc
39// BazelLabelForModuleSrcExcludes PathForModuleSrcExcludes
40// BazelLabelForModuleDeps n/a
41// tbd PathForSource
42// tbd ExistentPathsForSources
43// PathForBazelOut PathForModuleOut
Liz Kammer620dea62021-04-14 17:36:10 -040044//
45// Use cases:
46// * Module contains a property (often tagged `android:"path"`) that expects paths *relative to the
47// module directory*:
48// * BazelLabelForModuleSrcExcludes, if the module also contains an excludes_<propname> property
49// * BazelLabelForModuleSrc, otherwise
50// * Converting references to other modules to Bazel Labels:
51// BazelLabelForModuleDeps
52// * Converting a path obtained from bazel_handler cquery results:
53// PathForBazelOut
54//
55// NOTE: all Soong globs are expanded within Soong rather than being converted to a Bazel glob
56// syntax. This occurs because Soong does not have a concept of crossing package boundaries,
57// so the glob as computed by Soong may contain paths that cross package-boundaries. These
58// would be unknowingly omitted if the glob were handled by Bazel. By expanding globs within
59// Soong, we support identification and detection (within Bazel) use of paths that cross
60// package boundaries.
61//
62// Path resolution:
63// * filepath/globs: resolves as itself or is converted to an absolute Bazel label (e.g.
64// //path/to/dir:<filepath>) if path exists in a separate package or subpackage.
65// * references to other modules (using the ":name{.tag}" syntax). These resolve as a Bazel label
66// for a target. If the Bazel target is in the local module directory, it will be returned
67// relative to the current package (e.g. ":<target>"). Otherwise, it will be returned as an
68// absolute Bazel label (e.g. "//path/to/dir:<target>"). If the reference to another module
69// cannot be resolved,the function will panic. This is often due to the dependency not being added
70// via an AddDependency* method.
71
Usta Shresthadb46a9b2022-07-11 11:29:56 -040072// BazelConversionContext is a minimal context interface to check if a module should be converted by bp2build,
Jingwen Chen55bc8202021-11-02 06:40:51 +000073// with functions containing information to match against allowlists and denylists.
74// If a module is deemed to be convertible by bp2build, then it should rely on a
75// BazelConversionPathContext for more functions for dep/path features.
76type BazelConversionContext interface {
77 Config() Config
Liz Kammer620dea62021-04-14 17:36:10 -040078
Liz Kammer620dea62021-04-14 17:36:10 -040079 Module() Module
Liz Kammer6eff3232021-08-26 08:37:59 -040080 OtherModuleType(m blueprint.Module) string
Liz Kammer620dea62021-04-14 17:36:10 -040081 OtherModuleName(m blueprint.Module) string
82 OtherModuleDir(m blueprint.Module) string
Sam Delmerico24c56032022-03-28 19:53:03 +000083 ModuleErrorf(format string, args ...interface{})
Jingwen Chen55bc8202021-11-02 06:40:51 +000084}
85
86// A subset of the ModuleContext methods which are sufficient to resolve references to paths/deps in
87// order to form a Bazel-compatible label for conversion.
88type BazelConversionPathContext interface {
89 EarlyModulePathContext
90 BazelConversionContext
91
Liz Kammerc86e0942023-08-11 16:15:12 -040092 ModuleName() string
93 ModuleType() string
Jingwen Chen55bc8202021-11-02 06:40:51 +000094 ModuleErrorf(fmt string, args ...interface{})
95 PropertyErrorf(property, fmt string, args ...interface{})
96 GetDirectDep(name string) (blueprint.Module, blueprint.DependencyTag)
97 ModuleFromName(name string) (blueprint.Module, bool)
Liz Kammer6eff3232021-08-26 08:37:59 -040098 AddUnconvertedBp2buildDep(string)
Liz Kammerdaa09ef2021-12-15 15:35:38 -050099 AddMissingBp2buildDep(dep string)
Liz Kammer620dea62021-04-14 17:36:10 -0400100}
101
102// BazelLabelForModuleDeps expects a list of reference to other modules, ("<module>"
103// or ":<module>") and returns a Bazel-compatible label which corresponds to dependencies on the
104// module within the given ctx.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000105func BazelLabelForModuleDeps(ctx BazelConversionPathContext, modules []string) bazel.LabelList {
Chris Parsons953b3562021-09-20 15:14:39 -0400106 return BazelLabelForModuleDepsWithFn(ctx, modules, BazelModuleLabel)
Liz Kammer2d7bbe32021-06-10 18:20:06 -0400107}
108
109// BazelLabelForModuleWholeDepsExcludes expects two lists: modules (containing modules to include in
110// the list), and excludes (modules to exclude from the list). Both of these should contain
111// references to other modules, ("<module>" or ":<module>"). It returns a Bazel-compatible label
112// list which corresponds to dependencies on the module within the given ctx, and the excluded
113// dependencies. Prebuilt dependencies will be appended with _alwayslink so they can be handled as
114// whole static libraries.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000115func BazelLabelForModuleDepsExcludes(ctx BazelConversionPathContext, modules, excludes []string) bazel.LabelList {
Chris Parsons953b3562021-09-20 15:14:39 -0400116 return BazelLabelForModuleDepsExcludesWithFn(ctx, modules, excludes, BazelModuleLabel)
Liz Kammer2d7bbe32021-06-10 18:20:06 -0400117}
118
Chris Parsons953b3562021-09-20 15:14:39 -0400119// BazelLabelForModuleDepsWithFn expects a list of reference to other modules, ("<module>"
120// or ":<module>") and applies moduleToLabelFn to determine and return a Bazel-compatible label
121// which corresponds to dependencies on the module within the given ctx.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000122func BazelLabelForModuleDepsWithFn(ctx BazelConversionPathContext, modules []string,
123 moduleToLabelFn func(BazelConversionPathContext, blueprint.Module) string) bazel.LabelList {
Liz Kammer620dea62021-04-14 17:36:10 -0400124 var labels bazel.LabelList
Chris Parsons51f8c392021-08-03 21:01:05 -0400125 // In some cases, a nil string list is different than an explicitly empty list.
126 if len(modules) == 0 && modules != nil {
127 labels.Includes = []bazel.Label{}
128 return labels
129 }
Cole Faust5c84c622023-08-01 11:07:02 -0700130 modules = FirstUniqueStrings(modules)
Liz Kammer620dea62021-04-14 17:36:10 -0400131 for _, module := range modules {
132 bpText := module
133 if m := SrcIsModule(module); m == "" {
134 module = ":" + module
135 }
136 if m, t := SrcIsModuleWithTag(module); m != "" {
Chris Parsons953b3562021-09-20 15:14:39 -0400137 l := getOtherModuleLabel(ctx, m, t, moduleToLabelFn)
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500138 if l != nil {
139 l.OriginalModuleName = bpText
140 labels.Includes = append(labels.Includes, *l)
141 }
Liz Kammer620dea62021-04-14 17:36:10 -0400142 } else {
143 ctx.ModuleErrorf("%q, is not a module reference", module)
144 }
145 }
146 return labels
147}
148
Chris Parsons953b3562021-09-20 15:14:39 -0400149// BazelLabelForModuleDepsExcludesWithFn expects two lists: modules (containing modules to include in the
150// list), and excludes (modules to exclude from the list). Both of these should contain references
151// to other modules, ("<module>" or ":<module>"). It applies moduleToLabelFn to determine and return a
152// Bazel-compatible label list which corresponds to dependencies on the module within the given ctx, and
153// the excluded dependencies.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000154func BazelLabelForModuleDepsExcludesWithFn(ctx BazelConversionPathContext, modules, excludes []string,
155 moduleToLabelFn func(BazelConversionPathContext, blueprint.Module) string) bazel.LabelList {
Chris Parsons953b3562021-09-20 15:14:39 -0400156 moduleLabels := BazelLabelForModuleDepsWithFn(ctx, RemoveListFromList(modules, excludes), moduleToLabelFn)
Liz Kammer47535c52021-06-02 16:02:22 -0400157 if len(excludes) == 0 {
158 return moduleLabels
159 }
Chris Parsons953b3562021-09-20 15:14:39 -0400160 excludeLabels := BazelLabelForModuleDepsWithFn(ctx, excludes, moduleToLabelFn)
Liz Kammer47535c52021-06-02 16:02:22 -0400161 return bazel.LabelList{
162 Includes: moduleLabels.Includes,
163 Excludes: excludeLabels.Includes,
164 }
165}
166
Jingwen Chen55bc8202021-11-02 06:40:51 +0000167func BazelLabelForModuleSrcSingle(ctx BazelConversionPathContext, path string) bazel.Label {
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500168 if srcs := BazelLabelForModuleSrcExcludes(ctx, []string{path}, []string(nil)).Includes; len(srcs) > 0 {
169 return srcs[0]
170 }
171 return bazel.Label{}
Lukacs T. Berki1353e592021-04-30 15:35:09 +0200172}
173
Jingwen Chen55bc8202021-11-02 06:40:51 +0000174func BazelLabelForModuleDepSingle(ctx BazelConversionPathContext, path string) bazel.Label {
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500175 if srcs := BazelLabelForModuleDepsExcludes(ctx, []string{path}, []string(nil)).Includes; len(srcs) > 0 {
176 return srcs[0]
177 }
178 return bazel.Label{}
Rupert Shuttleworth6e4950a2021-07-27 01:34:59 -0400179}
180
Liz Kammer620dea62021-04-14 17:36:10 -0400181// BazelLabelForModuleSrc expects a list of path (relative to local module directory) and module
182// references (":<module>") and returns a bazel.LabelList{} containing the resolved references in
183// paths, relative to the local module, or Bazel-labels (absolute if in a different package or
184// relative if within the same package).
185// Properties must have been annotated with struct tag `android:"path"` so that dependencies modules
Spandan Das950091c2023-07-19 22:26:37 +0000186// will have already been handled by the pathdeps mutator.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000187func BazelLabelForModuleSrc(ctx BazelConversionPathContext, paths []string) bazel.LabelList {
Liz Kammer620dea62021-04-14 17:36:10 -0400188 return BazelLabelForModuleSrcExcludes(ctx, paths, []string(nil))
189}
190
191// BazelLabelForModuleSrc expects lists of path and excludes (relative to local module directory)
192// and module references (":<module>") and returns a bazel.LabelList{} containing the resolved
193// references in paths, minus those in excludes, relative to the local module, or Bazel-labels
194// (absolute if in a different package or relative if within the same package).
195// Properties must have been annotated with struct tag `android:"path"` so that dependencies modules
Spandan Das950091c2023-07-19 22:26:37 +0000196// will have already been handled by the pathdeps mutator.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000197func BazelLabelForModuleSrcExcludes(ctx BazelConversionPathContext, paths, excludes []string) bazel.LabelList {
Liz Kammer620dea62021-04-14 17:36:10 -0400198 excludeLabels := expandSrcsForBazel(ctx, excludes, []string(nil))
199 excluded := make([]string, 0, len(excludeLabels.Includes))
200 for _, e := range excludeLabels.Includes {
201 excluded = append(excluded, e.Label)
202 }
203 labels := expandSrcsForBazel(ctx, paths, excluded)
204 labels.Excludes = excludeLabels.Includes
Spandan Das0a8a2752023-06-21 01:50:33 +0000205 labels = TransformSubpackagePaths(ctx.Config(), ctx.ModuleDir(), labels)
Liz Kammer620dea62021-04-14 17:36:10 -0400206 return labels
207}
208
Spandan Das03010662023-08-15 22:06:41 +0000209func BazelLabelForSrcPatternExcludes(ctx BazelConversionPathContext, dir, pattern string, excludes []string) bazel.LabelList {
210 topRelPaths, err := ctx.GlobWithDeps(filepath.Join(dir, pattern), excludes)
211 if err != nil {
212 ctx.ModuleErrorf("Could not search dir: %s for pattern %s due to %v\n", dir, pattern, err)
213 }
214 // An intermediate list of labels relative to `dir` that assumes that there no subpacakges beneath `dir`
215 dirRelLabels := []bazel.Label{}
216 for _, topRelPath := range topRelPaths {
217 dirRelPath := Rel(ctx, dir, topRelPath)
218 dirRelLabels = append(dirRelLabels, bazel.Label{Label: "./" + dirRelPath})
219 }
220 // Return the package boudary resolved labels
221 return TransformSubpackagePaths(ctx.Config(), dir, bazel.MakeLabelList(dirRelLabels))
222}
223
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000224// Returns true if a prefix + components[:i] is a package boundary.
225//
226// A package boundary is determined by a BUILD file in the directory. This can happen in 2 cases:
227//
Usta Shresthad5580312022-09-23 16:46:38 -0400228// 1. An Android.bp exists, which bp2build will always convert to a sibling BUILD file.
229// 2. An Android.bp doesn't exist, but a checked-in BUILD/BUILD.bazel file exists, and that file
230// is allowlisted by the bp2build configuration to be merged into the symlink forest workspace.
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000231func isPackageBoundary(config Config, prefix string, components []string, componentIndex int) bool {
Spandan Dasdc7d7f72023-09-28 21:23:30 +0000232 isSymlink := func(c Config, path string) bool {
233 f, err := c.fs.Lstat(path)
234 if err != nil {
235 // The file does not exist
236 return false
237 }
238 return f.Mode()&os.ModeSymlink == os.ModeSymlink
239 }
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000240 prefix = filepath.Join(prefix, filepath.Join(components[:componentIndex+1]...))
241 if exists, _, _ := config.fs.Exists(filepath.Join(prefix, "Android.bp")); exists {
Liz Kammer620dea62021-04-14 17:36:10 -0400242 return true
Spandan Dasdc7d7f72023-09-28 21:23:30 +0000243 } else if config.Bp2buildPackageConfig.ShouldKeepExistingBuildFileForDir(prefix) || isSymlink(config, prefix) {
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000244 if exists, _, _ := config.fs.Exists(filepath.Join(prefix, "BUILD")); exists {
245 return true
246 } else if exists, _, _ := config.fs.Exists(filepath.Join(prefix, "BUILD.bazel")); exists {
247 return true
248 }
Liz Kammer620dea62021-04-14 17:36:10 -0400249 }
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000250
251 return false
Liz Kammer620dea62021-04-14 17:36:10 -0400252}
253
254// Transform a path (if necessary) to acknowledge package boundaries
255//
256// e.g. something like
Colin Crossd079e0b2022-08-16 10:27:33 -0700257//
258// async_safe/include/async_safe/CHECK.h
259//
Liz Kammer620dea62021-04-14 17:36:10 -0400260// might become
Colin Crossd079e0b2022-08-16 10:27:33 -0700261//
262// //bionic/libc/async_safe:include/async_safe/CHECK.h
263//
Liz Kammer620dea62021-04-14 17:36:10 -0400264// if the "async_safe" directory is actually a package and not just a directory.
265//
266// In particular, paths that extend into packages are transformed into absolute labels beginning with //.
Spandan Das0a8a2752023-06-21 01:50:33 +0000267func transformSubpackagePath(cfg Config, dir string, path bazel.Label) bazel.Label {
Liz Kammer620dea62021-04-14 17:36:10 -0400268 var newPath bazel.Label
269
Jingwen Chen38e62642021-04-19 05:00:15 +0000270 // Don't transform OriginalModuleName
271 newPath.OriginalModuleName = path.OriginalModuleName
Liz Kammer1e753242023-06-02 19:03:06 -0400272 // if it wasn't a module, store the original path. We may need the original path to replace
273 // references if it is actually in another package
274 if path.OriginalModuleName == "" {
275 newPath.OriginalModuleName = path.Label
276 }
Liz Kammer620dea62021-04-14 17:36:10 -0400277
278 if strings.HasPrefix(path.Label, "//") {
279 // Assume absolute labels are already correct (e.g. //path/to/some/package:foo.h)
280 newPath.Label = path.Label
281 return newPath
282 }
Usta Shresthad5580312022-09-23 16:46:38 -0400283 if strings.HasPrefix(path.Label, "./") {
284 // Drop "./" for consistent handling of paths.
285 // Specifically, to not let "." be considered a package boundary.
286 // Say `inputPath` is `x/Android.bp` and that file has some module
287 // with `srcs=["y/a.c", "z/b.c"]`.
288 // And say the directory tree is:
289 // x
290 // ├── Android.bp
291 // ├── y
292 // │ ├── a.c
293 // │ └── Android.bp
294 // └── z
295 // └── b.c
296 // Then bazel equivalent labels in srcs should be:
297 // //x/y:a.c, x/z/b.c
298 // The above should still be the case if `x/Android.bp` had
299 // srcs=["./y/a.c", "./z/b.c"]
300 // However, if we didn't strip "./", we'd get
301 // //x/./y:a.c, //x/.:z/b.c
302 path.Label = strings.TrimPrefix(path.Label, "./")
303 }
Liz Kammer620dea62021-04-14 17:36:10 -0400304 pathComponents := strings.Split(path.Label, "/")
Usta Shresthad5580312022-09-23 16:46:38 -0400305 newLabel := ""
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000306 foundPackageBoundary := false
Liz Kammer620dea62021-04-14 17:36:10 -0400307 // Check the deepest subdirectory first and work upwards
308 for i := len(pathComponents) - 1; i >= 0; i-- {
309 pathComponent := pathComponents[i]
310 var sep string
Spandan Das0a8a2752023-06-21 01:50:33 +0000311 if !foundPackageBoundary && isPackageBoundary(cfg, dir, pathComponents, i) {
Liz Kammer620dea62021-04-14 17:36:10 -0400312 sep = ":"
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000313 foundPackageBoundary = true
Liz Kammer620dea62021-04-14 17:36:10 -0400314 } else {
315 sep = "/"
316 }
317 if newLabel == "" {
318 newLabel = pathComponent
319 } else {
320 newLabel = pathComponent + sep + newLabel
321 }
322 }
Jingwen Chen0eeaeb82022-09-21 10:27:42 +0000323 if foundPackageBoundary {
Liz Kammer620dea62021-04-14 17:36:10 -0400324 // Ensure paths end up looking like //bionic/... instead of //./bionic/...
Spandan Das0a8a2752023-06-21 01:50:33 +0000325 moduleDir := dir
Liz Kammer620dea62021-04-14 17:36:10 -0400326 if strings.HasPrefix(moduleDir, ".") {
327 moduleDir = moduleDir[1:]
328 }
329 // Make the path into an absolute label (e.g. //bionic/libc/foo:bar.h instead of just foo:bar.h)
330 if moduleDir == "" {
331 newLabel = "//" + newLabel
332 } else {
333 newLabel = "//" + moduleDir + "/" + newLabel
334 }
335 }
336 newPath.Label = newLabel
337
338 return newPath
339}
340
341// Transform paths to acknowledge package boundaries
342// See transformSubpackagePath() for more information
Spandan Das0a8a2752023-06-21 01:50:33 +0000343func TransformSubpackagePaths(cfg Config, dir string, paths bazel.LabelList) bazel.LabelList {
Liz Kammer620dea62021-04-14 17:36:10 -0400344 var newPaths bazel.LabelList
345 for _, include := range paths.Includes {
Spandan Das0a8a2752023-06-21 01:50:33 +0000346 newPaths.Includes = append(newPaths.Includes, transformSubpackagePath(cfg, dir, include))
Liz Kammer620dea62021-04-14 17:36:10 -0400347 }
348 for _, exclude := range paths.Excludes {
Spandan Das0a8a2752023-06-21 01:50:33 +0000349 newPaths.Excludes = append(newPaths.Excludes, transformSubpackagePath(cfg, dir, exclude))
Liz Kammer620dea62021-04-14 17:36:10 -0400350 }
351 return newPaths
352}
353
Romain Jobredeaux1282c422021-10-29 10:52:59 -0400354// Converts root-relative Paths to a list of bazel.Label relative to the module in ctx.
355func RootToModuleRelativePaths(ctx BazelConversionPathContext, paths Paths) []bazel.Label {
356 var newPaths []bazel.Label
357 for _, path := range PathsWithModuleSrcSubDir(ctx, paths, "") {
358 s := path.Rel()
359 newPaths = append(newPaths, bazel.Label{Label: s})
360 }
361 return newPaths
362}
363
Liz Kammer620dea62021-04-14 17:36:10 -0400364// expandSrcsForBazel returns bazel.LabelList with paths rooted from the module's local source
365// directory and Bazel target labels, excluding those included in the excludes argument (which
366// should already be expanded to resolve references to Soong-modules). Valid elements of paths
367// include:
Colin Crossd079e0b2022-08-16 10:27:33 -0700368// - filepath, relative to local module directory, resolves as a filepath relative to the local
369// source directory
370// - glob, relative to the local module directory, resolves as filepath(s), relative to the local
371// module directory. Because Soong does not have a concept of crossing package boundaries, the
372// glob as computed by Soong may contain paths that cross package-boundaries that would be
373// unknowingly omitted if the glob were handled by Bazel. To allow identification and detect
374// (within Bazel) use of paths that cross package boundaries, we expand globs within Soong rather
375// than converting Soong glob syntax to Bazel glob syntax. **Invalid for excludes.**
376// - other modules using the ":name{.tag}" syntax. These modules must implement SourceFileProducer
377// or OutputFileProducer. These resolve as a Bazel label for a target. If the Bazel target is in
378// the local module directory, it will be returned relative to the current package (e.g.
379// ":<target>"). Otherwise, it will be returned as an absolute Bazel label (e.g.
380// "//path/to/dir:<target>"). If the reference to another module cannot be resolved,the function
381// will panic.
382//
Liz Kammer620dea62021-04-14 17:36:10 -0400383// Properties passed as the paths or excludes argument must have been annotated with struct tag
384// `android:"path"` so that dependencies on other modules will have already been handled by the
Spandan Das950091c2023-07-19 22:26:37 +0000385// pathdeps mutator.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000386func expandSrcsForBazel(ctx BazelConversionPathContext, paths, expandedExcludes []string) bazel.LabelList {
Liz Kammer620dea62021-04-14 17:36:10 -0400387 if paths == nil {
388 return bazel.LabelList{}
389 }
390 labels := bazel.LabelList{
391 Includes: []bazel.Label{},
392 }
Jingwen Chen4ecc67d2021-04-27 09:47:02 +0000393
394 // expandedExcludes contain module-dir relative paths, but root-relative paths
395 // are needed for GlobFiles later.
396 var rootRelativeExpandedExcludes []string
397 for _, e := range expandedExcludes {
398 rootRelativeExpandedExcludes = append(rootRelativeExpandedExcludes, filepath.Join(ctx.ModuleDir(), e))
399 }
400
Liz Kammer620dea62021-04-14 17:36:10 -0400401 for _, p := range paths {
402 if m, tag := SrcIsModuleWithTag(p); m != "" {
Chris Parsons953b3562021-09-20 15:14:39 -0400403 l := getOtherModuleLabel(ctx, m, tag, BazelModuleLabel)
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500404 if l != nil && !InList(l.Label, expandedExcludes) {
Spandan Dasf62e80a2023-08-17 22:35:04 +0000405 if strings.HasPrefix(m, "//") {
406 // this is a module in a soong namespace
407 // It appears as //<namespace>:<module_name> in srcs, and not ://<namespace>:<module_name>
408 l.OriginalModuleName = m
409 } else {
410 l.OriginalModuleName = fmt.Sprintf(":%s", m)
411 }
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500412 labels.Includes = append(labels.Includes, *l)
Liz Kammer620dea62021-04-14 17:36:10 -0400413 }
414 } else {
415 var expandedPaths []bazel.Label
416 if pathtools.IsGlob(p) {
Jingwen Chen4ecc67d2021-04-27 09:47:02 +0000417 // e.g. turn "math/*.c" in
418 // external/arm-optimized-routines to external/arm-optimized-routines/math/*.c
419 rootRelativeGlobPath := pathForModuleSrc(ctx, p).String()
Romain Jobredeaux1282c422021-10-29 10:52:59 -0400420 expandedPaths = RootToModuleRelativePaths(ctx, GlobFiles(ctx, rootRelativeGlobPath, rootRelativeExpandedExcludes))
Liz Kammer620dea62021-04-14 17:36:10 -0400421 } else {
422 if !InList(p, expandedExcludes) {
423 expandedPaths = append(expandedPaths, bazel.Label{Label: p})
424 }
425 }
426 labels.Includes = append(labels.Includes, expandedPaths...)
427 }
428 }
429 return labels
430}
431
432// getOtherModuleLabel returns a bazel.Label for the given dependency/tag combination for the
433// module. The label will be relative to the current directory if appropriate. The dependency must
434// already be resolved by either deps mutator or path deps mutator.
Jingwen Chen55bc8202021-11-02 06:40:51 +0000435func getOtherModuleLabel(ctx BazelConversionPathContext, dep, tag string,
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500436 labelFromModule func(BazelConversionPathContext, blueprint.Module) string) *bazel.Label {
Chris Parsons5a34ffb2021-07-21 14:34:58 -0400437 m, _ := ctx.ModuleFromName(dep)
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500438 // The module was not found in an Android.bp file, this is often due to:
439 // * a limited manifest
440 // * a required module not being converted from Android.mk
Liz Kammer620dea62021-04-14 17:36:10 -0400441 if m == nil {
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500442 ctx.AddMissingBp2buildDep(dep)
443 return &bazel.Label{
444 Label: ":" + dep + "__BP2BUILD__MISSING__DEP",
445 }
Liz Kammer620dea62021-04-14 17:36:10 -0400446 }
Liz Kammer6eff3232021-08-26 08:37:59 -0400447 if !convertedToBazel(ctx, m) {
448 ctx.AddUnconvertedBp2buildDep(dep)
449 }
Chris Parsons953b3562021-09-20 15:14:39 -0400450 label := BazelModuleLabel(ctx, ctx.Module())
451 otherLabel := labelFromModule(ctx, m)
452
453 // TODO(b/165114590): Convert tag (":name{.tag}") to corresponding Bazel implicit output targets.
Romain Jobredeaux9c06ef32023-08-21 18:05:29 -0400454 if tag != "" && m.Name() == "framework-res" {
455 otherLabel += tag
456 }
Chris Parsons953b3562021-09-20 15:14:39 -0400457
Liz Kammer620dea62021-04-14 17:36:10 -0400458 if samePackage(label, otherLabel) {
459 otherLabel = bazelShortLabel(otherLabel)
460 }
461
Liz Kammerdaa09ef2021-12-15 15:35:38 -0500462 return &bazel.Label{
Liz Kammer620dea62021-04-14 17:36:10 -0400463 Label: otherLabel,
464 }
465}
466
Jingwen Chen55bc8202021-11-02 06:40:51 +0000467func BazelModuleLabel(ctx BazelConversionPathContext, module blueprint.Module) string {
Liz Kammer620dea62021-04-14 17:36:10 -0400468 // TODO(b/165114590): Convert tag (":name{.tag}") to corresponding Bazel implicit output targets.
Spandan Das64852422023-08-02 21:58:41 +0000469 if !convertedToBazel(ctx, module) || isGoModule(module) {
Liz Kammer620dea62021-04-14 17:36:10 -0400470 return bp2buildModuleLabel(ctx, module)
471 }
Liz Kammer6eff3232021-08-26 08:37:59 -0400472 b, _ := module.(Bazelable)
Liz Kammer620dea62021-04-14 17:36:10 -0400473 return b.GetBazelLabel(ctx, module)
474}
475
476func bazelShortLabel(label string) string {
477 i := strings.Index(label, ":")
Jingwen Chen80b6b642021-11-02 06:23:07 +0000478 if i == -1 {
479 panic(fmt.Errorf("Could not find the ':' character in '%s', expected a fully qualified label.", label))
480 }
Liz Kammer620dea62021-04-14 17:36:10 -0400481 return label[i:]
482}
483
484func bazelPackage(label string) string {
485 i := strings.Index(label, ":")
Jingwen Chen80b6b642021-11-02 06:23:07 +0000486 if i == -1 {
487 panic(fmt.Errorf("Could not find the ':' character in '%s', expected a fully qualified label.", label))
488 }
Liz Kammer620dea62021-04-14 17:36:10 -0400489 return label[0:i]
490}
491
492func samePackage(label1, label2 string) bool {
493 return bazelPackage(label1) == bazelPackage(label2)
494}
495
Jingwen Chen55bc8202021-11-02 06:40:51 +0000496func bp2buildModuleLabel(ctx BazelConversionContext, module blueprint.Module) string {
Liz Kammerc86e0942023-08-11 16:15:12 -0400497 moduleName := moduleNameWithPossibleOverride(ctx, module, ctx.OtherModuleName(module))
498 moduleDir := moduleDirWithPossibleOverride(ctx, module, ctx.OtherModuleDir(module))
Jingwen Chen889f2f22022-12-16 08:16:01 +0000499 if moduleDir == Bp2BuildTopLevel {
500 moduleDir = ""
501 }
Liz Kammere1b39a52023-09-18 14:32:18 -0400502 if a, ok := module.(Module); ok && IsModulePrebuilt(a) {
503 moduleName = RemoveOptionalPrebuiltPrefix(moduleName)
504 }
Liz Kammer620dea62021-04-14 17:36:10 -0400505 return fmt.Sprintf("//%s:%s", moduleDir, moduleName)
506}
507
508// BazelOutPath is a Bazel output path compatible to be used for mixed builds within Soong/Ninja.
509type BazelOutPath struct {
510 OutputPath
511}
512
Liz Kammer0f3b7d22021-09-28 13:48:21 -0400513// ensure BazelOutPath implements Path
Liz Kammer620dea62021-04-14 17:36:10 -0400514var _ Path = BazelOutPath{}
Liz Kammer0f3b7d22021-09-28 13:48:21 -0400515
516// ensure BazelOutPath implements genPathProvider
517var _ genPathProvider = BazelOutPath{}
518
519// ensure BazelOutPath implements objPathProvider
Liz Kammer620dea62021-04-14 17:36:10 -0400520var _ objPathProvider = BazelOutPath{}
521
Liz Kammer0f3b7d22021-09-28 13:48:21 -0400522func (p BazelOutPath) genPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleGenPath {
523 return PathForModuleGen(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
524}
525
Liz Kammer620dea62021-04-14 17:36:10 -0400526func (p BazelOutPath) objPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleObjPath {
527 return PathForModuleObj(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
528}
529
Cole Faust9a06d252022-06-03 16:00:11 -0700530// PathForBazelOutRelative returns a BazelOutPath representing the path under an output directory dedicated to
531// bazel-owned outputs. Calling .Rel() on the result will give the input path as relative to the given
532// relativeRoot.
533func PathForBazelOutRelative(ctx PathContext, relativeRoot string, path string) BazelOutPath {
534 validatedPath, err := validatePath(filepath.Join("execroot", "__main__", path))
Liz Kammer620dea62021-04-14 17:36:10 -0400535 if err != nil {
536 reportPathError(ctx, err)
537 }
Cole Faust0abd4b42023-01-10 10:49:18 -0800538 var relativeRootPath string
539 if pathComponents := strings.SplitN(path, "/", 4); len(pathComponents) >= 3 &&
Cole Faust9a06d252022-06-03 16:00:11 -0700540 pathComponents[0] == "bazel-out" && pathComponents[2] == "bin" {
541 // If the path starts with something like: bazel-out/linux_x86_64-fastbuild-ST-b4ef1c4402f9/bin/
542 // make it relative to that folder. bazel-out/volatile-status.txt is an example
543 // of something that starts with bazel-out but is not relative to the bin folder
544 relativeRootPath = filepath.Join("execroot", "__main__", pathComponents[0], pathComponents[1], pathComponents[2], relativeRoot)
Cole Faust0abd4b42023-01-10 10:49:18 -0800545 } else {
546 relativeRootPath = filepath.Join("execroot", "__main__", relativeRoot)
Cole Faust9a06d252022-06-03 16:00:11 -0700547 }
Liz Kammer620dea62021-04-14 17:36:10 -0400548
Cole Faust9a06d252022-06-03 16:00:11 -0700549 var relPath string
550 if relPath, err = filepath.Rel(relativeRootPath, validatedPath); err != nil || strings.HasPrefix(relPath, "../") {
551 // We failed to make this path relative to execroot/__main__, fall back to a non-relative path
552 // One case where this happens is when path is ../bazel_tools/something
553 relativeRootPath = ""
554 relPath = validatedPath
555 }
556
557 outputPath := OutputPath{
558 basePath{"", ""},
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200559 ctx.Config().soongOutDir,
Cole Faust9a06d252022-06-03 16:00:11 -0700560 ctx.Config().BazelContext.OutputBase(),
561 }
Liz Kammer620dea62021-04-14 17:36:10 -0400562
563 return BazelOutPath{
Cole Faust9a06d252022-06-03 16:00:11 -0700564 // .withRel() appends its argument onto the current path, and only the most
565 // recently appended part is returned by outputPath.rel().
566 // So outputPath.rel() will return relPath.
567 OutputPath: outputPath.withRel(relativeRootPath).withRel(relPath),
Liz Kammer620dea62021-04-14 17:36:10 -0400568 }
569}
Liz Kammerb6a55bf2021-04-12 15:42:51 -0400570
Cole Faust9a06d252022-06-03 16:00:11 -0700571// PathForBazelOut returns a BazelOutPath representing the path under an output directory dedicated to
572// bazel-owned outputs.
573func PathForBazelOut(ctx PathContext, path string) BazelOutPath {
574 return PathForBazelOutRelative(ctx, "", path)
575}
576
Liz Kammerb6a55bf2021-04-12 15:42:51 -0400577// PathsForBazelOut returns a list of paths representing the paths under an output directory
578// dedicated to Bazel-owned outputs.
579func PathsForBazelOut(ctx PathContext, paths []string) Paths {
580 outs := make(Paths, 0, len(paths))
581 for _, p := range paths {
582 outs = append(outs, PathForBazelOut(ctx, p))
583 }
584 return outs
585}
Jingwen Chen6817bbb2022-10-14 09:56:07 +0000586
587// BazelStringOrLabelFromProp splits a Soong module property that can be
588// either a string literal, path (with android:path tag) or a module reference
589// into separate bazel string or label attributes. Bazel treats string and label
590// attributes as distinct types, so this function categorizes a string property
591// into either one of them.
592//
593// e.g. apex.private_key = "foo.pem" can either refer to:
594//
595// 1. "foo.pem" in the current directory -> file target
596// 2. "foo.pem" module -> rule target
597// 3. "foo.pem" file in a different directory, prefixed by a product variable handled
598// in a bazel macro. -> string literal
599//
600// For the first two cases, they are defined using the label attribute. For the third case,
601// it's defined with the string attribute.
602func BazelStringOrLabelFromProp(
Chris Parsons637458d2023-09-19 20:09:00 +0000603 ctx Bp2buildMutatorContext,
Jingwen Chen6817bbb2022-10-14 09:56:07 +0000604 propToDistinguish *string) (bazel.LabelAttribute, bazel.StringAttribute) {
605
606 var labelAttr bazel.LabelAttribute
607 var strAttr bazel.StringAttribute
608
609 if propToDistinguish == nil {
610 // nil pointer
611 return labelAttr, strAttr
612 }
613
614 prop := String(propToDistinguish)
615 if SrcIsModule(prop) != "" {
616 // If it's a module (SrcIsModule will return the module name), set the
617 // resolved label to the label attribute.
618 labelAttr.SetValue(BazelLabelForModuleDepSingle(ctx, prop))
619 } else {
620 // Not a module name. This could be a string literal or a file target in
621 // the current dir. Check if the path exists:
622 path := ExistentPathForSource(ctx, ctx.ModuleDir(), prop)
623
624 if path.Valid() && parentDir(path.String()) == ctx.ModuleDir() {
625 // If it exists and the path is relative to the current dir, resolve the bazel label
626 // for the _file target_ and set it to the label attribute.
627 //
628 // Resolution is necessary because this could be a file in a subpackage.
629 labelAttr.SetValue(BazelLabelForModuleSrcSingle(ctx, prop))
630 } else {
631 // Otherwise, treat it as a string literal and assign to the string attribute.
632 strAttr.Value = propToDistinguish
633 }
634 }
635
636 return labelAttr, strAttr
637}