| // Copyright 2020 The Android Open Source Project |
| // |
| // 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 config |
| |
| import ( |
| "strings" |
| |
| "android/soong/android" |
| ) |
| |
| // Overarching principles for Rust lints on Android: |
| // The Android build system tries to avoid reporting warnings during the build. |
| // Therefore, by default, we upgrade warnings to denials. For some of these |
| // lints, an allow exception is setup, using the variables below. |
| // There are different default lints depending on the repository location (see |
| // DefaultLocalClippyChecks). |
| // The lints are split into two categories. The first one contains the built-in |
| // lints (https://doc.rust-lang.org/rustc/lints/index.html). The second is |
| // specific to Clippy lints (https://rust-lang.github.io/rust-clippy/master/). |
| // |
| // When developing a module, it is possible to use the `no_lint` property to |
| // disable the built-in lints configuration. It is also possible to set |
| // `clippy` to false to disable the clippy verification. Expect some |
| // questioning during review if you enable one of these options. For external/ |
| // code, if you need to use them, it is likely a bug. Otherwise, it may be |
| // useful to add an exception (that is, move a lint from deny to allow). |
| var ( |
| // Default Rust lints that applies to Google-authored modules. |
| defaultRustcLints = []string{ |
| "-A deprecated", |
| "-D missing-docs", |
| "-D warnings", |
| } |
| // Default Clippy lints. These are applied on top of defaultRustcLints. |
| // It should be assumed that any warning lint will be promoted to a |
| // deny. |
| defaultClippyLints = []string{ |
| "-A clippy::type-complexity", |
| } |
| |
| // Rust lints for vendor code. |
| defaultRustcVendorLints = []string{ |
| "-A deprecated", |
| "-D warnings", |
| } |
| // Clippy lints for vendor source. These are applied on top of |
| // defaultRustcVendorLints. It should be assumed that any warning lint |
| // will be promoted to a deny. |
| defaultClippyVendorLints = []string{ |
| "-A clippy::complexity", |
| "-A clippy::perf", |
| "-A clippy::style", |
| } |
| |
| // For prebuilts/ and external/, no linting is expected. If a warning |
| // or a deny is reported, it should be fixed upstream. |
| allowAllLints = []string{ |
| "--cap-lints allow", |
| } |
| ) |
| |
| func init() { |
| // Default Rust lints. These apply to all Google-authored modules. |
| pctx.VariableFunc("RustDefaultLints", func(ctx android.PackageVarContext) string { |
| if override := ctx.Config().Getenv("RUST_DEFAULT_LINTS"); override != "" { |
| return override |
| } |
| return strings.Join(defaultRustcLints, " ") |
| }) |
| pctx.VariableFunc("ClippyDefaultLints", func(ctx android.PackageVarContext) string { |
| if override := ctx.Config().Getenv("CLIPPY_DEFAULT_LINTS"); override != "" { |
| return override |
| } |
| return strings.Join(defaultClippyLints, " ") |
| }) |
| |
| // Rust lints that only applies to external code. |
| pctx.VariableFunc("RustVendorLints", func(ctx android.PackageVarContext) string { |
| if override := ctx.Config().Getenv("RUST_VENDOR_LINTS"); override != "" { |
| return override |
| } |
| return strings.Join(defaultRustcVendorLints, " ") |
| }) |
| pctx.VariableFunc("ClippyVendorLints", func(ctx android.PackageVarContext) string { |
| if override := ctx.Config().Getenv("CLIPPY_VENDOR_LINTS"); override != "" { |
| return override |
| } |
| return strings.Join(defaultClippyVendorLints, " ") |
| }) |
| pctx.StaticVariable("RustAllowAllLints", strings.Join(allowAllLints, " ")) |
| } |
| |
| type PathBasedClippyConfig struct { |
| PathPrefix string |
| RustcConfig string |
| ClippyEnabled bool |
| ClippyConfig string |
| } |
| |
| const noLint = "" |
| const rustcDefault = "${config.RustDefaultLints}" |
| const rustcVendor = "${config.RustVendorLints}" |
| const rustcAllowAll = "${config.RustAllowAllLints}" |
| const clippyDefault = "${config.ClippyDefaultLints}" |
| const clippyVendor = "${config.ClippyVendorLints}" |
| |
| // This is a map of local path prefixes to a set of parameters for the linting: |
| // - a string for the lints to apply to rustc. |
| // - a boolean to indicate if clippy should be executed. |
| // - a string for the lints to apply to clippy. |
| // The first entry matching will be used. |
| var DefaultLocalClippyChecks = []PathBasedClippyConfig{ |
| {"external/", rustcAllowAll, false, noLint}, |
| {"hardware/", rustcVendor, true, clippyVendor}, |
| {"prebuilts/", rustcAllowAll, false, noLint}, |
| {"vendor/google", rustcDefault, true, clippyDefault}, |
| {"vendor/", rustcVendor, true, clippyVendor}, |
| } |
| |
| // ClippyLintsForDir returns a boolean if Clippy should be executed and if so, the lints to be used. |
| func ClippyLintsForDir(dir string) (bool, string) { |
| for _, pathCheck := range DefaultLocalClippyChecks { |
| if strings.HasPrefix(dir, pathCheck.PathPrefix) { |
| return pathCheck.ClippyEnabled, pathCheck.ClippyConfig |
| } |
| } |
| return true, clippyDefault |
| } |
| |
| // RustcLintsForDir returns the standard lints to be used for a repository. |
| func RustcLintsForDir(dir string) string { |
| for _, pathCheck := range DefaultLocalClippyChecks { |
| if strings.HasPrefix(dir, pathCheck.PathPrefix) { |
| return pathCheck.RustcConfig |
| } |
| } |
| return rustcDefault |
| } |