// Copyright 2020 Google Inc. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package rust import ( "encoding/json" "fmt" "path" "android/soong/android" ) // This singleton collects Rust crate definitions and generates a JSON file // (${OUT_DIR}/soong/rust-project.json) which can be use by external tools, // such as rust-analyzer. It does so when either make, mm, mma, mmm or mmma is // called. This singleton is enabled only if SOONG_GEN_RUST_PROJECT is set. // For example, // // $ SOONG_GEN_RUST_PROJECT=1 m nothing const ( // Environment variables used to control the behavior of this singleton. envVariableCollectRustDeps = "SOONG_GEN_RUST_PROJECT" rustProjectJsonFileName = "rust-project.json" ) // The format of rust-project.json is not yet finalized. A current description is available at: // https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/manual.adoc#non-cargo-based-projects type rustProjectDep struct { // The Crate attribute is the index of the dependency in the Crates array in rustProjectJson. Crate int `json:"crate"` Name string `json:"name"` } type rustProjectCrate struct { DisplayName string `json:"display_name"` RootModule string `json:"root_module"` Edition string `json:"edition,omitempty"` Deps []rustProjectDep `json:"deps"` Cfg []string `json:"cfg"` Env map[string]string `json:"env"` ProcMacro bool `json:"is_proc_macro"` } type rustProjectJson struct { Crates []rustProjectCrate `json:"crates"` } // crateInfo is used during the processing to keep track of the known crates. type crateInfo struct { Idx int // Index of the crate in rustProjectJson.Crates slice. Deps map[string]int // The keys are the module names and not the crate names. } type projectGeneratorSingleton struct { project rustProjectJson knownCrates map[string]crateInfo // Keys are module names. } func rustProjectGeneratorSingleton() android.Singleton { return &projectGeneratorSingleton{} } func init() { android.RegisterParallelSingletonType("rust_project_generator", rustProjectGeneratorSingleton) } // sourceProviderVariantSource returns the path to the source file if this // module variant should be used as a priority. // // SourceProvider modules may have multiple variants considered as source // (e.g., x86_64 and armv8). For a module available on device, use the source // generated for the target. For a host-only module, use the source generated // for the host. func sourceProviderVariantSource(ctx android.SingletonContext, rModule *Module) (string, bool) { rustLib, ok := rModule.compiler.(*libraryDecorator) if !ok { return "", false } if rustLib.source() { switch rModule.hod { case android.HostSupported, android.HostSupportedNoCross: if rModule.Target().String() == ctx.Config().BuildOSTarget.String() { src := rustLib.sourceProvider.Srcs()[0] return src.String(), true } default: if rModule.Target().String() == ctx.Config().AndroidFirstDeviceTarget.String() { src := rustLib.sourceProvider.Srcs()[0] return src.String(), true } } } return "", false } // sourceProviderSource finds the main source file of a source-provider crate. func sourceProviderSource(ctx android.SingletonContext, rModule *Module) (string, bool) { rustLib, ok := rModule.compiler.(*libraryDecorator) if !ok { return "", false } if rustLib.source() { // This is a source-variant, check if we are the right variant // depending on the module configuration. if src, ok := sourceProviderVariantSource(ctx, rModule); ok { return src, true } } foundSource := false sourceSrc := "" // Find the variant with the source and return its. ctx.VisitAllModuleVariants(rModule, func(variant android.Module) { if foundSource { return } // All variants of a source provider library are libraries. rVariant, _ := variant.(*Module) variantLib, _ := rVariant.compiler.(*libraryDecorator) if variantLib.source() { sourceSrc, ok = sourceProviderVariantSource(ctx, rVariant) if ok { foundSource = true } } }) if !foundSource { ctx.Errorf("No valid source for source provider found: %v\n", rModule) } return sourceSrc, foundSource } // crateSource finds the main source file (.rs) for a crate. func crateSource(ctx android.SingletonContext, rModule *Module, comp *baseCompiler) (string, bool) { // Basic libraries, executables and tests. srcs := comp.Properties.Srcs if len(srcs) != 0 { return path.Join(ctx.ModuleDir(rModule), srcs[0]), true } // SourceProvider libraries. if rModule.sourceProvider != nil { return sourceProviderSource(ctx, rModule) } return "", false } // mergeDependencies visits all the dependencies for module and updates crate and deps // with any new dependency. func (singleton *projectGeneratorSingleton) mergeDependencies(ctx android.SingletonContext, module *Module, crate *rustProjectCrate, deps map[string]int) { ctx.VisitDirectDeps(module, func(child android.Module) { // Skip intra-module dependencies (i.e., generated-source library depending on the source variant). if module.Name() == child.Name() { return } // Skip unsupported modules. rChild, compChild, ok := isModuleSupported(ctx, child) if !ok { return } // For unknown dependency, add it first. var childId int cInfo, known := singleton.knownCrates[rChild.Name()] if !known { childId, ok = singleton.addCrate(ctx, rChild, compChild) if !ok { return } } else { childId = cInfo.Idx } // Is this dependency known already? if _, ok = deps[child.Name()]; ok { return } crate.Deps = append(crate.Deps, rustProjectDep{Crate: childId, Name: rChild.CrateName()}) deps[child.Name()] = childId }) } // isModuleSupported returns the RustModule and baseCompiler if the module // should be considered for inclusion in rust-project.json. func isModuleSupported(ctx android.SingletonContext, module android.Module) (*Module, *baseCompiler, bool) { rModule, ok := module.(*Module) if !ok { return nil, nil, false } if rModule.compiler == nil { return nil, nil, false } var comp *baseCompiler switch c := rModule.compiler.(type) { case *libraryDecorator: comp = c.baseCompiler case *binaryDecorator: comp = c.baseCompiler case *testDecorator: comp = c.binaryDecorator.baseCompiler case *procMacroDecorator: comp = c.baseCompiler case *toolchainLibraryDecorator: comp = c.baseCompiler default: return nil, nil, false } return rModule, comp, true } // addCrate adds a crate to singleton.project.Crates ensuring that required // dependencies are also added. It returns the index of the new crate in // singleton.project.Crates func (singleton *projectGeneratorSingleton) addCrate(ctx android.SingletonContext, rModule *Module, comp *baseCompiler) (int, bool) { rootModule, ok := crateSource(ctx, rModule, comp) if !ok { ctx.Errorf("Unable to find source for valid module: %v", rModule) return 0, false } _, procMacro := rModule.compiler.(*procMacroDecorator) crate := rustProjectCrate{ DisplayName: rModule.Name(), RootModule: rootModule, Edition: comp.edition(), Deps: make([]rustProjectDep, 0), Cfg: make([]string, 0), Env: make(map[string]string), ProcMacro: procMacro, } if comp.CargoOutDir().Valid() { crate.Env["OUT_DIR"] = comp.CargoOutDir().String() } for _, feature := range comp.Properties.Features { crate.Cfg = append(crate.Cfg, "feature=\""+feature+"\"") } deps := make(map[string]int) singleton.mergeDependencies(ctx, rModule, &crate, deps) idx := len(singleton.project.Crates) singleton.knownCrates[rModule.Name()] = crateInfo{Idx: idx, Deps: deps} singleton.project.Crates = append(singleton.project.Crates, crate) return idx, true } // appendCrateAndDependencies creates a rustProjectCrate for the module argument and appends it to singleton.project. // It visits the dependencies of the module depth-first so the dependency ID can be added to the current module. If the // current module is already in singleton.knownCrates, its dependencies are merged. func (singleton *projectGeneratorSingleton) appendCrateAndDependencies(ctx android.SingletonContext, module android.Module) { rModule, comp, ok := isModuleSupported(ctx, module) if !ok { return } // If we have seen this crate already; merge any new dependencies. if cInfo, ok := singleton.knownCrates[module.Name()]; ok { crate := singleton.project.Crates[cInfo.Idx] singleton.mergeDependencies(ctx, rModule, &crate, cInfo.Deps) singleton.project.Crates[cInfo.Idx] = crate return } singleton.addCrate(ctx, rModule, comp) } func (singleton *projectGeneratorSingleton) GenerateBuildActions(ctx android.SingletonContext) { if !ctx.Config().IsEnvTrue(envVariableCollectRustDeps) { return } singleton.knownCrates = make(map[string]crateInfo) ctx.VisitAllModules(func(module android.Module) { singleton.appendCrateAndDependencies(ctx, module) }) path := android.PathForOutput(ctx, rustProjectJsonFileName) err := createJsonFile(singleton.project, path) if err != nil { ctx.Errorf(err.Error()) } } func createJsonFile(project rustProjectJson, rustProjectPath android.WritablePath) error { buf, err := json.MarshalIndent(project, "", " ") if err != nil { return fmt.Errorf("JSON marshal of rustProjectJson failed: %s", err) } err = android.WriteFileToOutputDir(rustProjectPath, buf, 0666) if err != nil { return fmt.Errorf("Writing rust-project to %s failed: %s", rustProjectPath.String(), err) } return nil }