From 7b4377ad9d8a7205416df8d6217ef2b010f89481 Mon Sep 17 00:00:00 2001 From: Taras Madan Date: Wed, 22 Jan 2025 16:07:17 +0100 Subject: vendor: delete --- vendor/github.com/mgechev/revive/LICENSE | 21 - vendor/github.com/mgechev/revive/config/config.go | 262 ------------- .../mgechev/revive/formatter/checkstyle.go | 77 ---- .../github.com/mgechev/revive/formatter/default.go | 28 -- vendor/github.com/mgechev/revive/formatter/doc.go | 2 - .../mgechev/revive/formatter/friendly.go | 141 ------- vendor/github.com/mgechev/revive/formatter/json.go | 40 -- .../github.com/mgechev/revive/formatter/ndjson.go | 35 -- .../github.com/mgechev/revive/formatter/plain.go | 28 -- .../github.com/mgechev/revive/formatter/sarif.go | 107 ----- .../mgechev/revive/formatter/severity.go | 13 - .../github.com/mgechev/revive/formatter/stylish.go | 89 ----- vendor/github.com/mgechev/revive/formatter/unix.go | 30 -- .../mgechev/revive/internal/ifelse/args.go | 11 - .../mgechev/revive/internal/ifelse/branch.go | 93 ----- .../mgechev/revive/internal/ifelse/branch_kind.go | 101 ----- .../mgechev/revive/internal/ifelse/chain.go | 10 - .../mgechev/revive/internal/ifelse/doc.go | 6 - .../mgechev/revive/internal/ifelse/func.go | 51 --- .../mgechev/revive/internal/ifelse/rule.go | 105 ----- .../mgechev/revive/internal/ifelse/target.go | 25 -- .../revive/internal/typeparams/typeparams.go | 29 -- .../revive/internal/typeparams/typeparams_go117.go | 12 - .../revive/internal/typeparams/typeparams_go118.go | 20 - vendor/github.com/mgechev/revive/lint/config.go | 71 ---- vendor/github.com/mgechev/revive/lint/doc.go | 2 - vendor/github.com/mgechev/revive/lint/failure.go | 39 -- vendor/github.com/mgechev/revive/lint/file.go | 280 ------------- .../github.com/mgechev/revive/lint/filefilter.go | 128 ------ vendor/github.com/mgechev/revive/lint/formatter.go | 14 - vendor/github.com/mgechev/revive/lint/linter.go | 257 ------------ vendor/github.com/mgechev/revive/lint/name.go | 133 ------- vendor/github.com/mgechev/revive/lint/package.go | 206 ---------- vendor/github.com/mgechev/revive/lint/rule.go | 31 -- .../github.com/mgechev/revive/rule/add_constant.go | 267 ------------- .../mgechev/revive/rule/argument_limit.go | 84 ---- vendor/github.com/mgechev/revive/rule/atomic.go | 94 ----- .../mgechev/revive/rule/banned_characters.go | 89 ----- .../github.com/mgechev/revive/rule/bare_return.go | 84 ---- .../mgechev/revive/rule/blank_imports.go | 75 ---- .../mgechev/revive/rule/bool_literal_in_expr.go | 72 ---- .../github.com/mgechev/revive/rule/call_to_gc.go | 70 ---- .../mgechev/revive/rule/cognitive_complexity.go | 209 ---------- .../mgechev/revive/rule/comment_spacings.go | 82 ---- .../mgechev/revive/rule/comments_density.go | 87 ----- .../mgechev/revive/rule/confusing_naming.go | 207 ---------- .../mgechev/revive/rule/confusing_results.go | 66 ---- .../mgechev/revive/rule/constant_logical_expr.go | 101 ----- .../mgechev/revive/rule/context_as_argument.go | 109 ------ .../mgechev/revive/rule/context_keys_type.go | 81 ---- .../github.com/mgechev/revive/rule/cyclomatic.go | 137 ------- vendor/github.com/mgechev/revive/rule/datarace.go | 144 ------- vendor/github.com/mgechev/revive/rule/deep_exit.go | 95 ----- vendor/github.com/mgechev/revive/rule/defer.go | 174 --------- vendor/github.com/mgechev/revive/rule/doc.go | 2 - .../github.com/mgechev/revive/rule/dot_imports.go | 101 ----- .../mgechev/revive/rule/duplicated_imports.go | 39 -- .../github.com/mgechev/revive/rule/early_return.go | 51 --- .../github.com/mgechev/revive/rule/empty_block.go | 75 ---- .../github.com/mgechev/revive/rule/empty_lines.go | 105 ----- .../mgechev/revive/rule/enforce_map_style.go | 155 -------- .../revive/rule/enforce_repeated_arg_type_style.go | 178 --------- .../mgechev/revive/rule/enforce_slice_style.go | 205 ---------- .../github.com/mgechev/revive/rule/error_naming.go | 79 ---- .../github.com/mgechev/revive/rule/error_return.go | 67 ---- .../mgechev/revive/rule/error_strings.go | 193 --------- vendor/github.com/mgechev/revive/rule/errorf.go | 93 ----- vendor/github.com/mgechev/revive/rule/exported.go | 435 --------------------- .../github.com/mgechev/revive/rule/file_header.go | 84 ---- .../mgechev/revive/rule/file_length_limit.go | 132 ------- .../mgechev/revive/rule/filename_format.go | 81 ---- .../github.com/mgechev/revive/rule/flag_param.go | 105 ----- .../mgechev/revive/rule/function_length.go | 174 --------- .../mgechev/revive/rule/function_result_limit.go | 85 ---- .../github.com/mgechev/revive/rule/get_return.go | 80 ---- .../mgechev/revive/rule/identical_branches.go | 87 ----- vendor/github.com/mgechev/revive/rule/if_return.go | 115 ------ .../mgechev/revive/rule/import_alias_naming.go | 120 ------ .../mgechev/revive/rule/import_shadowing.go | 115 ------ .../mgechev/revive/rule/imports_blocklist.go | 68 ---- .../mgechev/revive/rule/increment_decrement.go | 73 ---- .../mgechev/revive/rule/indent_error_flow.go | 45 --- .../mgechev/revive/rule/line_length_limit.go | 99 ----- .../mgechev/revive/rule/max_control_nesting.go | 123 ------ .../mgechev/revive/rule/max_public_structs.go | 90 ----- .../mgechev/revive/rule/modifies_param.go | 80 ---- .../mgechev/revive/rule/modifies_value_receiver.go | 179 --------- .../mgechev/revive/rule/nested_structs.go | 75 ---- .../mgechev/revive/rule/optimize_operands_order.go | 86 ---- .../mgechev/revive/rule/package_comments.go | 164 -------- vendor/github.com/mgechev/revive/rule/range.go | 82 ---- .../mgechev/revive/rule/range_val_address.go | 166 -------- .../mgechev/revive/rule/range_val_in_closure.go | 125 ------ .../mgechev/revive/rule/receiver_naming.go | 128 ------ .../mgechev/revive/rule/redefines_builtin_id.go | 224 ----------- .../mgechev/revive/rule/redundant_import_alias.go | 52 --- .../mgechev/revive/rule/string_format.go | 328 ---------------- .../mgechev/revive/rule/string_of_int.go | 95 ----- .../github.com/mgechev/revive/rule/struct_tag.go | 424 -------------------- .../mgechev/revive/rule/superfluous_else.go | 47 --- .../github.com/mgechev/revive/rule/time_equal.go | 73 ---- .../github.com/mgechev/revive/rule/time_naming.go | 96 ----- .../revive/rule/unchecked_type_assertion.go | 189 --------- .../mgechev/revive/rule/unconditional_recursion.go | 200 ---------- .../mgechev/revive/rule/unexported_naming.go | 115 ------ .../mgechev/revive/rule/unexported_return.go | 107 ----- .../mgechev/revive/rule/unhandled_error.go | 175 --------- .../mgechev/revive/rule/unnecessary_stmt.go | 107 ----- .../mgechev/revive/rule/unreachable_code.go | 122 ------ .../github.com/mgechev/revive/rule/unused_param.go | 159 -------- .../mgechev/revive/rule/unused_receiver.go | 125 ------ vendor/github.com/mgechev/revive/rule/use_any.go | 54 --- .../mgechev/revive/rule/useless_break.go | 82 ---- vendor/github.com/mgechev/revive/rule/utils.go | 173 -------- .../mgechev/revive/rule/var_declarations.go | 122 ------ .../github.com/mgechev/revive/rule/var_naming.go | 273 ------------- .../mgechev/revive/rule/waitgroup_by_value.go | 66 ---- 117 files changed, 12771 deletions(-) delete mode 100644 vendor/github.com/mgechev/revive/LICENSE delete mode 100644 vendor/github.com/mgechev/revive/config/config.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/checkstyle.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/default.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/doc.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/friendly.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/json.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/ndjson.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/plain.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/sarif.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/severity.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/stylish.go delete mode 100644 vendor/github.com/mgechev/revive/formatter/unix.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/args.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/branch.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/branch_kind.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/chain.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/doc.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/func.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/rule.go delete mode 100644 vendor/github.com/mgechev/revive/internal/ifelse/target.go delete mode 100644 vendor/github.com/mgechev/revive/internal/typeparams/typeparams.go delete mode 100644 vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go117.go delete mode 100644 vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go118.go delete mode 100644 vendor/github.com/mgechev/revive/lint/config.go delete mode 100644 vendor/github.com/mgechev/revive/lint/doc.go delete mode 100644 vendor/github.com/mgechev/revive/lint/failure.go delete mode 100644 vendor/github.com/mgechev/revive/lint/file.go delete mode 100644 vendor/github.com/mgechev/revive/lint/filefilter.go delete mode 100644 vendor/github.com/mgechev/revive/lint/formatter.go delete mode 100644 vendor/github.com/mgechev/revive/lint/linter.go delete mode 100644 vendor/github.com/mgechev/revive/lint/name.go delete mode 100644 vendor/github.com/mgechev/revive/lint/package.go delete mode 100644 vendor/github.com/mgechev/revive/lint/rule.go delete mode 100644 vendor/github.com/mgechev/revive/rule/add_constant.go delete mode 100644 vendor/github.com/mgechev/revive/rule/argument_limit.go delete mode 100644 vendor/github.com/mgechev/revive/rule/atomic.go delete mode 100644 vendor/github.com/mgechev/revive/rule/banned_characters.go delete mode 100644 vendor/github.com/mgechev/revive/rule/bare_return.go delete mode 100644 vendor/github.com/mgechev/revive/rule/blank_imports.go delete mode 100644 vendor/github.com/mgechev/revive/rule/bool_literal_in_expr.go delete mode 100644 vendor/github.com/mgechev/revive/rule/call_to_gc.go delete mode 100644 vendor/github.com/mgechev/revive/rule/cognitive_complexity.go delete mode 100644 vendor/github.com/mgechev/revive/rule/comment_spacings.go delete mode 100644 vendor/github.com/mgechev/revive/rule/comments_density.go delete mode 100644 vendor/github.com/mgechev/revive/rule/confusing_naming.go delete mode 100644 vendor/github.com/mgechev/revive/rule/confusing_results.go delete mode 100644 vendor/github.com/mgechev/revive/rule/constant_logical_expr.go delete mode 100644 vendor/github.com/mgechev/revive/rule/context_as_argument.go delete mode 100644 vendor/github.com/mgechev/revive/rule/context_keys_type.go delete mode 100644 vendor/github.com/mgechev/revive/rule/cyclomatic.go delete mode 100644 vendor/github.com/mgechev/revive/rule/datarace.go delete mode 100644 vendor/github.com/mgechev/revive/rule/deep_exit.go delete mode 100644 vendor/github.com/mgechev/revive/rule/defer.go delete mode 100644 vendor/github.com/mgechev/revive/rule/doc.go delete mode 100644 vendor/github.com/mgechev/revive/rule/dot_imports.go delete mode 100644 vendor/github.com/mgechev/revive/rule/duplicated_imports.go delete mode 100644 vendor/github.com/mgechev/revive/rule/early_return.go delete mode 100644 vendor/github.com/mgechev/revive/rule/empty_block.go delete mode 100644 vendor/github.com/mgechev/revive/rule/empty_lines.go delete mode 100644 vendor/github.com/mgechev/revive/rule/enforce_map_style.go delete mode 100644 vendor/github.com/mgechev/revive/rule/enforce_repeated_arg_type_style.go delete mode 100644 vendor/github.com/mgechev/revive/rule/enforce_slice_style.go delete mode 100644 vendor/github.com/mgechev/revive/rule/error_naming.go delete mode 100644 vendor/github.com/mgechev/revive/rule/error_return.go delete mode 100644 vendor/github.com/mgechev/revive/rule/error_strings.go delete mode 100644 vendor/github.com/mgechev/revive/rule/errorf.go delete mode 100644 vendor/github.com/mgechev/revive/rule/exported.go delete mode 100644 vendor/github.com/mgechev/revive/rule/file_header.go delete mode 100644 vendor/github.com/mgechev/revive/rule/file_length_limit.go delete mode 100644 vendor/github.com/mgechev/revive/rule/filename_format.go delete mode 100644 vendor/github.com/mgechev/revive/rule/flag_param.go delete mode 100644 vendor/github.com/mgechev/revive/rule/function_length.go delete mode 100644 vendor/github.com/mgechev/revive/rule/function_result_limit.go delete mode 100644 vendor/github.com/mgechev/revive/rule/get_return.go delete mode 100644 vendor/github.com/mgechev/revive/rule/identical_branches.go delete mode 100644 vendor/github.com/mgechev/revive/rule/if_return.go delete mode 100644 vendor/github.com/mgechev/revive/rule/import_alias_naming.go delete mode 100644 vendor/github.com/mgechev/revive/rule/import_shadowing.go delete mode 100644 vendor/github.com/mgechev/revive/rule/imports_blocklist.go delete mode 100644 vendor/github.com/mgechev/revive/rule/increment_decrement.go delete mode 100644 vendor/github.com/mgechev/revive/rule/indent_error_flow.go delete mode 100644 vendor/github.com/mgechev/revive/rule/line_length_limit.go delete mode 100644 vendor/github.com/mgechev/revive/rule/max_control_nesting.go delete mode 100644 vendor/github.com/mgechev/revive/rule/max_public_structs.go delete mode 100644 vendor/github.com/mgechev/revive/rule/modifies_param.go delete mode 100644 vendor/github.com/mgechev/revive/rule/modifies_value_receiver.go delete mode 100644 vendor/github.com/mgechev/revive/rule/nested_structs.go delete mode 100644 vendor/github.com/mgechev/revive/rule/optimize_operands_order.go delete mode 100644 vendor/github.com/mgechev/revive/rule/package_comments.go delete mode 100644 vendor/github.com/mgechev/revive/rule/range.go delete mode 100644 vendor/github.com/mgechev/revive/rule/range_val_address.go delete mode 100644 vendor/github.com/mgechev/revive/rule/range_val_in_closure.go delete mode 100644 vendor/github.com/mgechev/revive/rule/receiver_naming.go delete mode 100644 vendor/github.com/mgechev/revive/rule/redefines_builtin_id.go delete mode 100644 vendor/github.com/mgechev/revive/rule/redundant_import_alias.go delete mode 100644 vendor/github.com/mgechev/revive/rule/string_format.go delete mode 100644 vendor/github.com/mgechev/revive/rule/string_of_int.go delete mode 100644 vendor/github.com/mgechev/revive/rule/struct_tag.go delete mode 100644 vendor/github.com/mgechev/revive/rule/superfluous_else.go delete mode 100644 vendor/github.com/mgechev/revive/rule/time_equal.go delete mode 100644 vendor/github.com/mgechev/revive/rule/time_naming.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unchecked_type_assertion.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unconditional_recursion.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unexported_naming.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unexported_return.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unhandled_error.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unnecessary_stmt.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unreachable_code.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unused_param.go delete mode 100644 vendor/github.com/mgechev/revive/rule/unused_receiver.go delete mode 100644 vendor/github.com/mgechev/revive/rule/use_any.go delete mode 100644 vendor/github.com/mgechev/revive/rule/useless_break.go delete mode 100644 vendor/github.com/mgechev/revive/rule/utils.go delete mode 100644 vendor/github.com/mgechev/revive/rule/var_declarations.go delete mode 100644 vendor/github.com/mgechev/revive/rule/var_naming.go delete mode 100644 vendor/github.com/mgechev/revive/rule/waitgroup_by_value.go (limited to 'vendor/github.com/mgechev') diff --git a/vendor/github.com/mgechev/revive/LICENSE b/vendor/github.com/mgechev/revive/LICENSE deleted file mode 100644 index c617c7e01..000000000 --- a/vendor/github.com/mgechev/revive/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2018 Minko Gechev - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/vendor/github.com/mgechev/revive/config/config.go b/vendor/github.com/mgechev/revive/config/config.go deleted file mode 100644 index 16559f5ec..000000000 --- a/vendor/github.com/mgechev/revive/config/config.go +++ /dev/null @@ -1,262 +0,0 @@ -// Package config implements revive's configuration data structures and related methods -package config - -import ( - "errors" - "fmt" - "os" - - "github.com/BurntSushi/toml" - - "github.com/mgechev/revive/formatter" - "github.com/mgechev/revive/lint" - "github.com/mgechev/revive/rule" -) - -var defaultRules = []lint.Rule{ - &rule.VarDeclarationsRule{}, - &rule.PackageCommentsRule{}, - &rule.DotImportsRule{}, - &rule.BlankImportsRule{}, - &rule.ExportedRule{}, - &rule.VarNamingRule{}, - &rule.IndentErrorFlowRule{}, - &rule.RangeRule{}, - &rule.ErrorfRule{}, - &rule.ErrorNamingRule{}, - &rule.ErrorStringsRule{}, - &rule.ReceiverNamingRule{}, - &rule.IncrementDecrementRule{}, - &rule.ErrorReturnRule{}, - &rule.UnexportedReturnRule{}, - &rule.TimeNamingRule{}, - &rule.ContextKeysType{}, - &rule.ContextAsArgumentRule{}, - &rule.EmptyBlockRule{}, - &rule.SuperfluousElseRule{}, - &rule.UnusedParamRule{}, - &rule.UnreachableCodeRule{}, - &rule.RedefinesBuiltinIDRule{}, -} - -var allRules = append([]lint.Rule{ - &rule.ArgumentsLimitRule{}, - &rule.CyclomaticRule{}, - &rule.FileHeaderRule{}, - &rule.ConfusingNamingRule{}, - &rule.GetReturnRule{}, - &rule.ModifiesParamRule{}, - &rule.ConfusingResultsRule{}, - &rule.DeepExitRule{}, - &rule.AddConstantRule{}, - &rule.FlagParamRule{}, - &rule.UnnecessaryStmtRule{}, - &rule.StructTagRule{}, - &rule.ModifiesValRecRule{}, - &rule.ConstantLogicalExprRule{}, - &rule.BoolLiteralRule{}, - &rule.ImportsBlocklistRule{}, - &rule.FunctionResultsLimitRule{}, - &rule.MaxPublicStructsRule{}, - &rule.RangeValInClosureRule{}, - &rule.RangeValAddress{}, - &rule.WaitGroupByValueRule{}, - &rule.AtomicRule{}, - &rule.EmptyLinesRule{}, - &rule.LineLengthLimitRule{}, - &rule.CallToGCRule{}, - &rule.DuplicatedImportsRule{}, - &rule.ImportShadowingRule{}, - &rule.BareReturnRule{}, - &rule.UnusedReceiverRule{}, - &rule.UnhandledErrorRule{}, - &rule.CognitiveComplexityRule{}, - &rule.StringOfIntRule{}, - &rule.StringFormatRule{}, - &rule.EarlyReturnRule{}, - &rule.UnconditionalRecursionRule{}, - &rule.IdenticalBranchesRule{}, - &rule.DeferRule{}, - &rule.UnexportedNamingRule{}, - &rule.FunctionLength{}, - &rule.NestedStructs{}, - &rule.UselessBreak{}, - &rule.UncheckedTypeAssertionRule{}, - &rule.TimeEqualRule{}, - &rule.BannedCharsRule{}, - &rule.OptimizeOperandsOrderRule{}, - &rule.UseAnyRule{}, - &rule.DataRaceRule{}, - &rule.CommentSpacingsRule{}, - &rule.IfReturnRule{}, - &rule.RedundantImportAlias{}, - &rule.ImportAliasNamingRule{}, - &rule.EnforceMapStyleRule{}, - &rule.EnforceRepeatedArgTypeStyleRule{}, - &rule.EnforceSliceStyleRule{}, - &rule.MaxControlNestingRule{}, - &rule.CommentsDensityRule{}, - &rule.FileLengthLimitRule{}, - &rule.FilenameFormatRule{}, -}, defaultRules...) - -var allFormatters = []lint.Formatter{ - &formatter.Stylish{}, - &formatter.Friendly{}, - &formatter.JSON{}, - &formatter.NDJSON{}, - &formatter.Default{}, - &formatter.Unix{}, - &formatter.Checkstyle{}, - &formatter.Plain{}, - &formatter.Sarif{}, -} - -func getFormatters() map[string]lint.Formatter { - result := map[string]lint.Formatter{} - for _, f := range allFormatters { - result[f.Name()] = f - } - return result -} - -// GetLintingRules yields the linting rules that must be applied by the linter -func GetLintingRules(config *lint.Config, extraRules []lint.Rule) ([]lint.Rule, error) { - rulesMap := map[string]lint.Rule{} - for _, r := range allRules { - rulesMap[r.Name()] = r - } - for _, r := range extraRules { - if _, ok := rulesMap[r.Name()]; ok { - continue - } - rulesMap[r.Name()] = r - } - - var lintingRules []lint.Rule - for name, ruleConfig := range config.Rules { - actualName := actualRuleName(name) - r, ok := rulesMap[actualName] - if !ok { - return nil, fmt.Errorf("cannot find rule: %s", name) - } - - if ruleConfig.Disabled { - continue // skip disabled rules - } - - lintingRules = append(lintingRules, r) - } - - return lintingRules, nil -} - -func actualRuleName(name string) string { - switch name { - case "imports-blacklist": - return "imports-blocklist" - default: - return name - } -} - -func parseConfig(path string, config *lint.Config) error { - file, err := os.ReadFile(path) - if err != nil { - return errors.New("cannot read the config file") - } - _, err = toml.Decode(string(file), config) - if err != nil { - return fmt.Errorf("cannot parse the config file: %v", err) - } - for k, r := range config.Rules { - err := r.Initialize() - if err != nil { - return fmt.Errorf("error in config of rule [%s] : [%v]", k, err) - } - config.Rules[k] = r - } - - return nil -} - -func normalizeConfig(config *lint.Config) { - if len(config.Rules) == 0 { - config.Rules = map[string]lint.RuleConfig{} - } - if config.EnableAllRules { - // Add to the configuration all rules not yet present in it - for _, r := range allRules { - ruleName := r.Name() - _, alreadyInConf := config.Rules[ruleName] - if alreadyInConf { - continue - } - // Add the rule with an empty conf for - config.Rules[ruleName] = lint.RuleConfig{} - } - } - - severity := config.Severity - if severity != "" { - for k, v := range config.Rules { - if v.Severity == "" { - v.Severity = severity - } - config.Rules[k] = v - } - for k, v := range config.Directives { - if v.Severity == "" { - v.Severity = severity - } - config.Directives[k] = v - } - } -} - -const defaultConfidence = 0.8 - -// GetConfig yields the configuration -func GetConfig(configPath string) (*lint.Config, error) { - config := &lint.Config{} - switch { - case configPath != "": - config.Confidence = defaultConfidence - err := parseConfig(configPath, config) - if err != nil { - return nil, err - } - - default: // no configuration provided - config = defaultConfig() - } - - normalizeConfig(config) - return config, nil -} - -// GetFormatter yields the formatter for lint failures -func GetFormatter(formatterName string) (lint.Formatter, error) { - formatters := getFormatters() - fmtr := formatters["default"] - if formatterName != "" { - f, ok := formatters[formatterName] - if !ok { - return nil, fmt.Errorf("unknown formatter %v", formatterName) - } - fmtr = f - } - return fmtr, nil -} - -func defaultConfig() *lint.Config { - defaultConfig := lint.Config{ - Confidence: defaultConfidence, - Severity: lint.SeverityWarning, - Rules: map[string]lint.RuleConfig{}, - } - for _, r := range defaultRules { - defaultConfig.Rules[r.Name()] = lint.RuleConfig{} - } - return &defaultConfig -} diff --git a/vendor/github.com/mgechev/revive/formatter/checkstyle.go b/vendor/github.com/mgechev/revive/formatter/checkstyle.go deleted file mode 100644 index f45b63c92..000000000 --- a/vendor/github.com/mgechev/revive/formatter/checkstyle.go +++ /dev/null @@ -1,77 +0,0 @@ -package formatter - -import ( - "bytes" - "encoding/xml" - plain "text/template" - - "github.com/mgechev/revive/lint" -) - -// Checkstyle is an implementation of the Formatter interface -// which formats the errors to Checkstyle-like format. -type Checkstyle struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*Checkstyle) Name() string { - return "checkstyle" -} - -type issue struct { - Line int - Col int - What string - Confidence float64 - Severity lint.Severity - RuleName string -} - -// Format formats the failures gotten from the lint. -func (*Checkstyle) Format(failures <-chan lint.Failure, config lint.Config) (string, error) { - issues := map[string][]issue{} - for failure := range failures { - buf := new(bytes.Buffer) - xml.Escape(buf, []byte(failure.Failure)) - what := buf.String() - iss := issue{ - Line: failure.Position.Start.Line, - Col: failure.Position.Start.Column, - What: what, - Confidence: failure.Confidence, - Severity: severity(config, failure), - RuleName: failure.RuleName, - } - fn := failure.GetFilename() - if issues[fn] == nil { - issues[fn] = make([]issue, 0) - } - issues[fn] = append(issues[fn], iss) - } - - t, err := plain.New("revive").Parse(checkstyleTemplate) - if err != nil { - return "", err - } - - buf := new(bytes.Buffer) - - err = t.Execute(buf, issues) - if err != nil { - return "", err - } - - return buf.String(), nil -} - -const checkstyleTemplate = ` - -{{- range $k, $v := . }} - - {{- range $i, $issue := $v }} - - {{- end }} - -{{- end }} -` diff --git a/vendor/github.com/mgechev/revive/formatter/default.go b/vendor/github.com/mgechev/revive/formatter/default.go deleted file mode 100644 index 2d5a04434..000000000 --- a/vendor/github.com/mgechev/revive/formatter/default.go +++ /dev/null @@ -1,28 +0,0 @@ -package formatter - -import ( - "bytes" - "fmt" - - "github.com/mgechev/revive/lint" -) - -// Default is an implementation of the Formatter interface -// which formats the errors to text. -type Default struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*Default) Name() string { - return "default" -} - -// Format formats the failures gotten from the lint. -func (*Default) Format(failures <-chan lint.Failure, _ lint.Config) (string, error) { - var buf bytes.Buffer - for failure := range failures { - fmt.Fprintf(&buf, "%v: %s\n", failure.Position.Start, failure.Failure) - } - return buf.String(), nil -} diff --git a/vendor/github.com/mgechev/revive/formatter/doc.go b/vendor/github.com/mgechev/revive/formatter/doc.go deleted file mode 100644 index bb89f20ea..000000000 --- a/vendor/github.com/mgechev/revive/formatter/doc.go +++ /dev/null @@ -1,2 +0,0 @@ -// Package formatter implements the linter output formatters. -package formatter diff --git a/vendor/github.com/mgechev/revive/formatter/friendly.go b/vendor/github.com/mgechev/revive/formatter/friendly.go deleted file mode 100644 index 5ff329a23..000000000 --- a/vendor/github.com/mgechev/revive/formatter/friendly.go +++ /dev/null @@ -1,141 +0,0 @@ -package formatter - -import ( - "bytes" - "fmt" - "io" - "sort" - - "github.com/fatih/color" - "github.com/mgechev/revive/lint" - "github.com/olekukonko/tablewriter" -) - -func getErrorEmoji() string { - return color.RedString("✘") -} - -func getWarningEmoji() string { - return color.YellowString("⚠") -} - -// Friendly is an implementation of the Formatter interface -// which formats the errors to JSON. -type Friendly struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*Friendly) Name() string { - return "friendly" -} - -// Format formats the failures gotten from the lint. -func (f *Friendly) Format(failures <-chan lint.Failure, config lint.Config) (string, error) { - var buf bytes.Buffer - errorMap := map[string]int{} - warningMap := map[string]int{} - totalErrors := 0 - totalWarnings := 0 - for failure := range failures { - sev := severity(config, failure) - f.printFriendlyFailure(&buf, failure, sev) - if sev == lint.SeverityWarning { - warningMap[failure.RuleName]++ - totalWarnings++ - } - if sev == lint.SeverityError { - errorMap[failure.RuleName]++ - totalErrors++ - } - } - f.printSummary(&buf, totalErrors, totalWarnings) - f.printStatistics(&buf, color.RedString("Errors:"), errorMap) - f.printStatistics(&buf, color.YellowString("Warnings:"), warningMap) - return buf.String(), nil -} - -func (f *Friendly) printFriendlyFailure(w io.Writer, failure lint.Failure, severity lint.Severity) { - f.printHeaderRow(w, failure, severity) - f.printFilePosition(w, failure) - fmt.Fprintln(w) - fmt.Fprintln(w) -} - -func (f *Friendly) printHeaderRow(w io.Writer, failure lint.Failure, severity lint.Severity) { - emoji := getWarningEmoji() - if severity == lint.SeverityError { - emoji = getErrorEmoji() - } - fmt.Fprint(w, f.table([][]string{{emoji, "https://revive.run/r#" + failure.RuleName, color.GreenString(failure.Failure)}})) -} - -func (*Friendly) printFilePosition(w io.Writer, failure lint.Failure) { - fmt.Fprintf(w, " %s:%d:%d", failure.GetFilename(), failure.Position.Start.Line, failure.Position.Start.Column) -} - -type statEntry struct { - name string - failures int -} - -func (*Friendly) printSummary(w io.Writer, errors, warnings int) { - emoji := getWarningEmoji() - if errors > 0 { - emoji = getErrorEmoji() - } - problemsLabel := "problems" - if errors+warnings == 1 { - problemsLabel = "problem" - } - warningsLabel := "warnings" - if warnings == 1 { - warningsLabel = "warning" - } - errorsLabel := "errors" - if errors == 1 { - errorsLabel = "error" - } - str := fmt.Sprintf("%d %s (%d %s, %d %s)", errors+warnings, problemsLabel, errors, errorsLabel, warnings, warningsLabel) - if errors > 0 { - fmt.Fprintf(w, "%s %s\n", emoji, color.RedString(str)) - fmt.Fprintln(w) - return - } - if warnings > 0 { - fmt.Fprintf(w, "%s %s\n", emoji, color.YellowString(str)) - fmt.Fprintln(w) - return - } -} - -func (f *Friendly) printStatistics(w io.Writer, header string, stats map[string]int) { - if len(stats) == 0 { - return - } - var data []statEntry - for name, total := range stats { - data = append(data, statEntry{name, total}) - } - sort.Slice(data, func(i, j int) bool { - return data[i].failures > data[j].failures - }) - formatted := [][]string{} - for _, entry := range data { - formatted = append(formatted, []string{color.GreenString(fmt.Sprintf("%d", entry.failures)), entry.name}) - } - fmt.Fprintln(w, header) - fmt.Fprintln(w, f.table(formatted)) -} - -func (*Friendly) table(rows [][]string) string { - buf := new(bytes.Buffer) - table := tablewriter.NewWriter(buf) - table.SetBorder(false) - table.SetColumnSeparator("") - table.SetRowSeparator("") - table.SetAutoWrapText(false) - table.AppendBulk(rows) - table.Render() - return buf.String() -} diff --git a/vendor/github.com/mgechev/revive/formatter/json.go b/vendor/github.com/mgechev/revive/formatter/json.go deleted file mode 100644 index 7cace89ec..000000000 --- a/vendor/github.com/mgechev/revive/formatter/json.go +++ /dev/null @@ -1,40 +0,0 @@ -package formatter - -import ( - "encoding/json" - - "github.com/mgechev/revive/lint" -) - -// JSON is an implementation of the Formatter interface -// which formats the errors to JSON. -type JSON struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*JSON) Name() string { - return "json" -} - -// jsonObject defines a JSON object of an failure -type jsonObject struct { - Severity lint.Severity - lint.Failure `json:",inline"` -} - -// Format formats the failures gotten from the lint. -func (*JSON) Format(failures <-chan lint.Failure, config lint.Config) (string, error) { - var slice []jsonObject - for failure := range failures { - obj := jsonObject{} - obj.Severity = severity(config, failure) - obj.Failure = failure - slice = append(slice, obj) - } - result, err := json.Marshal(slice) - if err != nil { - return "", err - } - return string(result), err -} diff --git a/vendor/github.com/mgechev/revive/formatter/ndjson.go b/vendor/github.com/mgechev/revive/formatter/ndjson.go deleted file mode 100644 index 58b35dc44..000000000 --- a/vendor/github.com/mgechev/revive/formatter/ndjson.go +++ /dev/null @@ -1,35 +0,0 @@ -package formatter - -import ( - "bytes" - "encoding/json" - - "github.com/mgechev/revive/lint" -) - -// NDJSON is an implementation of the Formatter interface -// which formats the errors to NDJSON stream. -type NDJSON struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*NDJSON) Name() string { - return "ndjson" -} - -// Format formats the failures gotten from the lint. -func (*NDJSON) Format(failures <-chan lint.Failure, config lint.Config) (string, error) { - var buf bytes.Buffer - enc := json.NewEncoder(&buf) - for failure := range failures { - obj := jsonObject{} - obj.Severity = severity(config, failure) - obj.Failure = failure - err := enc.Encode(obj) - if err != nil { - return "", err - } - } - return buf.String(), nil -} diff --git a/vendor/github.com/mgechev/revive/formatter/plain.go b/vendor/github.com/mgechev/revive/formatter/plain.go deleted file mode 100644 index 09ebf6cdc..000000000 --- a/vendor/github.com/mgechev/revive/formatter/plain.go +++ /dev/null @@ -1,28 +0,0 @@ -package formatter - -import ( - "bytes" - "fmt" - - "github.com/mgechev/revive/lint" -) - -// Plain is an implementation of the Formatter interface -// which formats the errors to JSON. -type Plain struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*Plain) Name() string { - return "plain" -} - -// Format formats the failures gotten from the lint. -func (*Plain) Format(failures <-chan lint.Failure, _ lint.Config) (string, error) { - var buf bytes.Buffer - for failure := range failures { - fmt.Fprintf(&buf, "%v: %s %s\n", failure.Position.Start, failure.Failure, "https://revive.run/r#"+failure.RuleName) - } - return buf.String(), nil -} diff --git a/vendor/github.com/mgechev/revive/formatter/sarif.go b/vendor/github.com/mgechev/revive/formatter/sarif.go deleted file mode 100644 index c42da73eb..000000000 --- a/vendor/github.com/mgechev/revive/formatter/sarif.go +++ /dev/null @@ -1,107 +0,0 @@ -package formatter - -import ( - "bytes" - "fmt" - "strings" - - "github.com/chavacava/garif" - "github.com/mgechev/revive/lint" -) - -// Sarif is an implementation of the Formatter interface -// which formats revive failures into SARIF format. -type Sarif struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*Sarif) Name() string { - return "sarif" -} - -const reviveSite = "https://revive.run" - -// Format formats the failures gotten from the lint. -func (*Sarif) Format(failures <-chan lint.Failure, cfg lint.Config) (string, error) { - sarifLog := newReviveRunLog(cfg) - - for failure := range failures { - sarifLog.AddResult(failure) - } - - buf := new(bytes.Buffer) - sarifLog.PrettyWrite(buf) - - return buf.String(), nil -} - -type reviveRunLog struct { - *garif.LogFile - run *garif.Run - rules map[string]lint.RuleConfig -} - -func newReviveRunLog(cfg lint.Config) *reviveRunLog { - run := garif.NewRun(garif.NewTool(garif.NewDriver("revive").WithInformationUri(reviveSite))) - log := garif.NewLogFile([]*garif.Run{run}, garif.Version210) - - reviveLog := &reviveRunLog{ - log, - run, - cfg.Rules, - } - - reviveLog.addRules(cfg.Rules) - - return reviveLog -} - -func (l *reviveRunLog) addRules(cfg map[string]lint.RuleConfig) { - for name, ruleCfg := range cfg { - rule := garif.NewRule(name).WithHelpUri(reviveSite + "/r#" + name) - setRuleProperties(rule, ruleCfg) - driver := l.run.Tool.Driver - - if driver.Rules == nil { - driver.Rules = []*garif.ReportingDescriptor{rule} - return - } - - driver.Rules = append(driver.Rules, rule) - } -} - -func (l *reviveRunLog) AddResult(failure lint.Failure) { - positiveOrZero := func(x int) int { - if x > 0 { - return x - } - return 0 - } - position := failure.Position - filename := position.Start.Filename - line := positiveOrZero(position.Start.Line) // https://docs.oasis-open.org/sarif/sarif/v2.1.0/csprd01/sarif-v2.1.0-csprd01.html#def_line - column := positiveOrZero(position.Start.Column) // https://docs.oasis-open.org/sarif/sarif/v2.1.0/csprd01/sarif-v2.1.0-csprd01.html#def_column - - result := garif.NewResult(garif.NewMessageFromText(failure.Failure)) - location := garif.NewLocation().WithURI(filename).WithLineColumn(line, column) - result.Locations = append(result.Locations, location) - result.RuleId = failure.RuleName - result.Level = garif.ResultLevel(l.rules[failure.RuleName].Severity) - - l.run.Results = append(l.run.Results, result) -} - -func setRuleProperties(sarifRule *garif.ReportingDescriptor, lintRule lint.RuleConfig) { - arguments := make([]string, len(lintRule.Arguments)) - for i, arg := range lintRule.Arguments { - arguments[i] = fmt.Sprintf("%+v", arg) - } - - if len(arguments) > 0 { - sarifRule.WithProperties("arguments", strings.Join(arguments, ",")) - } - - sarifRule.WithProperties("severity", string(lintRule.Severity)) -} diff --git a/vendor/github.com/mgechev/revive/formatter/severity.go b/vendor/github.com/mgechev/revive/formatter/severity.go deleted file mode 100644 index a43bf3192..000000000 --- a/vendor/github.com/mgechev/revive/formatter/severity.go +++ /dev/null @@ -1,13 +0,0 @@ -package formatter - -import "github.com/mgechev/revive/lint" - -func severity(config lint.Config, failure lint.Failure) lint.Severity { - if config, ok := config.Rules[failure.RuleName]; ok && config.Severity == lint.SeverityError { - return lint.SeverityError - } - if config, ok := config.Directives[failure.RuleName]; ok && config.Severity == lint.SeverityError { - return lint.SeverityError - } - return lint.SeverityWarning -} diff --git a/vendor/github.com/mgechev/revive/formatter/stylish.go b/vendor/github.com/mgechev/revive/formatter/stylish.go deleted file mode 100644 index 828228c72..000000000 --- a/vendor/github.com/mgechev/revive/formatter/stylish.go +++ /dev/null @@ -1,89 +0,0 @@ -package formatter - -import ( - "bytes" - "fmt" - - "github.com/fatih/color" - "github.com/mgechev/revive/lint" - "github.com/olekukonko/tablewriter" -) - -// Stylish is an implementation of the Formatter interface -// which formats the errors to JSON. -type Stylish struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*Stylish) Name() string { - return "stylish" -} - -func formatFailure(failure lint.Failure, severity lint.Severity) []string { - fString := color.CyanString(failure.Failure) - fName := color.RedString("https://revive.run/r#" + failure.RuleName) - lineColumn := failure.Position - pos := fmt.Sprintf("(%d, %d)", lineColumn.Start.Line, lineColumn.Start.Column) - if severity == lint.SeverityWarning { - fName = color.YellowString("https://revive.run/r#" + failure.RuleName) - } - return []string{failure.GetFilename(), pos, fName, fString} -} - -// Format formats the failures gotten from the lint. -func (*Stylish) Format(failures <-chan lint.Failure, config lint.Config) (string, error) { - var result [][]string - totalErrors := 0 - total := 0 - - for f := range failures { - total++ - currentType := severity(config, f) - if currentType == lint.SeverityError { - totalErrors++ - } - result = append(result, formatFailure(f, lint.Severity(currentType))) - } - ps := "problems" - if total == 1 { - ps = "problem" - } - - fileReport := make(map[string][][]string) - - for _, row := range result { - if _, ok := fileReport[row[0]]; !ok { - fileReport[row[0]] = [][]string{} - } - - fileReport[row[0]] = append(fileReport[row[0]], []string{row[1], row[2], row[3]}) - } - - output := "" - for filename, val := range fileReport { - buf := new(bytes.Buffer) - table := tablewriter.NewWriter(buf) - table.SetBorder(false) - table.SetColumnSeparator("") - table.SetRowSeparator("") - table.SetAutoWrapText(false) - table.AppendBulk(val) - table.Render() - c := color.New(color.Underline) - output += c.SprintfFunc()(filename + "\n") - output += buf.String() + "\n" - } - - suffix := fmt.Sprintf(" %d %s (%d errors) (%d warnings)", total, ps, totalErrors, total-totalErrors) - - if total > 0 && totalErrors > 0 { - suffix = color.RedString("\n ✖" + suffix) - } else if total > 0 && totalErrors == 0 { - suffix = color.YellowString("\n ✖" + suffix) - } else { - suffix, output = "", "" - } - - return output + suffix, nil -} diff --git a/vendor/github.com/mgechev/revive/formatter/unix.go b/vendor/github.com/mgechev/revive/formatter/unix.go deleted file mode 100644 index e46f3c275..000000000 --- a/vendor/github.com/mgechev/revive/formatter/unix.go +++ /dev/null @@ -1,30 +0,0 @@ -package formatter - -import ( - "bytes" - "fmt" - - "github.com/mgechev/revive/lint" -) - -// Unix is an implementation of the Formatter interface -// which formats the errors to a simple line based error format -// -// main.go:24:9: [errorf] should replace errors.New(fmt.Sprintf(...)) with fmt.Errorf(...) -type Unix struct { - Metadata lint.FormatterMetadata -} - -// Name returns the name of the formatter -func (*Unix) Name() string { - return "unix" -} - -// Format formats the failures gotten from the lint. -func (*Unix) Format(failures <-chan lint.Failure, _ lint.Config) (string, error) { - var buf bytes.Buffer - for failure := range failures { - fmt.Fprintf(&buf, "%v: [%s] %s\n", failure.Position.Start, failure.RuleName, failure.Failure) - } - return buf.String(), nil -} diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/args.go b/vendor/github.com/mgechev/revive/internal/ifelse/args.go deleted file mode 100644 index c6e647e69..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/args.go +++ /dev/null @@ -1,11 +0,0 @@ -package ifelse - -// PreserveScope is a configuration argument that prevents suggestions -// that would enlarge variable scope -const PreserveScope = "preserveScope" - -// Args contains arguments common to the early-return, indent-error-flow -// and superfluous-else rules (currently just preserveScope) -type Args struct { - PreserveScope bool -} diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/branch.go b/vendor/github.com/mgechev/revive/internal/ifelse/branch.go deleted file mode 100644 index 6e6036b89..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/branch.go +++ /dev/null @@ -1,93 +0,0 @@ -package ifelse - -import ( - "fmt" - "go/ast" - "go/token" -) - -// Branch contains information about a branch within an if-else chain. -type Branch struct { - BranchKind - Call // The function called at the end for kind Panic or Exit. - HasDecls bool // The branch has one or more declarations (at the top level block) -} - -// BlockBranch gets the Branch of an ast.BlockStmt. -func BlockBranch(block *ast.BlockStmt) Branch { - blockLen := len(block.List) - if blockLen == 0 { - return Empty.Branch() - } - - branch := StmtBranch(block.List[blockLen-1]) - branch.HasDecls = hasDecls(block) - return branch -} - -// StmtBranch gets the Branch of an ast.Stmt. -func StmtBranch(stmt ast.Stmt) Branch { - switch stmt := stmt.(type) { - case *ast.ReturnStmt: - return Return.Branch() - case *ast.BlockStmt: - return BlockBranch(stmt) - case *ast.BranchStmt: - switch stmt.Tok { - case token.BREAK: - return Break.Branch() - case token.CONTINUE: - return Continue.Branch() - case token.GOTO: - return Goto.Branch() - } - case *ast.ExprStmt: - fn, ok := ExprCall(stmt) - if !ok { - break - } - kind, ok := DeviatingFuncs[fn] - if ok { - return Branch{BranchKind: kind, Call: fn} - } - case *ast.EmptyStmt: - return Empty.Branch() - case *ast.LabeledStmt: - return StmtBranch(stmt.Stmt) - } - return Regular.Branch() -} - -// String returns a brief string representation -func (b Branch) String() string { - switch b.BranchKind { - case Panic, Exit: - return fmt.Sprintf("... %v()", b.Call) - default: - return b.BranchKind.String() - } -} - -// LongString returns a longer form string representation -func (b Branch) LongString() string { - switch b.BranchKind { - case Panic, Exit: - return fmt.Sprintf("call to %v function", b.Call) - default: - return b.BranchKind.LongString() - } -} - -func hasDecls(block *ast.BlockStmt) bool { - for _, stmt := range block.List { - switch stmt := stmt.(type) { - case *ast.DeclStmt: - return true - case *ast.AssignStmt: - if stmt.Tok == token.DEFINE { - return true - } - } - } - return false -} diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/branch_kind.go b/vendor/github.com/mgechev/revive/internal/ifelse/branch_kind.go deleted file mode 100644 index 41601d1e1..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/branch_kind.go +++ /dev/null @@ -1,101 +0,0 @@ -package ifelse - -// BranchKind is a classifier for if-else branches. It says whether the branch is empty, -// and whether the branch ends with a statement that deviates control flow. -type BranchKind int - -const ( - // Empty branches do nothing - Empty BranchKind = iota - - // Return branches return from the current function - Return - - // Continue branches continue a surrounding "for" loop - Continue - - // Break branches break a surrounding "for" loop - Break - - // Goto branches conclude with a "goto" statement - Goto - - // Panic branches panic the current function - Panic - - // Exit branches end the program - Exit - - // Regular branches do not fit any category above - Regular -) - -// IsEmpty tests if the branch is empty -func (k BranchKind) IsEmpty() bool { return k == Empty } - -// Returns tests if the branch returns from the current function -func (k BranchKind) Returns() bool { return k == Return } - -// Deviates tests if the control does not flow to the first -// statement following the if-else chain. -func (k BranchKind) Deviates() bool { - switch k { - case Empty, Regular: - return false - case Return, Continue, Break, Goto, Panic, Exit: - return true - default: - panic("invalid kind") - } -} - -// Branch returns a Branch with the given kind -func (k BranchKind) Branch() Branch { return Branch{BranchKind: k} } - -// String returns a brief string representation -func (k BranchKind) String() string { - switch k { - case Empty: - return "" - case Regular: - return "..." - case Return: - return "... return" - case Continue: - return "... continue" - case Break: - return "... break" - case Goto: - return "... goto" - case Panic: - return "... panic()" - case Exit: - return "... os.Exit()" - default: - panic("invalid kind") - } -} - -// LongString returns a longer form string representation -func (k BranchKind) LongString() string { - switch k { - case Empty: - return "an empty block" - case Regular: - return "a regular statement" - case Return: - return "a return statement" - case Continue: - return "a continue statement" - case Break: - return "a break statement" - case Goto: - return "a goto statement" - case Panic: - return "a function call that panics" - case Exit: - return "a function call that exits the program" - default: - panic("invalid kind") - } -} diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/chain.go b/vendor/github.com/mgechev/revive/internal/ifelse/chain.go deleted file mode 100644 index 9891635ee..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/chain.go +++ /dev/null @@ -1,10 +0,0 @@ -package ifelse - -// Chain contains information about an if-else chain. -type Chain struct { - If Branch // what happens at the end of the "if" block - Else Branch // what happens at the end of the "else" block - HasInitializer bool // is there an "if"-initializer somewhere in the chain? - HasPriorNonDeviating bool // is there a prior "if" block that does NOT deviate control flow? - AtBlockEnd bool // whether the chain is placed at the end of the surrounding block -} diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/doc.go b/vendor/github.com/mgechev/revive/internal/ifelse/doc.go deleted file mode 100644 index 0aa2c9817..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/doc.go +++ /dev/null @@ -1,6 +0,0 @@ -// Package ifelse provides helpers for analysing the control flow in if-else chains, -// presently used by the following rules: -// - early-return -// - indent-error-flow -// - superfluous-else -package ifelse diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/func.go b/vendor/github.com/mgechev/revive/internal/ifelse/func.go deleted file mode 100644 index 7ba351918..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/func.go +++ /dev/null @@ -1,51 +0,0 @@ -package ifelse - -import ( - "fmt" - "go/ast" -) - -// Call contains the name of a function that deviates control flow. -type Call struct { - Pkg string // The package qualifier of the function, if not built-in. - Name string // The function name. -} - -// DeviatingFuncs lists known control flow deviating function calls. -var DeviatingFuncs = map[Call]BranchKind{ - {"os", "Exit"}: Exit, - {"log", "Fatal"}: Exit, - {"log", "Fatalf"}: Exit, - {"log", "Fatalln"}: Exit, - {"", "panic"}: Panic, - {"log", "Panic"}: Panic, - {"log", "Panicf"}: Panic, - {"log", "Panicln"}: Panic, -} - -// ExprCall gets the Call of an ExprStmt, if any. -func ExprCall(expr *ast.ExprStmt) (Call, bool) { - call, ok := expr.X.(*ast.CallExpr) - if !ok { - return Call{}, false - } - switch v := call.Fun.(type) { - case *ast.Ident: - return Call{Name: v.Name}, true - case *ast.SelectorExpr: - if ident, ok := v.X.(*ast.Ident); ok { - return Call{Name: v.Sel.Name, Pkg: ident.Name}, true - } - } - return Call{}, false -} - -// String returns the function name with package qualifier (if any) -func (f Call) String() string { - switch { - case f.Pkg != "": - return fmt.Sprintf("%s.%s", f.Pkg, f.Name) - default: - return f.Name - } -} diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/rule.go b/vendor/github.com/mgechev/revive/internal/ifelse/rule.go deleted file mode 100644 index 07ad456b6..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/rule.go +++ /dev/null @@ -1,105 +0,0 @@ -package ifelse - -import ( - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// Rule is an interface for linters operating on if-else chains -type Rule interface { - CheckIfElse(chain Chain, args Args) (failMsg string) -} - -// Apply evaluates the given Rule on if-else chains found within the given AST, -// and returns the failures. -// -// Note that in if-else chain with multiple "if" blocks, only the *last* one is checked, -// that is to say, given: -// -// if foo { -// ... -// } else if bar { -// ... -// } else { -// ... -// } -// -// Only the block following "bar" is linted. This is because the rules that use this function -// do not presently have anything to say about earlier blocks in the chain. -func Apply(rule Rule, node ast.Node, target Target, args lint.Arguments) []lint.Failure { - v := &visitor{rule: rule, target: target} - for _, arg := range args { - if arg == PreserveScope { - v.args.PreserveScope = true - } - } - ast.Walk(v, node) - return v.failures -} - -type visitor struct { - failures []lint.Failure - target Target - rule Rule - args Args -} - -func (v *visitor) Visit(node ast.Node) ast.Visitor { - block, ok := node.(*ast.BlockStmt) - if !ok { - return v - } - - for i, stmt := range block.List { - if ifStmt, ok := stmt.(*ast.IfStmt); ok { - v.visitChain(ifStmt, Chain{AtBlockEnd: i == len(block.List)-1}) - continue - } - ast.Walk(v, stmt) - } - return nil -} - -func (v *visitor) visitChain(ifStmt *ast.IfStmt, chain Chain) { - // look for other if-else chains nested inside this if { } block - ast.Walk(v, ifStmt.Body) - - if ifStmt.Else == nil { - // no else branch - return - } - - if as, ok := ifStmt.Init.(*ast.AssignStmt); ok && as.Tok == token.DEFINE { - chain.HasInitializer = true - } - chain.If = BlockBranch(ifStmt.Body) - - switch elseBlock := ifStmt.Else.(type) { - case *ast.IfStmt: - if !chain.If.Deviates() { - chain.HasPriorNonDeviating = true - } - v.visitChain(elseBlock, chain) - case *ast.BlockStmt: - // look for other if-else chains nested inside this else { } block - ast.Walk(v, elseBlock) - - chain.Else = BlockBranch(elseBlock) - if failMsg := v.rule.CheckIfElse(chain, v.args); failMsg != "" { - if chain.HasInitializer { - // if statement has a := initializer, so we might need to move the assignment - // onto its own line in case the body references it - failMsg += " (move short variable declaration to its own line if necessary)" - } - v.failures = append(v.failures, lint.Failure{ - Confidence: 1, - Node: v.target.node(ifStmt), - Failure: failMsg, - }) - } - default: - panic("invalid node type for else") - } -} diff --git a/vendor/github.com/mgechev/revive/internal/ifelse/target.go b/vendor/github.com/mgechev/revive/internal/ifelse/target.go deleted file mode 100644 index 81ff1c303..000000000 --- a/vendor/github.com/mgechev/revive/internal/ifelse/target.go +++ /dev/null @@ -1,25 +0,0 @@ -package ifelse - -import "go/ast" - -// Target decides what line/column should be indicated by the rule in question. -type Target int - -const ( - // TargetIf means the text refers to the "if" - TargetIf Target = iota - - // TargetElse means the text refers to the "else" - TargetElse -) - -func (t Target) node(ifStmt *ast.IfStmt) ast.Node { - switch t { - case TargetIf: - return ifStmt - case TargetElse: - return ifStmt.Else - default: - panic("bad target") - } -} diff --git a/vendor/github.com/mgechev/revive/internal/typeparams/typeparams.go b/vendor/github.com/mgechev/revive/internal/typeparams/typeparams.go deleted file mode 100644 index 33c4f203e..000000000 --- a/vendor/github.com/mgechev/revive/internal/typeparams/typeparams.go +++ /dev/null @@ -1,29 +0,0 @@ -// Package typeparams provides utilities for working with Go ASTs with support -// for type parameters when built with Go 1.18 and higher. -package typeparams - -import ( - "go/ast" -) - -// Enabled reports whether type parameters are enabled in the current build -// environment. -func Enabled() bool { - return enabled -} - -// ReceiverType returns the named type of the method receiver, sans "*" and type -// parameters, or "invalid-type" if fn.Recv is ill formed. -func ReceiverType(fn *ast.FuncDecl) string { - e := fn.Recv.List[0].Type - if s, ok := e.(*ast.StarExpr); ok { - e = s.X - } - if enabled { - e = unpackIndexExpr(e) - } - if id, ok := e.(*ast.Ident); ok { - return id.Name - } - return "invalid-type" -} diff --git a/vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go117.go b/vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go117.go deleted file mode 100644 index 913a7316e..000000000 --- a/vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go117.go +++ /dev/null @@ -1,12 +0,0 @@ -//go:build !go1.18 -// +build !go1.18 - -package typeparams - -import ( - "go/ast" -) - -const enabled = false - -func unpackIndexExpr(e ast.Expr) ast.Expr { return e } diff --git a/vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go118.go b/vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go118.go deleted file mode 100644 index 0f7fd88d3..000000000 --- a/vendor/github.com/mgechev/revive/internal/typeparams/typeparams_go118.go +++ /dev/null @@ -1,20 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -package typeparams - -import ( - "go/ast" -) - -const enabled = true - -func unpackIndexExpr(e ast.Expr) ast.Expr { - switch e := e.(type) { - case *ast.IndexExpr: - return e.X - case *ast.IndexListExpr: - return e.X - } - return e -} diff --git a/vendor/github.com/mgechev/revive/lint/config.go b/vendor/github.com/mgechev/revive/lint/config.go deleted file mode 100644 index d7ecd964a..000000000 --- a/vendor/github.com/mgechev/revive/lint/config.go +++ /dev/null @@ -1,71 +0,0 @@ -package lint - -import ( - goversion "github.com/hashicorp/go-version" -) - -// Arguments is type used for the arguments of a rule. -type Arguments = []interface{} - -// FileFilters is type used for modeling file filters to apply to rules. -type FileFilters = []*FileFilter - -// RuleConfig is type used for the rule configuration. -type RuleConfig struct { - Arguments Arguments - Severity Severity - Disabled bool - // Exclude - rule-level file excludes, TOML related (strings) - Exclude []string - // excludeFilters - regex-based file filters, initialized from Exclude - excludeFilters []*FileFilter -} - -// Initialize - should be called after reading from TOML file -func (rc *RuleConfig) Initialize() error { - for _, f := range rc.Exclude { - ff, err := ParseFileFilter(f) - if err != nil { - return err - } - rc.excludeFilters = append(rc.excludeFilters, ff) - } - return nil -} - -// RulesConfig defines the config for all rules. -type RulesConfig = map[string]RuleConfig - -// MustExclude - checks if given filename `name` must be excluded -func (rc *RuleConfig) MustExclude(name string) bool { - for _, exclude := range rc.excludeFilters { - if exclude.MatchFileName(name) { - return true - } - } - return false -} - -// DirectiveConfig is type used for the linter directive configuration. -type DirectiveConfig struct { - Severity Severity -} - -// DirectivesConfig defines the config for all directives. -type DirectivesConfig = map[string]DirectiveConfig - -// Config defines the config of the linter. -type Config struct { - IgnoreGeneratedHeader bool `toml:"ignoreGeneratedHeader"` - Confidence float64 - Severity Severity - EnableAllRules bool `toml:"enableAllRules"` - Rules RulesConfig `toml:"rule"` - ErrorCode int `toml:"errorCode"` - WarningCode int `toml:"warningCode"` - Directives DirectivesConfig `toml:"directive"` - Exclude []string `toml:"exclude"` - // If set, overrides the go language version specified in go.mod of - // packages being linted, and assumes this specific language version. - GoVersion *goversion.Version -} diff --git a/vendor/github.com/mgechev/revive/lint/doc.go b/vendor/github.com/mgechev/revive/lint/doc.go deleted file mode 100644 index 7048adf4b..000000000 --- a/vendor/github.com/mgechev/revive/lint/doc.go +++ /dev/null @@ -1,2 +0,0 @@ -// Package lint implements the linting machinery. -package lint diff --git a/vendor/github.com/mgechev/revive/lint/failure.go b/vendor/github.com/mgechev/revive/lint/failure.go deleted file mode 100644 index 479b0cb48..000000000 --- a/vendor/github.com/mgechev/revive/lint/failure.go +++ /dev/null @@ -1,39 +0,0 @@ -package lint - -import ( - "go/ast" - "go/token" -) - -const ( - // SeverityWarning declares failures of type warning - SeverityWarning = "warning" - // SeverityError declares failures of type error. - SeverityError = "error" -) - -// Severity is the type for the failure types. -type Severity string - -// FailurePosition returns the failure position -type FailurePosition struct { - Start token.Position - End token.Position -} - -// Failure defines a struct for a linting failure. -type Failure struct { - Failure string - RuleName string - Category string - Position FailurePosition - Node ast.Node `json:"-"` - Confidence float64 - // For future use - ReplacementLine string -} - -// GetFilename returns the filename. -func (f *Failure) GetFilename() string { - return f.Position.Start.Filename -} diff --git a/vendor/github.com/mgechev/revive/lint/file.go b/vendor/github.com/mgechev/revive/lint/file.go deleted file mode 100644 index e34f8b7f4..000000000 --- a/vendor/github.com/mgechev/revive/lint/file.go +++ /dev/null @@ -1,280 +0,0 @@ -package lint - -import ( - "bytes" - "go/ast" - "go/parser" - "go/printer" - "go/token" - "go/types" - "math" - "regexp" - "strings" -) - -// File abstraction used for representing files. -type File struct { - Name string - Pkg *Package - content []byte - AST *ast.File -} - -// IsTest returns if the file contains tests. -func (f *File) IsTest() bool { return strings.HasSuffix(f.Name, "_test.go") } - -// Content returns the file's content. -func (f *File) Content() []byte { - return f.content -} - -// NewFile creates a new file -func NewFile(name string, content []byte, pkg *Package) (*File, error) { - f, err := parser.ParseFile(pkg.fset, name, content, parser.ParseComments) - if err != nil { - return nil, err - } - return &File{ - Name: name, - content: content, - Pkg: pkg, - AST: f, - }, nil -} - -// ToPosition returns line and column for given position. -func (f *File) ToPosition(pos token.Pos) token.Position { - return f.Pkg.fset.Position(pos) -} - -// Render renders a node. -func (f *File) Render(x interface{}) string { - var buf bytes.Buffer - if err := printer.Fprint(&buf, f.Pkg.fset, x); err != nil { - panic(err) - } - return buf.String() -} - -// CommentMap builds a comment map for the file. -func (f *File) CommentMap() ast.CommentMap { - return ast.NewCommentMap(f.Pkg.fset, f.AST, f.AST.Comments) -} - -var basicTypeKinds = map[types.BasicKind]string{ - types.UntypedBool: "bool", - types.UntypedInt: "int", - types.UntypedRune: "rune", - types.UntypedFloat: "float64", - types.UntypedComplex: "complex128", - types.UntypedString: "string", -} - -// IsUntypedConst reports whether expr is an untyped constant, -// and indicates what its default type is. -// scope may be nil. -func (f *File) IsUntypedConst(expr ast.Expr) (defType string, ok bool) { - // Re-evaluate expr outside its context to see if it's untyped. - // (An expr evaluated within, for example, an assignment context will get the type of the LHS.) - exprStr := f.Render(expr) - tv, err := types.Eval(f.Pkg.fset, f.Pkg.TypesPkg(), expr.Pos(), exprStr) - if err != nil { - return "", false - } - if b, ok := tv.Type.(*types.Basic); ok { - if dt, ok := basicTypeKinds[b.Kind()]; ok { - return dt, true - } - } - - return "", false -} - -func (f *File) isMain() bool { - return f.AST.Name.Name == "main" -} - -const directiveSpecifyDisableReason = "specify-disable-reason" - -func (f *File) lint(rules []Rule, config Config, failures chan Failure) { - rulesConfig := config.Rules - _, mustSpecifyDisableReason := config.Directives[directiveSpecifyDisableReason] - disabledIntervals := f.disabledIntervals(rules, mustSpecifyDisableReason, failures) - for _, currentRule := range rules { - ruleConfig := rulesConfig[currentRule.Name()] - if ruleConfig.MustExclude(f.Name) { - continue - } - currentFailures := currentRule.Apply(f, ruleConfig.Arguments) - for idx, failure := range currentFailures { - if failure.RuleName == "" { - failure.RuleName = currentRule.Name() - } - if failure.Node != nil { - failure.Position = ToFailurePosition(failure.Node.Pos(), failure.Node.End(), f) - } - currentFailures[idx] = failure - } - currentFailures = f.filterFailures(currentFailures, disabledIntervals) - for _, failure := range currentFailures { - if failure.Confidence >= config.Confidence { - failures <- failure - } - } - } -} - -type enableDisableConfig struct { - enabled bool - position int -} - -const ( - directiveRE = `^//[\s]*revive:(enable|disable)(?:-(line|next-line))?(?::([^\s]+))?[\s]*(?: (.+))?$` - directivePos = 1 - modifierPos = 2 - rulesPos = 3 - reasonPos = 4 -) - -var re = regexp.MustCompile(directiveRE) - -func (f *File) disabledIntervals(rules []Rule, mustSpecifyDisableReason bool, failures chan Failure) disabledIntervalsMap { - enabledDisabledRulesMap := make(map[string][]enableDisableConfig) - - getEnabledDisabledIntervals := func() disabledIntervalsMap { - result := make(disabledIntervalsMap) - - for ruleName, disabledArr := range enabledDisabledRulesMap { - ruleResult := []DisabledInterval{} - for i := 0; i < len(disabledArr); i++ { - interval := DisabledInterval{ - RuleName: ruleName, - From: token.Position{ - Filename: f.Name, - Line: disabledArr[i].position, - }, - To: token.Position{ - Filename: f.Name, - Line: math.MaxInt32, - }, - } - if i%2 == 0 { - ruleResult = append(ruleResult, interval) - } else { - ruleResult[len(ruleResult)-1].To.Line = disabledArr[i].position - } - } - result[ruleName] = ruleResult - } - - return result - } - - handleConfig := func(isEnabled bool, line int, name string) { - existing, ok := enabledDisabledRulesMap[name] - if !ok { - existing = []enableDisableConfig{} - enabledDisabledRulesMap[name] = existing - } - if (len(existing) > 1 && existing[len(existing)-1].enabled == isEnabled) || - (len(existing) == 0 && isEnabled) { - return - } - existing = append(existing, enableDisableConfig{ - enabled: isEnabled, - position: line, - }) - enabledDisabledRulesMap[name] = existing - } - - handleRules := func(_, modifier string, isEnabled bool, line int, ruleNames []string) []DisabledInterval { - var result []DisabledInterval - for _, name := range ruleNames { - if modifier == "line" { - handleConfig(isEnabled, line, name) - handleConfig(!isEnabled, line, name) - } else if modifier == "next-line" { - handleConfig(isEnabled, line+1, name) - handleConfig(!isEnabled, line+1, name) - } else { - handleConfig(isEnabled, line, name) - } - } - return result - } - - handleComment := func(filename string, c *ast.CommentGroup, line int) { - comments := c.List - for _, c := range comments { - match := re.FindStringSubmatch(c.Text) - if len(match) == 0 { - continue - } - ruleNames := []string{} - tempNames := strings.Split(match[rulesPos], ",") - - for _, name := range tempNames { - name = strings.Trim(name, "\n") - if len(name) > 0 { - ruleNames = append(ruleNames, name) - } - } - - mustCheckDisablingReason := mustSpecifyDisableReason && match[directivePos] == "disable" - if mustCheckDisablingReason && strings.Trim(match[reasonPos], " ") == "" { - failures <- Failure{ - Confidence: 1, - RuleName: directiveSpecifyDisableReason, - Failure: "reason of lint disabling not found", - Position: ToFailurePosition(c.Pos(), c.End(), f), - Node: c, - } - continue // skip this linter disabling directive - } - - // TODO: optimize - if len(ruleNames) == 0 { - for _, rule := range rules { - ruleNames = append(ruleNames, rule.Name()) - } - } - - handleRules(filename, match[modifierPos], match[directivePos] == "enable", line, ruleNames) - } - } - - comments := f.AST.Comments - for _, c := range comments { - handleComment(f.Name, c, f.ToPosition(c.End()).Line) - } - - return getEnabledDisabledIntervals() -} - -func (File) filterFailures(failures []Failure, disabledIntervals disabledIntervalsMap) []Failure { - result := []Failure{} - for _, failure := range failures { - fStart := failure.Position.Start.Line - fEnd := failure.Position.End.Line - intervals, ok := disabledIntervals[failure.RuleName] - if !ok { - result = append(result, failure) - } else { - include := true - for _, interval := range intervals { - intStart := interval.From.Line - intEnd := interval.To.Line - if (fStart >= intStart && fStart <= intEnd) || - (fEnd >= intStart && fEnd <= intEnd) { - include = false - break - } - } - if include { - result = append(result, failure) - } - } - } - return result -} diff --git a/vendor/github.com/mgechev/revive/lint/filefilter.go b/vendor/github.com/mgechev/revive/lint/filefilter.go deleted file mode 100644 index 8da090b9c..000000000 --- a/vendor/github.com/mgechev/revive/lint/filefilter.go +++ /dev/null @@ -1,128 +0,0 @@ -package lint - -import ( - "fmt" - "regexp" - "strings" -) - -// FileFilter - file filter to exclude some files for rule -// supports whole -// 1. file/dir names : pkg/mypkg/my.go, -// 2. globs: **/*.pb.go, -// 3. regexes (~ prefix) ~-tmp\.\d+\.go -// 4. special test marker `TEST` - treats as `~_test\.go` -type FileFilter struct { - // raw definition of filter inside config - raw string - // don't care what was at start, will use regexes inside - rx *regexp.Regexp - // marks filter as matching everything - matchesAll bool - // marks filter as matching nothing - matchesNothing bool -} - -// ParseFileFilter - creates [FileFilter] for given raw filter -// if empty string, it matches nothing -// if `*`, or `~`, it matches everything -// while regexp could be invalid, it could return it's compilation error -func ParseFileFilter(rawFilter string) (*FileFilter, error) { - rawFilter = strings.TrimSpace(rawFilter) - result := new(FileFilter) - result.raw = rawFilter - result.matchesNothing = len(result.raw) == 0 - result.matchesAll = result.raw == "*" || result.raw == "~" - if !result.matchesAll && !result.matchesNothing { - if err := result.prepareRegexp(); err != nil { - return nil, err - } - } - return result, nil -} - -func (ff *FileFilter) String() string { return ff.raw } - -// MatchFileName - checks if file name matches filter -func (ff *FileFilter) MatchFileName(name string) bool { - if ff.matchesAll { - return true - } - if ff.matchesNothing { - return false - } - name = strings.ReplaceAll(name, "\\", "/") - return ff.rx.MatchString(name) -} - -var fileFilterInvalidGlobRegexp = regexp.MustCompile(`[^/]\*\*[^/]`) -var escapeRegexSymbols = ".+{}()[]^$" - -func (ff *FileFilter) prepareRegexp() error { - var err error - var src = ff.raw - if src == "TEST" { - src = "~_test\\.go" - } - if strings.HasPrefix(src, "~") { - ff.rx, err = regexp.Compile(src[1:]) - if err != nil { - return fmt.Errorf("invalid file filter [%s], regexp compile error: [%v]", ff.raw, err) - } - return nil - } - /* globs */ - if strings.Contains(src, "*") { - if fileFilterInvalidGlobRegexp.MatchString(src) { - return fmt.Errorf("invalid file filter [%s], invalid glob pattern", ff.raw) - } - var rxBuild strings.Builder - rxBuild.WriteByte('^') - wasStar := false - justDirGlob := false - for _, c := range src { - if c == '*' { - if wasStar { - rxBuild.WriteString(`[\s\S]*`) - wasStar = false - justDirGlob = true - continue - } - wasStar = true - continue - } - if wasStar { - rxBuild.WriteString("[^/]*") - wasStar = false - } - if strings.ContainsRune(escapeRegexSymbols, c) { - rxBuild.WriteByte('\\') - } - rxBuild.WriteRune(c) - if c == '/' && justDirGlob { - rxBuild.WriteRune('?') - } - justDirGlob = false - } - if wasStar { - rxBuild.WriteString("[^/]*") - } - rxBuild.WriteByte('$') - ff.rx, err = regexp.Compile(rxBuild.String()) - if err != nil { - return fmt.Errorf("invalid file filter [%s], regexp compile error after glob expand: [%v]", ff.raw, err) - } - return nil - } - - // it's whole file mask, just escape dots and normilze separators - fillRx := src - fillRx = strings.ReplaceAll(fillRx, "\\", "/") - fillRx = strings.ReplaceAll(fillRx, ".", `\.`) - fillRx = "^" + fillRx + "$" - ff.rx, err = regexp.Compile(fillRx) - if err != nil { - return fmt.Errorf("invalid file filter [%s], regexp compile full path: [%v]", ff.raw, err) - } - return nil -} diff --git a/vendor/github.com/mgechev/revive/lint/formatter.go b/vendor/github.com/mgechev/revive/lint/formatter.go deleted file mode 100644 index 7c19af278..000000000 --- a/vendor/github.com/mgechev/revive/lint/formatter.go +++ /dev/null @@ -1,14 +0,0 @@ -package lint - -// FormatterMetadata configuration of a formatter -type FormatterMetadata struct { - Name string - Description string - Sample string -} - -// Formatter defines an interface for failure formatters -type Formatter interface { - Format(<-chan Failure, Config) (string, error) - Name() string -} diff --git a/vendor/github.com/mgechev/revive/lint/linter.go b/vendor/github.com/mgechev/revive/lint/linter.go deleted file mode 100644 index b777f9251..000000000 --- a/vendor/github.com/mgechev/revive/lint/linter.go +++ /dev/null @@ -1,257 +0,0 @@ -package lint - -import ( - "bufio" - "bytes" - "fmt" - "go/token" - "os" - "path/filepath" - "regexp" - "strconv" - "strings" - "sync" - - goversion "github.com/hashicorp/go-version" - "golang.org/x/mod/modfile" -) - -// ReadFile defines an abstraction for reading files. -type ReadFile func(path string) (result []byte, err error) - -type disabledIntervalsMap = map[string][]DisabledInterval - -// Linter is used for linting set of files. -type Linter struct { - reader ReadFile - fileReadTokens chan struct{} -} - -// New creates a new Linter -func New(reader ReadFile, maxOpenFiles int) Linter { - var fileReadTokens chan struct{} - if maxOpenFiles > 0 { - fileReadTokens = make(chan struct{}, maxOpenFiles) - } - return Linter{ - reader: reader, - fileReadTokens: fileReadTokens, - } -} - -func (l Linter) readFile(path string) (result []byte, err error) { - if l.fileReadTokens != nil { - // "take" a token by writing to the channel. - // It will block if no more space in the channel's buffer - l.fileReadTokens <- struct{}{} - defer func() { - // "free" a token by reading from the channel - <-l.fileReadTokens - }() - } - - return l.reader(path) -} - -var ( - genHdr = []byte("// Code generated ") - genFtr = []byte(" DO NOT EDIT.") - defaultGoVersion = goversion.Must(goversion.NewVersion("1.0")) -) - -// Lint lints a set of files with the specified rule. -func (l *Linter) Lint(packages [][]string, ruleSet []Rule, config Config) (<-chan Failure, error) { - failures := make(chan Failure) - - perModVersions := make(map[string]*goversion.Version) - perPkgVersions := make([]*goversion.Version, len(packages)) - for n, files := range packages { - if len(files) == 0 { - continue - } - if config.GoVersion != nil { - perPkgVersions[n] = config.GoVersion - continue - } - - dir, err := filepath.Abs(filepath.Dir(files[0])) - if err != nil { - return nil, err - } - - alreadyKnownMod := false - for d, v := range perModVersions { - if strings.HasPrefix(dir, d) { - perPkgVersions[n] = v - alreadyKnownMod = true - break - } - } - if alreadyKnownMod { - continue - } - - d, v, err := detectGoMod(dir) - if err != nil { - // No luck finding the go.mod file thus set the default Go version - v = defaultGoVersion - d = dir - } - perModVersions[d] = v - perPkgVersions[n] = v - } - - var wg sync.WaitGroup - for n := range packages { - wg.Add(1) - go func(pkg []string, gover *goversion.Version) { - if err := l.lintPackage(pkg, gover, ruleSet, config, failures); err != nil { - fmt.Fprintln(os.Stderr, err) - os.Exit(1) - } - wg.Done() - }(packages[n], perPkgVersions[n]) - } - - go func() { - wg.Wait() - close(failures) - }() - - return failures, nil -} - -func (l *Linter) lintPackage(filenames []string, gover *goversion.Version, ruleSet []Rule, config Config, failures chan Failure) error { - if len(filenames) == 0 { - return nil - } - - pkg := &Package{ - fset: token.NewFileSet(), - files: map[string]*File{}, - goVersion: gover, - } - for _, filename := range filenames { - content, err := l.readFile(filename) - if err != nil { - return err - } - if !config.IgnoreGeneratedHeader && isGenerated(content) { - continue - } - - file, err := NewFile(filename, content, pkg) - if err != nil { - addInvalidFileFailure(filename, err.Error(), failures) - continue - } - pkg.files[filename] = file - } - - if len(pkg.files) == 0 { - return nil - } - - pkg.lint(ruleSet, config, failures) - - return nil -} - -func detectGoMod(dir string) (rootDir string, ver *goversion.Version, err error) { - modFileName, err := retrieveModFile(dir) - if err != nil { - return "", nil, fmt.Errorf("%q doesn't seem to be part of a Go module", dir) - } - - mod, err := os.ReadFile(modFileName) - if err != nil { - return "", nil, fmt.Errorf("failed to read %q, got %v", modFileName, err) - } - - modAst, err := modfile.ParseLax(modFileName, mod, nil) - if err != nil { - return "", nil, fmt.Errorf("failed to parse %q, got %v", modFileName, err) - } - - if modAst.Go == nil { - return "", nil, fmt.Errorf("%q does not specify a Go version", modFileName) - } - - ver, err = goversion.NewVersion(modAst.Go.Version) - return filepath.Dir(modFileName), ver, err -} - -func retrieveModFile(dir string) (string, error) { - const lookingForFile = "go.mod" - for { - // filepath.Dir returns 'C:\' on Windows, and '/' on Unix - isRootDir := (dir == filepath.VolumeName(dir)+string(filepath.Separator)) - if dir == "." || isRootDir { - return "", fmt.Errorf("did not found %q file", lookingForFile) - } - - lookingForFilePath := filepath.Join(dir, lookingForFile) - info, err := os.Stat(lookingForFilePath) - if err != nil || info.IsDir() { - // lets check the parent dir - dir = filepath.Dir(dir) - continue - } - - return lookingForFilePath, nil - } -} - -// isGenerated reports whether the source file is generated code -// according the rules from https://golang.org/s/generatedcode. -// This is inherited from the original go lint. -func isGenerated(src []byte) bool { - sc := bufio.NewScanner(bytes.NewReader(src)) - for sc.Scan() { - b := sc.Bytes() - if bytes.HasPrefix(b, genHdr) && bytes.HasSuffix(b, genFtr) && len(b) >= len(genHdr)+len(genFtr) { - return true - } - } - return false -} - -// addInvalidFileFailure adds a failure for an invalid formatted file -func addInvalidFileFailure(filename, errStr string, failures chan Failure) { - position := getPositionInvalidFile(filename, errStr) - failures <- Failure{ - Confidence: 1, - Failure: fmt.Sprintf("invalid file %s: %v", filename, errStr), - Category: "validity", - Position: position, - } -} - -// errPosRegexp matches with an NewFile error message -// i.e. : corrupted.go:10:4: expected '}', found 'EOF -// first group matches the line and the second group, the column -var errPosRegexp = regexp.MustCompile(`.*:(\d*):(\d*):.*$`) - -// getPositionInvalidFile gets the position of the error in an invalid file -func getPositionInvalidFile(filename, s string) FailurePosition { - pos := errPosRegexp.FindStringSubmatch(s) - if len(pos) < 3 { - return FailurePosition{} - } - line, err := strconv.Atoi(pos[1]) - if err != nil { - return FailurePosition{} - } - column, err := strconv.Atoi(pos[2]) - if err != nil { - return FailurePosition{} - } - - return FailurePosition{ - Start: token.Position{ - Filename: filename, - Line: line, - Column: column, - }, - } -} diff --git a/vendor/github.com/mgechev/revive/lint/name.go b/vendor/github.com/mgechev/revive/lint/name.go deleted file mode 100644 index 6ccfb0ef2..000000000 --- a/vendor/github.com/mgechev/revive/lint/name.go +++ /dev/null @@ -1,133 +0,0 @@ -package lint - -import ( - "strings" - "unicode" -) - -// Name returns a different name if it should be different. -func Name(name string, allowlist, blocklist []string) (should string) { - // Fast path for simple cases: "_" and all lowercase. - if name == "_" { - return name - } - allLower := true - for _, r := range name { - if !unicode.IsLower(r) { - allLower = false - break - } - } - if allLower { - return name - } - - // Split camelCase at any lower->upper transition, and split on underscores. - // Check each word for common initialisms. - runes := []rune(name) - w, i := 0, 0 // index of start of word, scan - for i+1 <= len(runes) { - eow := false // whether we hit the end of a word - if i+1 == len(runes) { - eow = true - } else if runes[i+1] == '_' { - // underscore; shift the remainder forward over any run of underscores - eow = true - n := 1 - for i+n+1 < len(runes) && runes[i+n+1] == '_' { - n++ - } - - // Leave at most one underscore if the underscore is between two digits - if i+n+1 < len(runes) && unicode.IsDigit(runes[i]) && unicode.IsDigit(runes[i+n+1]) { - n-- - } - - copy(runes[i+1:], runes[i+n+1:]) - runes = runes[:len(runes)-n] - } else if unicode.IsLower(runes[i]) && !unicode.IsLower(runes[i+1]) { - // lower->non-lower - eow = true - } - i++ - if !eow { - continue - } - - // [w,i) is a word. - word := string(runes[w:i]) - ignoreInitWarnings := map[string]bool{} - for _, i := range allowlist { - ignoreInitWarnings[i] = true - } - - extraInits := map[string]bool{} - for _, i := range blocklist { - extraInits[i] = true - } - - if u := strings.ToUpper(word); (commonInitialisms[u] || extraInits[u]) && !ignoreInitWarnings[u] { - // Keep consistent case, which is lowercase only at the start. - if w == 0 && unicode.IsLower(runes[w]) { - u = strings.ToLower(u) - } - // Keep lowercase s for IDs - if u == "IDS" { - u = "IDs" - } - // All the common initialisms are ASCII, - // so we can replace the bytes exactly. - copy(runes[w:], []rune(u)) - } else if w > 0 && strings.ToLower(word) == word { - // already all lowercase, and not the first word, so uppercase the first character. - runes[w] = unicode.ToUpper(runes[w]) - } - w = i - } - return string(runes) -} - -// commonInitialisms is a set of common initialisms. -// Only add entries that are highly unlikely to be non-initialisms. -// For instance, "ID" is fine (Freudian code is rare), but "AND" is not. -var commonInitialisms = map[string]bool{ - "ACL": true, - "API": true, - "ASCII": true, - "CPU": true, - "CSS": true, - "DNS": true, - "EOF": true, - "GUID": true, - "HTML": true, - "HTTP": true, - "HTTPS": true, - "ID": true, - "IDS": true, - "IP": true, - "JSON": true, - "LHS": true, - "QPS": true, - "RAM": true, - "RHS": true, - "RPC": true, - "SLA": true, - "SMTP": true, - "SQL": true, - "SSH": true, - "TCP": true, - "TLS": true, - "TTL": true, - "UDP": true, - "UI": true, - "UID": true, - "UUID": true, - "URI": true, - "URL": true, - "UTF8": true, - "VM": true, - "XML": true, - "XMPP": true, - "XSRF": true, - "XSS": true, -} diff --git a/vendor/github.com/mgechev/revive/lint/package.go b/vendor/github.com/mgechev/revive/lint/package.go deleted file mode 100644 index 4a633f35a..000000000 --- a/vendor/github.com/mgechev/revive/lint/package.go +++ /dev/null @@ -1,206 +0,0 @@ -package lint - -import ( - "go/ast" - "go/importer" - "go/token" - "go/types" - "sync" - - goversion "github.com/hashicorp/go-version" - - "github.com/mgechev/revive/internal/typeparams" -) - -// Package represents a package in the project. -type Package struct { - fset *token.FileSet - files map[string]*File - goVersion *goversion.Version - - typesPkg *types.Package - typesInfo *types.Info - - // sortable is the set of types in the package that implement sort.Interface. - sortable map[string]bool - // main is whether this is a "main" package. - main int - sync.RWMutex -} - -var ( - trueValue = 1 - falseValue = 2 - notSet = 3 - - go121 = goversion.Must(goversion.NewVersion("1.21")) - go122 = goversion.Must(goversion.NewVersion("1.22")) -) - -// Files return package's files. -func (p *Package) Files() map[string]*File { - return p.files -} - -// IsMain returns if that's the main package. -func (p *Package) IsMain() bool { - p.Lock() - defer p.Unlock() - - if p.main == trueValue { - return true - } else if p.main == falseValue { - return false - } - for _, f := range p.files { - if f.isMain() { - p.main = trueValue - return true - } - } - p.main = falseValue - return false -} - -// TypesPkg yields information on this package -func (p *Package) TypesPkg() *types.Package { - p.RLock() - defer p.RUnlock() - return p.typesPkg -} - -// TypesInfo yields type information of this package identifiers -func (p *Package) TypesInfo() *types.Info { - p.RLock() - defer p.RUnlock() - return p.typesInfo -} - -// Sortable yields a map of sortable types in this package -func (p *Package) Sortable() map[string]bool { - p.RLock() - defer p.RUnlock() - return p.sortable -} - -// TypeCheck performs type checking for given package. -func (p *Package) TypeCheck() error { - p.Lock() - defer p.Unlock() - - // If type checking has already been performed - // skip it. - if p.typesInfo != nil || p.typesPkg != nil { - return nil - } - config := &types.Config{ - // By setting a no-op error reporter, the type checker does as much work as possible. - Error: func(error) {}, - Importer: importer.Default(), - } - info := &types.Info{ - Types: make(map[ast.Expr]types.TypeAndValue), - Defs: make(map[*ast.Ident]types.Object), - Uses: make(map[*ast.Ident]types.Object), - Scopes: make(map[ast.Node]*types.Scope), - } - var anyFile *File - var astFiles []*ast.File - for _, f := range p.files { - anyFile = f - astFiles = append(astFiles, f.AST) - } - - typesPkg, err := check(config, anyFile.AST.Name.Name, p.fset, astFiles, info) - - // Remember the typechecking info, even if config.Check failed, - // since we will get partial information. - p.typesPkg = typesPkg - p.typesInfo = info - - return err -} - -// check function encapsulates the call to go/types.Config.Check method and -// recovers if the called method panics (see issue #59) -func check(config *types.Config, n string, fset *token.FileSet, astFiles []*ast.File, info *types.Info) (p *types.Package, err error) { - defer func() { - if r := recover(); r != nil { - err, _ = r.(error) - p = nil - return - } - }() - - return config.Check(n, fset, astFiles, info) -} - -// TypeOf returns the type of an expression. -func (p *Package) TypeOf(expr ast.Expr) types.Type { - if p.typesInfo == nil { - return nil - } - return p.typesInfo.TypeOf(expr) -} - -type walker struct { - nmap map[string]int - has map[string]int -} - -func (w *walker) Visit(n ast.Node) ast.Visitor { - fn, ok := n.(*ast.FuncDecl) - if !ok || fn.Recv == nil || len(fn.Recv.List) == 0 { - return w - } - // TODO(dsymonds): We could check the signature to be more precise. - recv := typeparams.ReceiverType(fn) - if i, ok := w.nmap[fn.Name.Name]; ok { - w.has[recv] |= i - } - return w -} - -func (p *Package) scanSortable() { - p.sortable = make(map[string]bool) - - // bitfield for which methods exist on each type. - const ( - bfLen = 1 << iota - bfLess - bfSwap - ) - nmap := map[string]int{"Len": bfLen, "Less": bfLess, "Swap": bfSwap} - has := make(map[string]int) - for _, f := range p.files { - ast.Walk(&walker{nmap, has}, f.AST) - } - for typ, ms := range has { - if ms == bfLen|bfLess|bfSwap { - p.sortable[typ] = true - } - } -} - -func (p *Package) lint(rules []Rule, config Config, failures chan Failure) { - p.scanSortable() - var wg sync.WaitGroup - for _, file := range p.files { - wg.Add(1) - go (func(file *File) { - file.lint(rules, config, failures) - wg.Done() - })(file) - } - wg.Wait() -} - -// IsAtLeastGo121 returns true if the Go version for this package is 1.21 or higher, false otherwise -func (p *Package) IsAtLeastGo121() bool { - return p.goVersion.GreaterThanOrEqual(go121) -} - -// IsAtLeastGo122 returns true if the Go version for this package is 1.22 or higher, false otherwise -func (p *Package) IsAtLeastGo122() bool { - return p.goVersion.GreaterThanOrEqual(go122) -} diff --git a/vendor/github.com/mgechev/revive/lint/rule.go b/vendor/github.com/mgechev/revive/lint/rule.go deleted file mode 100644 index ccc66691c..000000000 --- a/vendor/github.com/mgechev/revive/lint/rule.go +++ /dev/null @@ -1,31 +0,0 @@ -package lint - -import ( - "go/token" -) - -// DisabledInterval contains a single disabled interval and the associated rule name. -type DisabledInterval struct { - From token.Position - To token.Position - RuleName string -} - -// Rule defines an abstract rule interface -type Rule interface { - Name() string - Apply(*File, Arguments) []Failure -} - -// AbstractRule defines an abstract rule. -type AbstractRule struct { - Failures []Failure -} - -// ToFailurePosition returns the failure position. -func ToFailurePosition(start, end token.Pos, file *File) FailurePosition { - return FailurePosition{ - Start: file.ToPosition(start), - End: file.ToPosition(end), - } -} diff --git a/vendor/github.com/mgechev/revive/rule/add_constant.go b/vendor/github.com/mgechev/revive/rule/add_constant.go deleted file mode 100644 index 399382c8b..000000000 --- a/vendor/github.com/mgechev/revive/rule/add_constant.go +++ /dev/null @@ -1,267 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "regexp" - "strconv" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -const ( - defaultStrLitLimit = 2 - kindFLOAT = "FLOAT" - kindINT = "INT" - kindSTRING = "STRING" -) - -type allowList map[string]map[string]bool - -func newAllowList() allowList { - return map[string]map[string]bool{kindINT: {}, kindFLOAT: {}, kindSTRING: {}} -} - -func (wl allowList) add(kind, list string) { - elems := strings.Split(list, ",") - for _, e := range elems { - wl[kind][e] = true - } -} - -// AddConstantRule lints unused params in functions. -type AddConstantRule struct { - allowList allowList - ignoreFunctions []*regexp.Regexp - strLitLimit int - - configureOnce sync.Once -} - -// Apply applies the rule to given file. -func (r *AddConstantRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := &lintAddConstantRule{ - onFailure: onFailure, - strLits: make(map[string]int), - strLitLimit: r.strLitLimit, - allowList: r.allowList, - ignoreFunctions: r.ignoreFunctions, - structTags: make(map[*ast.BasicLit]struct{}), - } - - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*AddConstantRule) Name() string { - return "add-constant" -} - -type lintAddConstantRule struct { - onFailure func(lint.Failure) - strLits map[string]int - strLitLimit int - allowList allowList - ignoreFunctions []*regexp.Regexp - structTags map[*ast.BasicLit]struct{} -} - -func (w *lintAddConstantRule) Visit(node ast.Node) ast.Visitor { - if node == nil { - return nil - } - - switch n := node.(type) { - case *ast.CallExpr: - w.checkFunc(n) - return nil - case *ast.GenDecl: - return nil // skip declarations - case *ast.BasicLit: - if !w.isStructTag(n) { - w.checkLit(n) - } - case *ast.StructType: - if n.Fields != nil { - for _, field := range n.Fields.List { - if field.Tag != nil { - w.structTags[field.Tag] = struct{}{} - } - } - } - } - - return w -} - -func (w *lintAddConstantRule) checkFunc(expr *ast.CallExpr) { - fName := w.getFuncName(expr) - - for _, arg := range expr.Args { - switch t := arg.(type) { - case *ast.CallExpr: - w.checkFunc(t) - case *ast.BasicLit: - if w.isIgnoredFunc(fName) { - continue - } - w.checkLit(t) - } - } -} - -func (*lintAddConstantRule) getFuncName(expr *ast.CallExpr) string { - switch f := expr.Fun.(type) { - case *ast.SelectorExpr: - switch prefix := f.X.(type) { - case *ast.Ident: - return prefix.Name + "." + f.Sel.Name - case *ast.CallExpr: - // If the selector is an CallExpr, like `fn().Info`, we return `.Info` as function name - if f.Sel != nil { - return "." + f.Sel.Name - } - } - case *ast.Ident: - return f.Name - } - - return "" -} - -func (w *lintAddConstantRule) checkLit(n *ast.BasicLit) { - switch kind := n.Kind.String(); kind { - case kindFLOAT, kindINT: - w.checkNumLit(kind, n) - case kindSTRING: - w.checkStrLit(n) - } -} - -func (w *lintAddConstantRule) isIgnoredFunc(fName string) bool { - for _, pattern := range w.ignoreFunctions { - if pattern.MatchString(fName) { - return true - } - } - - return false -} - -func (w *lintAddConstantRule) checkStrLit(n *ast.BasicLit) { - const ignoreMarker = -1 - - if w.allowList[kindSTRING][n.Value] { - return - } - - count := w.strLits[n.Value] - mustCheck := count > ignoreMarker - if mustCheck { - w.strLits[n.Value] = count + 1 - if w.strLits[n.Value] > w.strLitLimit { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: n, - Category: "style", - Failure: fmt.Sprintf("string literal %s appears, at least, %d times, create a named constant for it", n.Value, w.strLits[n.Value]), - }) - w.strLits[n.Value] = -1 // mark it to avoid failing again on the same literal - } - } -} - -func (w *lintAddConstantRule) checkNumLit(kind string, n *ast.BasicLit) { - if w.allowList[kind][n.Value] { - return - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: n, - Category: "style", - Failure: fmt.Sprintf("avoid magic numbers like '%s', create a named constant for it", n.Value), - }) -} - -func (w *lintAddConstantRule) isStructTag(n *ast.BasicLit) bool { - _, ok := w.structTags[n] - return ok -} - -func (r *AddConstantRule) configure(arguments lint.Arguments) { - if r.allowList == nil { - r.strLitLimit = defaultStrLitLimit - r.allowList = newAllowList() - if len(arguments) > 0 { - args, ok := arguments[0].(map[string]any) - if !ok { - panic(fmt.Sprintf("Invalid argument to the add-constant rule. Expecting a k,v map, got %T", arguments[0])) - } - for k, v := range args { - kind := "" - switch k { - case "allowFloats": - kind = kindFLOAT - fallthrough - case "allowInts": - if kind == "" { - kind = kindINT - } - fallthrough - case "allowStrs": - if kind == "" { - kind = kindSTRING - } - list, ok := v.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the add-constant rule, string expected. Got '%v' (%T)", v, v)) - } - r.allowList.add(kind, list) - case "maxLitCount": - sl, ok := v.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v' (%T)", v, v)) - } - - limit, err := strconv.Atoi(sl) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v'", v)) - } - r.strLitLimit = limit - case "ignoreFuncs": - excludes, ok := v.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule, string expected. Got '%v' (%T)", v, v)) - } - - for _, exclude := range strings.Split(excludes, ",") { - exclude = strings.Trim(exclude, " ") - if exclude == "" { - panic("Invalid argument to the ignoreFuncs parameter of add-constant rule, expected regular expression must not be empty.") - } - - exp, err := regexp.Compile(exclude) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule: regexp %q does not compile: %v", exclude, err)) - } - - r.ignoreFunctions = append(r.ignoreFunctions, exp) - } - } - } - } - } -} diff --git a/vendor/github.com/mgechev/revive/rule/argument_limit.go b/vendor/github.com/mgechev/revive/rule/argument_limit.go deleted file mode 100644 index b4d56de0e..000000000 --- a/vendor/github.com/mgechev/revive/rule/argument_limit.go +++ /dev/null @@ -1,84 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -// ArgumentsLimitRule lints given else constructs. -type ArgumentsLimitRule struct { - max int - - configureOnce sync.Once -} - -const defaultArgumentsLimit = 8 - -func (r *ArgumentsLimitRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.max = defaultArgumentsLimit - return - } - - maxArguments, ok := arguments[0].(int64) // Alt. non panicking version - if !ok { - panic(`invalid value passed as argument number to the "argument-limit" rule`) - } - r.max = int(maxArguments) -} - -// Apply applies the rule to given file. -func (r *ArgumentsLimitRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - walker := lintArgsNum{ - max: r.max, - onFailure: onFailure, - } - - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*ArgumentsLimitRule) Name() string { - return "argument-limit" -} - -type lintArgsNum struct { - max int - onFailure func(lint.Failure) -} - -func (w lintArgsNum) Visit(n ast.Node) ast.Visitor { - node, ok := n.(*ast.FuncDecl) - if !ok { - return w - } - - num := 0 - for _, l := range node.Type.Params.List { - for range l.Names { - num++ - } - } - - if num > w.max { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("maximum number of arguments per function exceeded; max %d but got %d", w.max, num), - Node: node.Type, - }) - } - - return nil // skip visiting the body of the function -} diff --git a/vendor/github.com/mgechev/revive/rule/atomic.go b/vendor/github.com/mgechev/revive/rule/atomic.go deleted file mode 100644 index 287b28c21..000000000 --- a/vendor/github.com/mgechev/revive/rule/atomic.go +++ /dev/null @@ -1,94 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - "go/types" - - "github.com/mgechev/revive/lint" -) - -// AtomicRule lints given else constructs. -type AtomicRule struct{} - -// Apply applies the rule to given file. -func (*AtomicRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - walker := atomic{ - pkgTypesInfo: file.Pkg.TypesInfo(), - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*AtomicRule) Name() string { - return "atomic" -} - -type atomic struct { - pkgTypesInfo *types.Info - onFailure func(lint.Failure) -} - -func (w atomic) Visit(node ast.Node) ast.Visitor { - n, ok := node.(*ast.AssignStmt) - if !ok { - return w - } - - if len(n.Lhs) != len(n.Rhs) { - return nil // skip assignment sub-tree - } - if len(n.Lhs) == 1 && n.Tok == token.DEFINE { - return nil // skip assignment sub-tree - } - - for i, right := range n.Rhs { - call, ok := right.(*ast.CallExpr) - if !ok { - continue - } - sel, ok := call.Fun.(*ast.SelectorExpr) - if !ok { - continue - } - pkgIdent, _ := sel.X.(*ast.Ident) - if w.pkgTypesInfo != nil { - pkgName, ok := w.pkgTypesInfo.Uses[pkgIdent].(*types.PkgName) - if !ok || pkgName.Imported().Path() != "sync/atomic" { - continue - } - } - - switch sel.Sel.Name { - case "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr": - left := n.Lhs[i] - if len(call.Args) != 2 { - continue - } - arg := call.Args[0] - broken := false - - if uarg, ok := arg.(*ast.UnaryExpr); ok && uarg.Op == token.AND { - broken = gofmt(left) == gofmt(uarg.X) - } else if star, ok := left.(*ast.StarExpr); ok { - broken = gofmt(star.X) == gofmt(arg) - } - - if broken { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: "direct assignment to atomic value", - Node: n, - }) - } - } - } - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/banned_characters.go b/vendor/github.com/mgechev/revive/rule/banned_characters.go deleted file mode 100644 index 926b32c21..000000000 --- a/vendor/github.com/mgechev/revive/rule/banned_characters.go +++ /dev/null @@ -1,89 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// BannedCharsRule checks if a file contains banned characters. -type BannedCharsRule struct { - bannedCharList []string - - configureOnce sync.Once -} - -const bannedCharsRuleName = "banned-characters" - -func (r *BannedCharsRule) configure(arguments lint.Arguments) { - if len(arguments) > 0 { - checkNumberOfArguments(1, arguments, bannedCharsRuleName) - r.bannedCharList = r.getBannedCharsList(arguments) - } -} - -// Apply applied the rule to the given file. -func (r *BannedCharsRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintBannedCharsRule{ - bannedChars: r.bannedCharList, - onFailure: onFailure, - } - - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name -func (*BannedCharsRule) Name() string { - return bannedCharsRuleName -} - -// getBannedCharsList converts arguments into the banned characters list -func (r *BannedCharsRule) getBannedCharsList(args lint.Arguments) []string { - var bannedChars []string - for _, char := range args { - charStr, ok := char.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument for the %s rule: expecting a string, got %T", r.Name(), char)) - } - bannedChars = append(bannedChars, charStr) - } - - return bannedChars -} - -type lintBannedCharsRule struct { - bannedChars []string - onFailure func(lint.Failure) -} - -// Visit checks for each node if an identifier contains banned characters -func (w lintBannedCharsRule) Visit(node ast.Node) ast.Visitor { - n, ok := node.(*ast.Ident) - if !ok { - return w - } - for _, c := range w.bannedChars { - ok := strings.Contains(n.Name, c) - if ok { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("banned character found: %s", c), - RuleName: bannedCharsRuleName, - Node: n, - }) - } - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/bare_return.go b/vendor/github.com/mgechev/revive/rule/bare_return.go deleted file mode 100644 index 147fa84db..000000000 --- a/vendor/github.com/mgechev/revive/rule/bare_return.go +++ /dev/null @@ -1,84 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// BareReturnRule lints given else constructs. -type BareReturnRule struct{} - -// Apply applies the rule to given file. -func (*BareReturnRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintBareReturnRule{onFailure: onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*BareReturnRule) Name() string { - return "bare-return" -} - -type lintBareReturnRule struct { - onFailure func(lint.Failure) -} - -func (w lintBareReturnRule) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.FuncDecl: - w.checkFunc(n.Type.Results, n.Body) - case *ast.FuncLit: // to cope with deferred functions and go-routines - w.checkFunc(n.Type.Results, n.Body) - } - - return w -} - -// checkFunc will verify if the given function has named result and bare returns -func (w lintBareReturnRule) checkFunc(results *ast.FieldList, body *ast.BlockStmt) { - hasNamedResults := results != nil && len(results.List) > 0 && results.List[0].Names != nil - if !hasNamedResults || body == nil { - return // nothing to do - } - - brf := bareReturnFinder{w.onFailure} - ast.Walk(brf, body) -} - -type bareReturnFinder struct { - onFailure func(lint.Failure) -} - -func (w bareReturnFinder) Visit(node ast.Node) ast.Visitor { - _, ok := node.(*ast.FuncLit) - if ok { - // skip analysing function literals - // they will be analysed by the lintBareReturnRule.Visit method - return nil - } - - rs, ok := node.(*ast.ReturnStmt) - if !ok { - return w - } - - if len(rs.Results) > 0 { - return w - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: rs, - Failure: "avoid using bare returns, please add return expressions", - }) - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/blank_imports.go b/vendor/github.com/mgechev/revive/rule/blank_imports.go deleted file mode 100644 index 0ddb4aad2..000000000 --- a/vendor/github.com/mgechev/revive/rule/blank_imports.go +++ /dev/null @@ -1,75 +0,0 @@ -package rule - -import ( - "go/ast" - "strings" - - "github.com/mgechev/revive/lint" -) - -// BlankImportsRule lints given else constructs. -type BlankImportsRule struct{} - -// Name returns the rule name. -func (*BlankImportsRule) Name() string { - return "blank-imports" -} - -// Apply applies the rule to given file. -func (r *BlankImportsRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - if file.Pkg.IsMain() || file.IsTest() { - return nil - } - - const ( - message = "a blank import should be only in a main or test package, or have a comment justifying it" - category = "imports" - embedImportPath = `"embed"` - ) - - var failures []lint.Failure - - // The first element of each contiguous group of blank imports should have - // an explanatory comment of some kind. - for i, imp := range file.AST.Imports { - pos := file.ToPosition(imp.Pos()) - - if !isBlank(imp.Name) { - continue // Ignore non-blank imports. - } - - isNotFirstElement := i > 0 - if isNotFirstElement { - prev := file.AST.Imports[i-1] - prevPos := file.ToPosition(prev.Pos()) - - isSubsequentBlancInAGroup := prevPos.Line+1 == pos.Line && prev.Path.Value != embedImportPath && isBlank(prev.Name) - if isSubsequentBlancInAGroup { - continue - } - } - - if imp.Path.Value == embedImportPath && r.fileHasValidEmbedComment(file.AST) { - continue - } - - // This is the first blank import of a group. - if imp.Doc == nil && imp.Comment == nil { - failures = append(failures, lint.Failure{Failure: message, Category: category, Node: imp, Confidence: 1}) - } - } - - return failures -} - -func (*BlankImportsRule) fileHasValidEmbedComment(fileAst *ast.File) bool { - for _, commentGroup := range fileAst.Comments { - for _, comment := range commentGroup.List { - if strings.HasPrefix(comment.Text, "//go:embed ") { - return true - } - } - } - - return false -} diff --git a/vendor/github.com/mgechev/revive/rule/bool_literal_in_expr.go b/vendor/github.com/mgechev/revive/rule/bool_literal_in_expr.go deleted file mode 100644 index 71551e55a..000000000 --- a/vendor/github.com/mgechev/revive/rule/bool_literal_in_expr.go +++ /dev/null @@ -1,72 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// BoolLiteralRule warns when logic expressions contains Boolean literals. -type BoolLiteralRule struct{} - -// Apply applies the rule to given file. -func (*BoolLiteralRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - astFile := file.AST - w := &lintBoolLiteral{astFile, onFailure} - ast.Walk(w, astFile) - - return failures -} - -// Name returns the rule name. -func (*BoolLiteralRule) Name() string { - return "bool-literal-in-expr" -} - -type lintBoolLiteral struct { - file *ast.File - onFailure func(lint.Failure) -} - -func (w *lintBoolLiteral) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.BinaryExpr: - if !isBoolOp(n.Op) { - return w - } - - lexeme, ok := isExprABooleanLit(n.X) - if !ok { - lexeme, ok = isExprABooleanLit(n.Y) - if !ok { - return w - } - } - - isConstant := (n.Op == token.LAND && lexeme == "false") || (n.Op == token.LOR && lexeme == "true") - - if isConstant { - w.addFailure(n, "Boolean expression seems to always evaluate to "+lexeme, "logic") - } else { - w.addFailure(n, "omit Boolean literal in expression", "style") - } - } - - return w -} - -func (w lintBoolLiteral) addFailure(node ast.Node, msg, cat string) { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: node, - Category: cat, - Failure: msg, - }) -} diff --git a/vendor/github.com/mgechev/revive/rule/call_to_gc.go b/vendor/github.com/mgechev/revive/rule/call_to_gc.go deleted file mode 100644 index 9c68380a4..000000000 --- a/vendor/github.com/mgechev/revive/rule/call_to_gc.go +++ /dev/null @@ -1,70 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// CallToGCRule lints calls to the garbage collector. -type CallToGCRule struct{} - -// Apply applies the rule to given file. -func (*CallToGCRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - gcTriggeringFunctions := map[string]map[string]bool{ - "runtime": {"GC": true}, - } - - w := lintCallToGC{onFailure, gcTriggeringFunctions} - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*CallToGCRule) Name() string { - return "call-to-gc" -} - -type lintCallToGC struct { - onFailure func(lint.Failure) - gcTriggeringFunctions map[string]map[string]bool -} - -func (w lintCallToGC) Visit(node ast.Node) ast.Visitor { - ce, ok := node.(*ast.CallExpr) - if !ok { - return w // nothing to do, the node is not a call - } - - fc, ok := ce.Fun.(*ast.SelectorExpr) - if !ok { - return nil // nothing to do, the call is not of the form pkg.func(...) - } - - id, ok := fc.X.(*ast.Ident) - - if !ok { - return nil // in case X is not an id (it should be!) - } - - fn := fc.Sel.Name - pkg := id.Name - if !w.gcTriggeringFunctions[pkg][fn] { - return nil // it isn't a call to a GC triggering function - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: node, - Category: "bad practice", - Failure: "explicit call to the garbage collector", - }) - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/cognitive_complexity.go b/vendor/github.com/mgechev/revive/rule/cognitive_complexity.go deleted file mode 100644 index ecde3882e..000000000 --- a/vendor/github.com/mgechev/revive/rule/cognitive_complexity.go +++ /dev/null @@ -1,209 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "sync" - - "github.com/mgechev/revive/lint" - "golang.org/x/tools/go/ast/astutil" -) - -// CognitiveComplexityRule lints given else constructs. -type CognitiveComplexityRule struct { - maxComplexity int - - configureOnce sync.Once -} - -const defaultMaxCognitiveComplexity = 7 - -func (r *CognitiveComplexityRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.maxComplexity = defaultMaxCognitiveComplexity - return - } - - complexity, ok := arguments[0].(int64) - if !ok { - panic(fmt.Sprintf("invalid argument type for cognitive-complexity, expected int64, got %T", arguments[0])) - } - - r.maxComplexity = int(complexity) -} - -// Apply applies the rule to given file. -func (r *CognitiveComplexityRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - linter := cognitiveComplexityLinter{ - file: file, - maxComplexity: r.maxComplexity, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - linter.lintCognitiveComplexity() - - return failures -} - -// Name returns the rule name. -func (*CognitiveComplexityRule) Name() string { - return "cognitive-complexity" -} - -type cognitiveComplexityLinter struct { - file *lint.File - maxComplexity int - onFailure func(lint.Failure) -} - -func (w cognitiveComplexityLinter) lintCognitiveComplexity() { - f := w.file - for _, decl := range f.AST.Decls { - if fn, ok := decl.(*ast.FuncDecl); ok && fn.Body != nil { - v := cognitiveComplexityVisitor{} - c := v.subTreeComplexity(fn.Body) - if c > w.maxComplexity { - w.onFailure(lint.Failure{ - Confidence: 1, - Category: "maintenance", - Failure: fmt.Sprintf("function %s has cognitive complexity %d (> max enabled %d)", funcName(fn), c, w.maxComplexity), - Node: fn, - }) - } - } - } -} - -type cognitiveComplexityVisitor struct { - complexity int - nestingLevel int -} - -// subTreeComplexity calculates the cognitive complexity of an AST-subtree. -func (v cognitiveComplexityVisitor) subTreeComplexity(n ast.Node) int { - ast.Walk(&v, n) - return v.complexity -} - -// Visit implements the ast.Visitor interface. -func (v *cognitiveComplexityVisitor) Visit(n ast.Node) ast.Visitor { - switch n := n.(type) { - case *ast.IfStmt: - targets := []ast.Node{n.Cond, n.Body, n.Else} - v.walk(1, targets...) - return nil - case *ast.ForStmt: - targets := []ast.Node{n.Cond, n.Body} - v.walk(1, targets...) - return nil - case *ast.RangeStmt: - v.walk(1, n.Body) - return nil - case *ast.SelectStmt: - v.walk(1, n.Body) - return nil - case *ast.SwitchStmt: - v.walk(1, n.Body) - return nil - case *ast.TypeSwitchStmt: - v.walk(1, n.Body) - return nil - case *ast.FuncLit: - v.walk(0, n.Body) // do not increment the complexity, just do the nesting - return nil - case *ast.BinaryExpr: - v.complexity += v.binExpComplexity(n) - return nil // skip visiting binexp sub-tree (already visited by binExpComplexity) - case *ast.BranchStmt: - if n.Label != nil { - v.complexity++ - } - } - // TODO handle (at least) direct recursion - - return v -} - -func (v *cognitiveComplexityVisitor) walk(complexityIncrement int, targets ...ast.Node) { - v.complexity += complexityIncrement + v.nestingLevel - nesting := v.nestingLevel - v.nestingLevel++ - - for _, t := range targets { - if t == nil { - continue - } - - ast.Walk(v, t) - } - - v.nestingLevel = nesting -} - -func (cognitiveComplexityVisitor) binExpComplexity(n *ast.BinaryExpr) int { - calculator := binExprComplexityCalculator{opsStack: []token.Token{}} - - astutil.Apply(n, calculator.pre, calculator.post) - - return calculator.complexity -} - -type binExprComplexityCalculator struct { - complexity int - opsStack []token.Token // stack of bool operators - subexpStarted bool -} - -func (becc *binExprComplexityCalculator) pre(c *astutil.Cursor) bool { - switch n := c.Node().(type) { - case *ast.BinaryExpr: - isBoolOp := n.Op == token.LAND || n.Op == token.LOR - if !isBoolOp { - break - } - - ops := len(becc.opsStack) - // if - // is the first boolop in the expression OR - // is the first boolop inside a subexpression (...) OR - // is not the same to the previous one - // then - // increment complexity - if ops == 0 || becc.subexpStarted || n.Op != becc.opsStack[ops-1] { - becc.complexity++ - becc.subexpStarted = false - } - - becc.opsStack = append(becc.opsStack, n.Op) - case *ast.ParenExpr: - becc.subexpStarted = true - } - - return true -} - -func (becc *binExprComplexityCalculator) post(c *astutil.Cursor) bool { - switch n := c.Node().(type) { - case *ast.BinaryExpr: - isBoolOp := n.Op == token.LAND || n.Op == token.LOR - if !isBoolOp { - break - } - - ops := len(becc.opsStack) - if ops > 0 { - becc.opsStack = becc.opsStack[:ops-1] - } - case *ast.ParenExpr: - becc.subexpStarted = false - } - - return true -} diff --git a/vendor/github.com/mgechev/revive/rule/comment_spacings.go b/vendor/github.com/mgechev/revive/rule/comment_spacings.go deleted file mode 100644 index 7bdc0e71d..000000000 --- a/vendor/github.com/mgechev/revive/rule/comment_spacings.go +++ /dev/null @@ -1,82 +0,0 @@ -package rule - -import ( - "fmt" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// CommentSpacingsRule check the whether there is a space between -// the comment symbol( // ) and the start of the comment text -type CommentSpacingsRule struct { - allowList []string - - configureOnce sync.Once -} - -func (r *CommentSpacingsRule) configure(arguments lint.Arguments) { - r.allowList = []string{} - for _, arg := range arguments { - allow, ok := arg.(string) // Alt. non panicking version - if !ok { - panic(fmt.Sprintf("invalid argument %v for %s; expected string but got %T", arg, r.Name(), arg)) - } - r.allowList = append(r.allowList, `//`+allow) - } -} - -// Apply the rule. -func (r *CommentSpacingsRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - - var failures []lint.Failure - - for _, cg := range file.AST.Comments { - for _, comment := range cg.List { - commentLine := comment.Text - if len(commentLine) < 3 { - continue // nothing to do - } - - isMultiLineComment := commentLine[1] == '*' - isOK := commentLine[2] == '\n' - if isMultiLineComment && isOK { - continue - } - - isOK = (commentLine[2] == ' ') || (commentLine[2] == '\t') - if isOK { - continue - } - - if r.isAllowed(commentLine) { - continue - } - - failures = append(failures, lint.Failure{ - Node: comment, - Confidence: 1, - Category: "style", - Failure: "no space between comment delimiter and comment text", - }) - } - } - return failures -} - -// Name yields this rule name. -func (*CommentSpacingsRule) Name() string { - return "comment-spacings" -} - -func (r *CommentSpacingsRule) isAllowed(line string) bool { - for _, allow := range r.allowList { - if strings.HasPrefix(line, allow) { - return true - } - } - - return isDirectiveComment(line) -} diff --git a/vendor/github.com/mgechev/revive/rule/comments_density.go b/vendor/github.com/mgechev/revive/rule/comments_density.go deleted file mode 100644 index f2382b1f0..000000000 --- a/vendor/github.com/mgechev/revive/rule/comments_density.go +++ /dev/null @@ -1,87 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// CommentsDensityRule lints given else constructs. -type CommentsDensityRule struct { - minimumCommentsDensity int64 - - configureOnce sync.Once -} - -const defaultMinimumCommentsPercentage = 0 - -func (r *CommentsDensityRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.minimumCommentsDensity = defaultMinimumCommentsPercentage - return - } - - var ok bool - r.minimumCommentsDensity, ok = arguments[0].(int64) - if !ok { - panic(fmt.Sprintf("invalid argument for %q rule: argument should be an int, got %T", r.Name(), arguments[0])) - } -} - -// Apply applies the rule to given file. -func (r *CommentsDensityRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - commentsLines := countDocLines(file.AST.Comments) - statementsCount := countStatements(file.AST) - density := (float32(commentsLines) / float32(statementsCount+commentsLines)) * 100 - - if density < float32(r.minimumCommentsDensity) { - return []lint.Failure{ - { - Node: file.AST, - Confidence: 1, - Failure: fmt.Sprintf("the file has a comment density of %2.f%% (%d comment lines for %d code lines) but expected a minimum of %d%%", - density, commentsLines, statementsCount, r.minimumCommentsDensity), - }, - } - } - - return nil -} - -// Name returns the rule name. -func (*CommentsDensityRule) Name() string { - return "comments-density" -} - -// countStatements counts the number of program statements in the given AST. -func countStatements(node ast.Node) int { - counter := 0 - - ast.Inspect(node, func(n ast.Node) bool { - switch n.(type) { - case *ast.ExprStmt, *ast.AssignStmt, *ast.ReturnStmt, *ast.GoStmt, *ast.DeferStmt, - *ast.BranchStmt, *ast.IfStmt, *ast.SwitchStmt, *ast.TypeSwitchStmt, - *ast.SelectStmt, *ast.ForStmt, *ast.RangeStmt, *ast.CaseClause, *ast.CommClause, - *ast.DeclStmt, *ast.FuncDecl: - counter++ - } - return true - }) - - return counter -} - -func countDocLines(comments []*ast.CommentGroup) int { - acc := 0 - for _, c := range comments { - lines := strings.Split(c.Text(), "\n") - acc += len(lines) - 1 - } - - return acc -} diff --git a/vendor/github.com/mgechev/revive/rule/confusing_naming.go b/vendor/github.com/mgechev/revive/rule/confusing_naming.go deleted file mode 100644 index 32f6dd803..000000000 --- a/vendor/github.com/mgechev/revive/rule/confusing_naming.go +++ /dev/null @@ -1,207 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -type referenceMethod struct { - fileName string - id *ast.Ident -} - -type pkgMethods struct { - pkg *lint.Package - methods map[string]map[string]*referenceMethod - mu *sync.Mutex -} - -type packages struct { - pkgs []pkgMethods - mu sync.Mutex -} - -func (ps *packages) methodNames(lp *lint.Package) pkgMethods { - ps.mu.Lock() - defer ps.mu.Unlock() - - for _, pkg := range ps.pkgs { - if pkg.pkg == lp { - return pkg - } - } - - pkgm := pkgMethods{pkg: lp, methods: make(map[string]map[string]*referenceMethod), mu: &sync.Mutex{}} - ps.pkgs = append(ps.pkgs, pkgm) - - return pkgm -} - -var allPkgs = packages{pkgs: make([]pkgMethods, 1)} - -// ConfusingNamingRule lints method names that differ only by capitalization -type ConfusingNamingRule struct{} - -// Apply applies the rule to given file. -func (*ConfusingNamingRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - fileAst := file.AST - pkgm := allPkgs.methodNames(file.Pkg) - walker := lintConfusingNames{ - fileName: file.Name, - pkgm: pkgm, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(&walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ConfusingNamingRule) Name() string { - return "confusing-naming" -} - -// checkMethodName checks if a given method/function name is similar (just case differences) to other method/function of the same struct/file. -func checkMethodName(holder string, id *ast.Ident, w *lintConfusingNames) { - if id.Name == "init" && holder == defaultStructName { - // ignore init functions - return - } - - pkgm := w.pkgm - name := strings.ToUpper(id.Name) - - pkgm.mu.Lock() - defer pkgm.mu.Unlock() - - if pkgm.methods[holder] != nil { - if pkgm.methods[holder][name] != nil { - refMethod := pkgm.methods[holder][name] - // confusing names - var kind string - if holder == defaultStructName { - kind = "function" - } else { - kind = "method" - } - var fileName string - if w.fileName == refMethod.fileName { - fileName = "the same source file" - } else { - fileName = refMethod.fileName - } - w.onFailure(lint.Failure{ - Failure: fmt.Sprintf("Method '%s' differs only by capitalization to %s '%s' in %s", id.Name, kind, refMethod.id.Name, fileName), - Confidence: 1, - Node: id, - Category: "naming", - }) - - return - } - } else { - pkgm.methods[holder] = make(map[string]*referenceMethod, 1) - } - - // update the block list - if pkgm.methods[holder] == nil { - println("no entry for '", holder, "'") - } - pkgm.methods[holder][name] = &referenceMethod{fileName: w.fileName, id: id} -} - -type lintConfusingNames struct { - fileName string - pkgm pkgMethods - onFailure func(lint.Failure) -} - -const defaultStructName = "_" // used to map functions - -// getStructName of a function receiver. Defaults to defaultStructName -func getStructName(r *ast.FieldList) string { - result := defaultStructName - - if r == nil || len(r.List) < 1 { - return result - } - - t := r.List[0].Type - - switch v := t.(type) { - case *ast.StarExpr: - return extractFromStarExpr(v) - case *ast.IndexExpr: - return extractFromIndexExpr(v) - case *ast.Ident: - return v.Name - } - - return defaultStructName -} - -func extractFromStarExpr(expr *ast.StarExpr) string { - switch v := expr.X.(type) { - case *ast.IndexExpr: - return extractFromIndexExpr(v) - case *ast.Ident: - return v.Name - } - return defaultStructName -} - -func extractFromIndexExpr(expr *ast.IndexExpr) string { - switch v := expr.X.(type) { - case *ast.Ident: - return v.Name - } - return defaultStructName -} - -func checkStructFields(fields *ast.FieldList, structName string, w *lintConfusingNames) { - bl := make(map[string]bool, len(fields.List)) - for _, f := range fields.List { - for _, id := range f.Names { - normName := strings.ToUpper(id.Name) - if bl[normName] { - w.onFailure(lint.Failure{ - Failure: fmt.Sprintf("Field '%s' differs only by capitalization to other field in the struct type %s", id.Name, structName), - Confidence: 1, - Node: id, - Category: "naming", - }) - } else { - bl[normName] = true - } - } - } -} - -func (w *lintConfusingNames) Visit(n ast.Node) ast.Visitor { - switch v := n.(type) { - case *ast.FuncDecl: - // Exclude naming warnings for functions that are exported to C but - // not exported in the Go API. - // See https://github.com/golang/lint/issues/144. - if ast.IsExported(v.Name.Name) || !isCgoExported(v) { - checkMethodName(getStructName(v.Recv), v.Name, w) - } - case *ast.TypeSpec: - if s, ok := v.Type.(*ast.StructType); ok { - checkStructFields(s.Fields, v.Name.Name, w) - } - - default: - // will add other checks like field names, struct names, etc. - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/confusing_results.go b/vendor/github.com/mgechev/revive/rule/confusing_results.go deleted file mode 100644 index 1b79ada9c..000000000 --- a/vendor/github.com/mgechev/revive/rule/confusing_results.go +++ /dev/null @@ -1,66 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// ConfusingResultsRule lints given function declarations -type ConfusingResultsRule struct{} - -// Apply applies the rule to given file. -func (*ConfusingResultsRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := lintConfusingResults{ - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ConfusingResultsRule) Name() string { - return "confusing-results" -} - -type lintConfusingResults struct { - onFailure func(lint.Failure) -} - -func (w lintConfusingResults) Visit(n ast.Node) ast.Visitor { - fn, ok := n.(*ast.FuncDecl) - if !ok || fn.Type.Results == nil || len(fn.Type.Results.List) < 2 { - return w - } - lastType := "" - for _, result := range fn.Type.Results.List { - if len(result.Names) > 0 { - return w - } - - t, ok := result.Type.(*ast.Ident) - if !ok { - return w - } - - if t.Name == lastType { - w.onFailure(lint.Failure{ - Node: n, - Confidence: 1, - Category: "naming", - Failure: "unnamed results of the same type may be confusing, consider using named results", - }) - break - } - lastType = t.Name - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/constant_logical_expr.go b/vendor/github.com/mgechev/revive/rule/constant_logical_expr.go deleted file mode 100644 index 9e34d3d16..000000000 --- a/vendor/github.com/mgechev/revive/rule/constant_logical_expr.go +++ /dev/null @@ -1,101 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// ConstantLogicalExprRule warns on constant logical expressions. -type ConstantLogicalExprRule struct{} - -// Apply applies the rule to given file. -func (*ConstantLogicalExprRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - astFile := file.AST - w := &lintConstantLogicalExpr{astFile, onFailure} - ast.Walk(w, astFile) - return failures -} - -// Name returns the rule name. -func (*ConstantLogicalExprRule) Name() string { - return "constant-logical-expr" -} - -type lintConstantLogicalExpr struct { - file *ast.File - onFailure func(lint.Failure) -} - -func (w *lintConstantLogicalExpr) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.BinaryExpr: - if !w.isOperatorWithLogicalResult(n.Op) { - return w - } - - subExpressionsAreNotEqual := gofmt(n.X) != gofmt(n.Y) - if subExpressionsAreNotEqual { - return w // nothing to say - } - - // Handles cases like: a <= a, a == a, a >= a - if w.isEqualityOperator(n.Op) { - w.newFailure(n, "expression always evaluates to true") - return w - } - - // Handles cases like: a < a, a > a, a != a - if w.isInequalityOperator(n.Op) { - w.newFailure(n, "expression always evaluates to false") - return w - } - - w.newFailure(n, "left and right hand-side sub-expressions are the same") - } - - return w -} - -func (*lintConstantLogicalExpr) isOperatorWithLogicalResult(t token.Token) bool { - switch t { - case token.LAND, token.LOR, token.EQL, token.LSS, token.GTR, token.NEQ, token.LEQ, token.GEQ: - return true - } - - return false -} - -func (*lintConstantLogicalExpr) isEqualityOperator(t token.Token) bool { - switch t { - case token.EQL, token.LEQ, token.GEQ: - return true - } - - return false -} - -func (*lintConstantLogicalExpr) isInequalityOperator(t token.Token) bool { - switch t { - case token.LSS, token.GTR, token.NEQ: - return true - } - - return false -} - -func (w lintConstantLogicalExpr) newFailure(node ast.Node, msg string) { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: node, - Category: "logic", - Failure: msg, - }) -} diff --git a/vendor/github.com/mgechev/revive/rule/context_as_argument.go b/vendor/github.com/mgechev/revive/rule/context_as_argument.go deleted file mode 100644 index 8bc5f8b61..000000000 --- a/vendor/github.com/mgechev/revive/rule/context_as_argument.go +++ /dev/null @@ -1,109 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// ContextAsArgumentRule lints given else constructs. -type ContextAsArgumentRule struct { - allowTypesLUT map[string]struct{} - - configureOnce sync.Once -} - -// Apply applies the rule to given file. -func (r *ContextAsArgumentRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - - var failures []lint.Failure - walker := lintContextArguments{ - allowTypesLUT: r.allowTypesLUT, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, file.AST) - - return failures -} - -func (r *ContextAsArgumentRule) configure(arguments lint.Arguments) { - r.allowTypesLUT = getAllowTypesFromArguments(arguments) -} - -// Name returns the rule name. -func (*ContextAsArgumentRule) Name() string { - return "context-as-argument" -} - -type lintContextArguments struct { - allowTypesLUT map[string]struct{} - onFailure func(lint.Failure) -} - -func (w lintContextArguments) Visit(n ast.Node) ast.Visitor { - fn, ok := n.(*ast.FuncDecl) - if !ok || len(fn.Type.Params.List) <= 1 { - return w - } - - fnArgs := fn.Type.Params.List - - // A context.Context should be the first parameter of a function. - // Flag any that show up after the first. - isCtxStillAllowed := true - for _, arg := range fnArgs { - argIsCtx := isPkgDot(arg.Type, "context", "Context") - if argIsCtx && !isCtxStillAllowed { - w.onFailure(lint.Failure{ - Node: arg, - Category: "arg-order", - Failure: "context.Context should be the first parameter of a function", - Confidence: 0.9, - }) - break // only flag one - } - - typeName := gofmt(arg.Type) - // a parameter of type context.Context is still allowed if the current arg type is in the LUT - _, isCtxStillAllowed = w.allowTypesLUT[typeName] - } - - return nil // avoid visiting the function body -} - -func getAllowTypesFromArguments(args lint.Arguments) map[string]struct{} { - allowTypesBefore := []string{} - if len(args) >= 1 { - argKV, ok := args[0].(map[string]any) - if !ok { - panic(fmt.Sprintf("Invalid argument to the context-as-argument rule. Expecting a k,v map, got %T", args[0])) - } - for k, v := range argKV { - switch k { - case "allowTypesBefore": - typesBefore, ok := v.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the context-as-argument.allowTypesBefore rule. Expecting a string, got %T", v)) - } - allowTypesBefore = append(allowTypesBefore, strings.Split(typesBefore, ",")...) - default: - panic(fmt.Sprintf("Invalid argument to the context-as-argument rule. Unrecognized key %s", k)) - } - } - } - - result := make(map[string]struct{}, len(allowTypesBefore)) - for _, v := range allowTypesBefore { - result[v] = struct{}{} - } - - result["context.Context"] = struct{}{} // context.Context is always allowed before another context.Context - return result -} diff --git a/vendor/github.com/mgechev/revive/rule/context_keys_type.go b/vendor/github.com/mgechev/revive/rule/context_keys_type.go deleted file mode 100644 index 60ccec560..000000000 --- a/vendor/github.com/mgechev/revive/rule/context_keys_type.go +++ /dev/null @@ -1,81 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/types" - - "github.com/mgechev/revive/lint" -) - -// ContextKeysType lints given else constructs. -type ContextKeysType struct{} - -// Apply applies the rule to given file. -func (*ContextKeysType) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := lintContextKeyTypes{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - file.Pkg.TypeCheck() - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ContextKeysType) Name() string { - return "context-keys-type" -} - -type lintContextKeyTypes struct { - file *lint.File - fileAst *ast.File - onFailure func(lint.Failure) -} - -func (w lintContextKeyTypes) Visit(n ast.Node) ast.Visitor { - switch n := n.(type) { - case *ast.CallExpr: - checkContextKeyType(w, n) - } - - return w -} - -func checkContextKeyType(w lintContextKeyTypes, x *ast.CallExpr) { - f := w.file - sel, ok := x.Fun.(*ast.SelectorExpr) - if !ok { - return - } - pkg, ok := sel.X.(*ast.Ident) - if !ok || pkg.Name != "context" { - return - } - if sel.Sel.Name != "WithValue" { - return - } - - // key is second argument to context.WithValue - if len(x.Args) != 3 { - return - } - key := f.Pkg.TypesInfo().Types[x.Args[1]] - - if ktyp, ok := key.Type.(*types.Basic); ok && ktyp.Kind() != types.Invalid { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: x, - Category: "content", - Failure: fmt.Sprintf("should not use basic type %s as key in context.WithValue", key.Type), - }) - } -} diff --git a/vendor/github.com/mgechev/revive/rule/cyclomatic.go b/vendor/github.com/mgechev/revive/rule/cyclomatic.go deleted file mode 100644 index c1a2de97a..000000000 --- a/vendor/github.com/mgechev/revive/rule/cyclomatic.go +++ /dev/null @@ -1,137 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "sync" - - "github.com/mgechev/revive/lint" -) - -// Based on https://github.com/fzipp/gocyclo - -// CyclomaticRule lints given else constructs. -type CyclomaticRule struct { - maxComplexity int - - configureOnce sync.Once -} - -const defaultMaxCyclomaticComplexity = 10 - -func (r *CyclomaticRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.maxComplexity = defaultMaxCyclomaticComplexity - return - } - - complexity, ok := arguments[0].(int64) // Alt. non panicking version - if !ok { - panic(fmt.Sprintf("invalid argument for cyclomatic complexity; expected int but got %T", arguments[0])) - } - r.maxComplexity = int(complexity) -} - -// Apply applies the rule to given file. -func (r *CyclomaticRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - fileAst := file.AST - - walker := lintCyclomatic{ - file: file, - complexity: r.maxComplexity, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*CyclomaticRule) Name() string { - return "cyclomatic" -} - -type lintCyclomatic struct { - file *lint.File - complexity int - onFailure func(lint.Failure) -} - -func (w lintCyclomatic) Visit(_ ast.Node) ast.Visitor { - f := w.file - for _, decl := range f.AST.Decls { - fn, ok := decl.(*ast.FuncDecl) - if !ok { - continue - } - - c := complexity(fn) - if c > w.complexity { - w.onFailure(lint.Failure{ - Confidence: 1, - Category: "maintenance", - Failure: fmt.Sprintf("function %s has cyclomatic complexity %d (> max enabled %d)", - funcName(fn), c, w.complexity), - Node: fn, - }) - } - } - - return nil -} - -// funcName returns the name representation of a function or method: -// "(Type).Name" for methods or simply "Name" for functions. -func funcName(fn *ast.FuncDecl) string { - declarationHasReceiver := fn.Recv != nil && fn.Recv.NumFields() > 0 - if declarationHasReceiver { - typ := fn.Recv.List[0].Type - return fmt.Sprintf("(%s).%s", recvString(typ), fn.Name) - } - - return fn.Name.Name -} - -// recvString returns a string representation of recv of the -// form "T", "*T", or "BADRECV" (if not a proper receiver type). -func recvString(recv ast.Expr) string { - switch t := recv.(type) { - case *ast.Ident: - return t.Name - case *ast.StarExpr: - return "*" + recvString(t.X) - } - return "BADRECV" -} - -// complexity calculates the cyclomatic complexity of a function. -func complexity(fn *ast.FuncDecl) int { - v := complexityVisitor{} - ast.Walk(&v, fn) - return v.Complexity -} - -type complexityVisitor struct { - // Complexity is the cyclomatic complexity - Complexity int -} - -// Visit implements the ast.Visitor interface. -func (v *complexityVisitor) Visit(n ast.Node) ast.Visitor { - switch n := n.(type) { - case *ast.FuncDecl, *ast.IfStmt, *ast.ForStmt, *ast.RangeStmt, *ast.CaseClause, *ast.CommClause: - v.Complexity++ - case *ast.BinaryExpr: - if n.Op == token.LAND || n.Op == token.LOR { - v.Complexity++ - } - } - return v -} diff --git a/vendor/github.com/mgechev/revive/rule/datarace.go b/vendor/github.com/mgechev/revive/rule/datarace.go deleted file mode 100644 index 21a7a706e..000000000 --- a/vendor/github.com/mgechev/revive/rule/datarace.go +++ /dev/null @@ -1,144 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// DataRaceRule lints assignments to value method-receivers. -type DataRaceRule struct{} - -// Apply applies the rule to given file. -func (*DataRaceRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - w := lintDataRaces{onFailure: onFailure, go122for: file.Pkg.IsAtLeastGo122()} - - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*DataRaceRule) Name() string { - return "datarace" -} - -type lintDataRaces struct { - onFailure func(failure lint.Failure) - go122for bool -} - -func (w lintDataRaces) Visit(n ast.Node) ast.Visitor { - node, ok := n.(*ast.FuncDecl) - if !ok { - return w // not function declaration - } - if node.Body == nil { - return nil // empty body - } - - results := node.Type.Results - - returnIDs := map[*ast.Object]struct{}{} - if results != nil { - returnIDs = w.ExtractReturnIDs(results.List) - } - fl := &lintFunctionForDataRaces{onFailure: w.onFailure, returnIDs: returnIDs, rangeIDs: map[*ast.Object]struct{}{}, go122for: w.go122for} - ast.Walk(fl, node.Body) - - return nil -} - -func (lintDataRaces) ExtractReturnIDs(fields []*ast.Field) map[*ast.Object]struct{} { - r := map[*ast.Object]struct{}{} - for _, f := range fields { - for _, id := range f.Names { - r[id.Obj] = struct{}{} - } - } - - return r -} - -type lintFunctionForDataRaces struct { - _ struct{} - onFailure func(failure lint.Failure) - returnIDs map[*ast.Object]struct{} - rangeIDs map[*ast.Object]struct{} - go122for bool -} - -func (w lintFunctionForDataRaces) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.RangeStmt: - if n.Body == nil { - return nil - } - - getIDs := func(exprs ...ast.Expr) []*ast.Ident { - r := []*ast.Ident{} - for _, expr := range exprs { - if id, ok := expr.(*ast.Ident); ok { - r = append(r, id) - } - } - return r - } - - ids := getIDs(n.Key, n.Value) - for _, id := range ids { - w.rangeIDs[id.Obj] = struct{}{} - } - - ast.Walk(w, n.Body) - - for _, id := range ids { - delete(w.rangeIDs, id.Obj) - } - - return nil // do not visit the body of the range, it has been already visited - case *ast.GoStmt: - f := n.Call.Fun - funcLit, ok := f.(*ast.FuncLit) - if !ok { - return nil - } - selectIDs := func(n ast.Node) bool { - _, ok := n.(*ast.Ident) - return ok - } - - ids := pick(funcLit.Body, selectIDs) - for _, id := range ids { - id := id.(*ast.Ident) - _, isRangeID := w.rangeIDs[id.Obj] - _, isReturnID := w.returnIDs[id.Obj] - - switch { - case isRangeID && !w.go122for: - w.onFailure(lint.Failure{ - Confidence: 1, - Node: id, - Category: "logic", - Failure: fmt.Sprintf("datarace: range value %s is captured (by-reference) in goroutine", id.Name), - }) - case isReturnID: - w.onFailure(lint.Failure{ - Confidence: 0.8, - Node: id, - Category: "logic", - Failure: fmt.Sprintf("potential datarace: return value %s is captured (by-reference) in goroutine", id.Name), - }) - } - } - - return nil - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/deep_exit.go b/vendor/github.com/mgechev/revive/rule/deep_exit.go deleted file mode 100644 index 7b3dd0f82..000000000 --- a/vendor/github.com/mgechev/revive/rule/deep_exit.go +++ /dev/null @@ -1,95 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// DeepExitRule lints program exit at functions other than main or init. -type DeepExitRule struct{} - -// Apply applies the rule to given file. -func (*DeepExitRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - exitFunctions := map[string]map[string]bool{ - "os": {"Exit": true}, - "syscall": {"Exit": true}, - "log": { - "Fatal": true, - "Fatalf": true, - "Fatalln": true, - "Panic": true, - "Panicf": true, - "Panicln": true, - }, - } - - w := lintDeepExit{onFailure, exitFunctions, file.IsTest()} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*DeepExitRule) Name() string { - return "deep-exit" -} - -type lintDeepExit struct { - onFailure func(lint.Failure) - exitFunctions map[string]map[string]bool - isTestFile bool -} - -func (w lintDeepExit) Visit(node ast.Node) ast.Visitor { - if fd, ok := node.(*ast.FuncDecl); ok { - if w.mustIgnore(fd) { - return nil // skip analysis of this function - } - - return w - } - - se, ok := node.(*ast.ExprStmt) - if !ok { - return w - } - ce, ok := se.X.(*ast.CallExpr) - if !ok { - return w - } - - fc, ok := ce.Fun.(*ast.SelectorExpr) - if !ok { - return w - } - id, ok := fc.X.(*ast.Ident) - if !ok { - return w - } - - pkg := id.Name - fn := fc.Sel.Name - isACallToExitFunction := w.exitFunctions[pkg] != nil && w.exitFunctions[pkg][fn] - if isACallToExitFunction { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: ce, - Category: "bad practice", - Failure: fmt.Sprintf("calls to %s.%s only in main() or init() functions", pkg, fn), - }) - } - - return w -} - -func (w *lintDeepExit) mustIgnore(fd *ast.FuncDecl) bool { - fn := fd.Name.Name - - return fn == "init" || fn == "main" || (w.isTestFile && fn == "TestMain") -} diff --git a/vendor/github.com/mgechev/revive/rule/defer.go b/vendor/github.com/mgechev/revive/rule/defer.go deleted file mode 100644 index f7c716eb6..000000000 --- a/vendor/github.com/mgechev/revive/rule/defer.go +++ /dev/null @@ -1,174 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -// DeferRule lints unused params in functions. -type DeferRule struct { - allow map[string]bool - - configureOnce sync.Once -} - -func (r *DeferRule) configure(arguments lint.Arguments) { - r.allow = r.allowFromArgs(arguments) -} - -// Apply applies the rule to given file. -func (r *DeferRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - w := lintDeferRule{onFailure: onFailure, allow: r.allow} - - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*DeferRule) Name() string { - return "defer" -} - -func (*DeferRule) allowFromArgs(args lint.Arguments) map[string]bool { - if len(args) < 1 { - allow := map[string]bool{ - "loop": true, - "call-chain": true, - "method-call": true, - "return": true, - "recover": true, - "immediate-recover": true, - } - - return allow - } - - aa, ok := args[0].([]any) - if !ok { - panic(fmt.Sprintf("Invalid argument '%v' for 'defer' rule. Expecting []string, got %T", args[0], args[0])) - } - - allow := make(map[string]bool, len(aa)) - for _, subcase := range aa { - sc, ok := subcase.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument '%v' for 'defer' rule. Expecting string, got %T", subcase, subcase)) - } - allow[sc] = true - } - - return allow -} - -type lintDeferRule struct { - onFailure func(lint.Failure) - inALoop bool - inADefer bool - inAFuncLit bool - allow map[string]bool -} - -func (w lintDeferRule) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.ForStmt: - w.visitSubtree(n.Body, w.inADefer, true, w.inAFuncLit) - return nil - case *ast.RangeStmt: - w.visitSubtree(n.Body, w.inADefer, true, w.inAFuncLit) - return nil - case *ast.FuncLit: - w.visitSubtree(n.Body, w.inADefer, false, true) - return nil - case *ast.ReturnStmt: - if len(n.Results) != 0 && w.inADefer && w.inAFuncLit { - w.newFailure("return in a defer function has no effect", n, 1.0, "logic", "return") - } - case *ast.CallExpr: - isCallToRecover := isIdent(n.Fun, "recover") - switch { - case !w.inADefer && isCallToRecover: - // func fn() { recover() } - // - // confidence is not 1 because recover can be in a function that is deferred elsewhere - w.newFailure("recover must be called inside a deferred function", n, 0.8, "logic", "recover") - case w.inADefer && !w.inAFuncLit && isCallToRecover: - // defer helper(recover()) - // - // confidence is not truly 1 because this could be in a correctly-deferred func, - // but it is very likely to be a misunderstanding of defer's behavior around arguments. - w.newFailure("recover must be called inside a deferred function, this is executing recover immediately", n, 1, "logic", "immediate-recover") - } - return nil // no need to analyze the arguments of the function call - case *ast.DeferStmt: - if isIdent(n.Call.Fun, "recover") { - // defer recover() - // - // confidence is not truly 1 because this could be in a correctly-deferred func, - // but normally this doesn't suppress a panic, and even if it did it would silently discard the value. - w.newFailure("recover must be called inside a deferred function, this is executing recover immediately", n, 1, "logic", "immediate-recover") - } - w.visitSubtree(n.Call.Fun, true, false, false) - for _, a := range n.Call.Args { - switch a.(type) { - case *ast.FuncLit: - continue // too hard to analyze deferred calls with func literals args - default: - w.visitSubtree(a, true, false, false) // check arguments, they should not contain recover() - } - } - - if w.inALoop { - w.newFailure("prefer not to defer inside loops", n, 1.0, "bad practice", "loop") - } - - switch fn := n.Call.Fun.(type) { - case *ast.CallExpr: - w.newFailure("prefer not to defer chains of function calls", fn, 1.0, "bad practice", "call-chain") - case *ast.SelectorExpr: - if id, ok := fn.X.(*ast.Ident); ok { - isMethodCall := id != nil && id.Obj != nil && id.Obj.Kind == ast.Typ - if isMethodCall { - w.newFailure("be careful when deferring calls to methods without pointer receiver", fn, 0.8, "bad practice", "method-call") - } - } - } - - return nil - } - - return w -} - -func (w lintDeferRule) visitSubtree(n ast.Node, inADefer, inALoop, inAFuncLit bool) { - nw := lintDeferRule{ - onFailure: w.onFailure, - inADefer: inADefer, - inALoop: inALoop, - inAFuncLit: inAFuncLit, - allow: w.allow, - } - ast.Walk(nw, n) -} - -func (w lintDeferRule) newFailure(msg string, node ast.Node, confidence float64, cat, subcase string) { - if !w.allow[subcase] { - return - } - - w.onFailure(lint.Failure{ - Confidence: confidence, - Node: node, - Category: cat, - Failure: msg, - }) -} diff --git a/vendor/github.com/mgechev/revive/rule/doc.go b/vendor/github.com/mgechev/revive/rule/doc.go deleted file mode 100644 index 55bf6caa6..000000000 --- a/vendor/github.com/mgechev/revive/rule/doc.go +++ /dev/null @@ -1,2 +0,0 @@ -// Package rule implements revive's linting rules. -package rule diff --git a/vendor/github.com/mgechev/revive/rule/dot_imports.go b/vendor/github.com/mgechev/revive/rule/dot_imports.go deleted file mode 100644 index f6c7fbcfb..000000000 --- a/vendor/github.com/mgechev/revive/rule/dot_imports.go +++ /dev/null @@ -1,101 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -// DotImportsRule lints given else constructs. -type DotImportsRule struct { - allowedPackages allowPackages - - configureOnce sync.Once -} - -// Apply applies the rule to given file. -func (r *DotImportsRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - fileAst := file.AST - walker := lintImports{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - allowPackages: r.allowedPackages, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*DotImportsRule) Name() string { - return "dot-imports" -} - -func (r *DotImportsRule) configure(arguments lint.Arguments) { - r.allowedPackages = make(allowPackages) - if len(arguments) == 0 { - return - } - - args, ok := arguments[0].(map[string]any) - if !ok { - panic(fmt.Sprintf("Invalid argument to the dot-imports rule. Expecting a k,v map, got %T", arguments[0])) - } - - if allowedPkgArg, ok := args["allowedPackages"]; ok { - pkgs, ok := allowedPkgArg.([]any) - if !ok { - panic(fmt.Sprintf("Invalid argument to the dot-imports rule, []string expected. Got '%v' (%T)", allowedPkgArg, allowedPkgArg)) - } - for _, p := range pkgs { - pkg, ok := p.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the dot-imports rule, string expected. Got '%v' (%T)", p, p)) - } - r.allowedPackages.add(pkg) - } - } -} - -type lintImports struct { - file *lint.File - fileAst *ast.File - onFailure func(lint.Failure) - allowPackages allowPackages -} - -func (w lintImports) Visit(_ ast.Node) ast.Visitor { - for _, importSpec := range w.fileAst.Imports { - isDotImport := importSpec.Name != nil && importSpec.Name.Name == "." - if isDotImport && !w.allowPackages.isAllowedPackage(importSpec.Path.Value) { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: "should not use dot imports", - Node: importSpec, - Category: "imports", - }) - } - } - return nil -} - -type allowPackages map[string]struct{} - -func (ap allowPackages) add(pkg string) { - ap[fmt.Sprintf(`"%s"`, pkg)] = struct{}{} // import path strings are with double quotes -} - -func (ap allowPackages) isAllowedPackage(pkg string) bool { - _, allowed := ap[pkg] - return allowed -} diff --git a/vendor/github.com/mgechev/revive/rule/duplicated_imports.go b/vendor/github.com/mgechev/revive/rule/duplicated_imports.go deleted file mode 100644 index 2b177fac6..000000000 --- a/vendor/github.com/mgechev/revive/rule/duplicated_imports.go +++ /dev/null @@ -1,39 +0,0 @@ -package rule - -import ( - "fmt" - - "github.com/mgechev/revive/lint" -) - -// DuplicatedImportsRule lints given else constructs. -type DuplicatedImportsRule struct{} - -// Apply applies the rule to given file. -func (*DuplicatedImportsRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - impPaths := map[string]struct{}{} - for _, imp := range file.AST.Imports { - path := imp.Path.Value - _, ok := impPaths[path] - if ok { - failures = append(failures, lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("Package %s already imported", path), - Node: imp, - Category: "imports", - }) - continue - } - - impPaths[path] = struct{}{} - } - - return failures -} - -// Name returns the rule name. -func (*DuplicatedImportsRule) Name() string { - return "duplicated-imports" -} diff --git a/vendor/github.com/mgechev/revive/rule/early_return.go b/vendor/github.com/mgechev/revive/rule/early_return.go deleted file mode 100644 index 62d491f27..000000000 --- a/vendor/github.com/mgechev/revive/rule/early_return.go +++ /dev/null @@ -1,51 +0,0 @@ -package rule - -import ( - "fmt" - - "github.com/mgechev/revive/internal/ifelse" - "github.com/mgechev/revive/lint" -) - -// EarlyReturnRule finds opportunities to reduce nesting by inverting -// the condition of an "if" block. -type EarlyReturnRule struct{} - -// Apply applies the rule to given file. -func (e *EarlyReturnRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - return ifelse.Apply(e, file.AST, ifelse.TargetIf, args) -} - -// Name returns the rule name. -func (*EarlyReturnRule) Name() string { - return "early-return" -} - -// CheckIfElse evaluates the rule against an ifelse.Chain and returns a failure message if applicable. -func (*EarlyReturnRule) CheckIfElse(chain ifelse.Chain, args ifelse.Args) string { - if !chain.Else.Deviates() { - // this rule only applies if the else-block deviates control flow - return "" - } - - if chain.HasPriorNonDeviating && !chain.If.IsEmpty() { - // if we de-indent this block then a previous branch - // might flow into it, affecting program behaviour - return "" - } - - if chain.If.Deviates() { - // avoid overlapping with superfluous-else - return "" - } - - if args.PreserveScope && !chain.AtBlockEnd && (chain.HasInitializer || chain.If.HasDecls) { - // avoid increasing variable scope - return "" - } - - if chain.If.IsEmpty() { - return fmt.Sprintf("if c { } else { %[1]v } can be simplified to if !c { %[1]v }", chain.Else) - } - return fmt.Sprintf("if c { ... } else { %[1]v } can be simplified to if !c { %[1]v } ...", chain.Else) -} diff --git a/vendor/github.com/mgechev/revive/rule/empty_block.go b/vendor/github.com/mgechev/revive/rule/empty_block.go deleted file mode 100644 index 25a052a0e..000000000 --- a/vendor/github.com/mgechev/revive/rule/empty_block.go +++ /dev/null @@ -1,75 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// EmptyBlockRule lints given else constructs. -type EmptyBlockRule struct{} - -// Apply applies the rule to given file. -func (*EmptyBlockRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintEmptyBlock{make(map[*ast.BlockStmt]bool), onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*EmptyBlockRule) Name() string { - return "empty-block" -} - -type lintEmptyBlock struct { - ignore map[*ast.BlockStmt]bool - onFailure func(lint.Failure) -} - -func (w lintEmptyBlock) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.FuncDecl: - w.ignore[n.Body] = true - return w - case *ast.FuncLit: - w.ignore[n.Body] = true - return w - case *ast.SelectStmt: - w.ignore[n.Body] = true - return w - case *ast.ForStmt: - if len(n.Body.List) == 0 && n.Init == nil && n.Post == nil && n.Cond != nil { - if _, isCall := n.Cond.(*ast.CallExpr); isCall { - w.ignore[n.Body] = true - return w - } - } - case *ast.RangeStmt: - if len(n.Body.List) == 0 { - w.onFailure(lint.Failure{ - Confidence: 0.9, - Node: n, - Category: "logic", - Failure: "this block is empty, you can remove it", - }) - return nil // skip visiting the range subtree (it will produce a duplicated failure) - } - case *ast.BlockStmt: - if !w.ignore[n] && len(n.List) == 0 { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: n, - Category: "logic", - Failure: "this block is empty, you can remove it", - }) - } - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/empty_lines.go b/vendor/github.com/mgechev/revive/rule/empty_lines.go deleted file mode 100644 index 2710a8979..000000000 --- a/vendor/github.com/mgechev/revive/rule/empty_lines.go +++ /dev/null @@ -1,105 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// EmptyLinesRule lints empty lines in blocks. -type EmptyLinesRule struct{} - -// Apply applies the rule to given file. -func (r *EmptyLinesRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintEmptyLines{file, r.commentLines(file.CommentMap(), file), onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*EmptyLinesRule) Name() string { - return "empty-lines" -} - -type lintEmptyLines struct { - file *lint.File - cmap map[int]struct{} - onFailure func(lint.Failure) -} - -func (w lintEmptyLines) Visit(node ast.Node) ast.Visitor { - block, ok := node.(*ast.BlockStmt) - if !ok || len(block.List) == 0 { - return w - } - - w.checkStart(block) - w.checkEnd(block) - - return w -} - -func (w lintEmptyLines) checkStart(block *ast.BlockStmt) { - blockStart := w.position(block.Lbrace) - firstNode := block.List[0] - firstStmt := w.position(firstNode.Pos()) - - firstBlockLineIsStmt := firstStmt.Line-(blockStart.Line+1) <= 0 - _, firstBlockLineIsComment := w.cmap[blockStart.Line+1] - if firstBlockLineIsStmt || firstBlockLineIsComment { - return - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: block, - Category: "style", - Failure: "extra empty line at the start of a block", - }) -} - -func (w lintEmptyLines) checkEnd(block *ast.BlockStmt) { - blockEnd := w.position(block.Rbrace) - lastNode := block.List[len(block.List)-1] - lastStmt := w.position(lastNode.End()) - - lastBlockLineIsStmt := (blockEnd.Line-1)-lastStmt.Line <= 0 - _, lastBlockLineIsComment := w.cmap[blockEnd.Line-1] - if lastBlockLineIsStmt || lastBlockLineIsComment { - return - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: block, - Category: "style", - Failure: "extra empty line at the end of a block", - }) -} - -func (w lintEmptyLines) position(pos token.Pos) token.Position { - return w.file.ToPosition(pos) -} - -func (*EmptyLinesRule) commentLines(cmap ast.CommentMap, file *lint.File) map[int]struct{} { - result := map[int]struct{}{} - - for _, comments := range cmap { - for _, comment := range comments { - start := file.ToPosition(comment.Pos()) - end := file.ToPosition(comment.End()) - for i := start.Line; i <= end.Line; i++ { - result[i] = struct{}{} - } - } - } - - return result -} diff --git a/vendor/github.com/mgechev/revive/rule/enforce_map_style.go b/vendor/github.com/mgechev/revive/rule/enforce_map_style.go deleted file mode 100644 index 7ddf31e35..000000000 --- a/vendor/github.com/mgechev/revive/rule/enforce_map_style.go +++ /dev/null @@ -1,155 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -type enforceMapStyleType string - -const ( - enforceMapStyleTypeAny enforceMapStyleType = "any" - enforceMapStyleTypeMake enforceMapStyleType = "make" - enforceMapStyleTypeLiteral enforceMapStyleType = "literal" -) - -func mapStyleFromString(s string) (enforceMapStyleType, error) { - switch s { - case string(enforceMapStyleTypeAny), "": - return enforceMapStyleTypeAny, nil - case string(enforceMapStyleTypeMake): - return enforceMapStyleTypeMake, nil - case string(enforceMapStyleTypeLiteral): - return enforceMapStyleTypeLiteral, nil - default: - return enforceMapStyleTypeAny, fmt.Errorf( - "invalid map style: %s (expecting one of %v)", - s, - []enforceMapStyleType{ - enforceMapStyleTypeAny, - enforceMapStyleTypeMake, - enforceMapStyleTypeLiteral, - }, - ) - } -} - -// EnforceMapStyleRule implements a rule to enforce `make(map[type]type)` over `map[type]type{}`. -type EnforceMapStyleRule struct { - enforceMapStyle enforceMapStyleType - - configureOnce sync.Once -} - -func (r *EnforceMapStyleRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.enforceMapStyle = enforceMapStyleTypeAny - return - } - - enforceMapStyle, ok := arguments[0].(string) - if !ok { - panic(fmt.Sprintf("Invalid argument '%v' for 'enforce-map-style' rule. Expecting string, got %T", arguments[0], arguments[0])) - } - - var err error - r.enforceMapStyle, err = mapStyleFromString(enforceMapStyle) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the enforce-map-style rule: %v", err)) - } -} - -// Apply applies the rule to given file. -func (r *EnforceMapStyleRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - if r.enforceMapStyle == enforceMapStyleTypeAny { - // this linter is not configured - return nil - } - - var failures []lint.Failure - - astFile := file.AST - ast.Inspect(astFile, func(n ast.Node) bool { - switch v := n.(type) { - case *ast.CompositeLit: - if r.enforceMapStyle != enforceMapStyleTypeMake { - return true - } - - if !r.isMapType(v.Type) { - return true - } - - isEmptyMap := len(v.Elts) > 0 - if isEmptyMap { - return true - } - - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: v, - Category: "style", - Failure: "use make(map[type]type) instead of map[type]type{}", - }) - case *ast.CallExpr: - if r.enforceMapStyle != enforceMapStyleTypeLiteral { - // skip any function calls, even if it's make(map[type]type) - // we don't want to report it if literals are not enforced - return true - } - - ident, ok := v.Fun.(*ast.Ident) - if !ok || ident.Name != "make" { - return true - } - - if len(v.Args) != 1 { - // skip make(map[type]type, size) and invalid empty declarations - return true - } - - if !r.isMapType(v.Args[0]) { - // not a map type - return true - } - - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: v.Args[0], - Category: "style", - Failure: "use map[type]type{} instead of make(map[type]type)", - }) - } - return true - }) - - return failures -} - -// Name returns the rule name. -func (*EnforceMapStyleRule) Name() string { - return "enforce-map-style" -} - -func (r *EnforceMapStyleRule) isMapType(v ast.Expr) bool { - switch t := v.(type) { - case *ast.MapType: - return true - case *ast.Ident: - if t.Obj == nil { - return false - } - typeSpec, ok := t.Obj.Decl.(*ast.TypeSpec) - if !ok { - return false - } - return r.isMapType(typeSpec.Type) - default: - return false - } -} diff --git a/vendor/github.com/mgechev/revive/rule/enforce_repeated_arg_type_style.go b/vendor/github.com/mgechev/revive/rule/enforce_repeated_arg_type_style.go deleted file mode 100644 index 3f9712aef..000000000 --- a/vendor/github.com/mgechev/revive/rule/enforce_repeated_arg_type_style.go +++ /dev/null @@ -1,178 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -type enforceRepeatedArgTypeStyleType string - -const ( - enforceRepeatedArgTypeStyleTypeAny enforceRepeatedArgTypeStyleType = "any" - enforceRepeatedArgTypeStyleTypeShort enforceRepeatedArgTypeStyleType = "short" - enforceRepeatedArgTypeStyleTypeFull enforceRepeatedArgTypeStyleType = "full" -) - -func repeatedArgTypeStyleFromString(s string) enforceRepeatedArgTypeStyleType { - switch s { - case string(enforceRepeatedArgTypeStyleTypeAny), "": - return enforceRepeatedArgTypeStyleTypeAny - case string(enforceRepeatedArgTypeStyleTypeShort): - return enforceRepeatedArgTypeStyleTypeShort - case string(enforceRepeatedArgTypeStyleTypeFull): - return enforceRepeatedArgTypeStyleTypeFull - default: - err := fmt.Errorf( - "invalid repeated arg type style: %s (expecting one of %v)", - s, - []enforceRepeatedArgTypeStyleType{ - enforceRepeatedArgTypeStyleTypeAny, - enforceRepeatedArgTypeStyleTypeShort, - enforceRepeatedArgTypeStyleTypeFull, - }, - ) - - panic(fmt.Sprintf("Invalid argument to the enforce-repeated-arg-type-style rule: %v", err)) - } -} - -// EnforceRepeatedArgTypeStyleRule implements a rule to enforce repeated argument type style. -type EnforceRepeatedArgTypeStyleRule struct { - funcArgStyle enforceRepeatedArgTypeStyleType - funcRetValStyle enforceRepeatedArgTypeStyleType - - configureOnce sync.Once -} - -func (r *EnforceRepeatedArgTypeStyleRule) configure(arguments lint.Arguments) { - r.funcArgStyle = enforceRepeatedArgTypeStyleTypeAny - r.funcRetValStyle = enforceRepeatedArgTypeStyleTypeAny - - if len(arguments) == 0 { - return - } - - switch funcArgStyle := arguments[0].(type) { - case string: - r.funcArgStyle = repeatedArgTypeStyleFromString(funcArgStyle) - r.funcRetValStyle = repeatedArgTypeStyleFromString(funcArgStyle) - case map[string]any: // expecting map[string]string - for k, v := range funcArgStyle { - switch k { - case "funcArgStyle": - val, ok := v.(string) - if !ok { - panic(fmt.Sprintf("Invalid map value type for 'enforce-repeated-arg-type-style' rule. Expecting string, got %T", v)) - } - r.funcArgStyle = repeatedArgTypeStyleFromString(val) - case "funcRetValStyle": - val, ok := v.(string) - if !ok { - panic(fmt.Sprintf("Invalid map value '%v' for 'enforce-repeated-arg-type-style' rule. Expecting string, got %T", v, v)) - } - r.funcRetValStyle = repeatedArgTypeStyleFromString(val) - default: - panic(fmt.Sprintf("Invalid map key for 'enforce-repeated-arg-type-style' rule. Expecting 'funcArgStyle' or 'funcRetValStyle', got %v", k)) - } - } - default: - panic(fmt.Sprintf("Invalid argument '%v' for 'import-alias-naming' rule. Expecting string or map[string]string, got %T", arguments[0], arguments[0])) - } -} - -// Apply applies the rule to a given file. -func (r *EnforceRepeatedArgTypeStyleRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - if r.funcArgStyle == enforceRepeatedArgTypeStyleTypeAny && r.funcRetValStyle == enforceRepeatedArgTypeStyleTypeAny { - // This linter is not configured, return no failures. - return nil - } - - var failures []lint.Failure - - astFile := file.AST - ast.Inspect(astFile, func(n ast.Node) bool { - switch fn := n.(type) { - case *ast.FuncDecl: - if r.funcArgStyle == enforceRepeatedArgTypeStyleTypeFull { - if fn.Type.Params != nil { - for _, field := range fn.Type.Params.List { - if len(field.Names) > 1 { - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: field, - Category: "style", - Failure: "argument types should not be omitted", - }) - } - } - } - } - - if r.funcArgStyle == enforceRepeatedArgTypeStyleTypeShort { - var prevType ast.Expr - if fn.Type.Params != nil { - for _, field := range fn.Type.Params.List { - prevTypeStr := gofmt(prevType) - currentTypeStr := gofmt(field.Type) - if currentTypeStr == prevTypeStr { - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: prevType, - Category: "style", - Failure: fmt.Sprintf("repeated argument type %q can be omitted", prevTypeStr), - }) - } - prevType = field.Type - } - } - } - - if r.funcRetValStyle == enforceRepeatedArgTypeStyleTypeFull { - if fn.Type.Results != nil { - for _, field := range fn.Type.Results.List { - if len(field.Names) > 1 { - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: field, - Category: "style", - Failure: "return types should not be omitted", - }) - } - } - } - } - - if r.funcRetValStyle == enforceRepeatedArgTypeStyleTypeShort { - var prevType ast.Expr - if fn.Type.Results != nil { - for _, field := range fn.Type.Results.List { - prevTypeStr := gofmt(prevType) - currentTypeStr := gofmt(field.Type) - if field.Names != nil && currentTypeStr == prevTypeStr { - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: prevType, - Category: "style", - Failure: fmt.Sprintf("repeated return type %q can be omitted", prevTypeStr), - }) - } - prevType = field.Type - } - } - } - } - return true - }) - - return failures -} - -// Name returns the name of the linter rule. -func (*EnforceRepeatedArgTypeStyleRule) Name() string { - return "enforce-repeated-arg-type-style" -} diff --git a/vendor/github.com/mgechev/revive/rule/enforce_slice_style.go b/vendor/github.com/mgechev/revive/rule/enforce_slice_style.go deleted file mode 100644 index 7170379d9..000000000 --- a/vendor/github.com/mgechev/revive/rule/enforce_slice_style.go +++ /dev/null @@ -1,205 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -type enforceSliceStyleType string - -const ( - enforceSliceStyleTypeAny enforceSliceStyleType = "any" - enforceSliceStyleTypeMake enforceSliceStyleType = "make" - enforceSliceStyleTypeLiteral enforceSliceStyleType = "literal" - enforceSliceStyleTypeNil enforceSliceStyleType = "nil" -) - -func sliceStyleFromString(s string) (enforceSliceStyleType, error) { - switch s { - case string(enforceSliceStyleTypeAny), "": - return enforceSliceStyleTypeAny, nil - case string(enforceSliceStyleTypeMake): - return enforceSliceStyleTypeMake, nil - case string(enforceSliceStyleTypeLiteral): - return enforceSliceStyleTypeLiteral, nil - case string(enforceSliceStyleTypeNil): - return enforceSliceStyleTypeNil, nil - default: - return enforceSliceStyleTypeAny, fmt.Errorf( - "invalid slice style: %s (expecting one of %v)", - s, - []enforceSliceStyleType{ - enforceSliceStyleTypeAny, - enforceSliceStyleTypeMake, - enforceSliceStyleTypeLiteral, - enforceSliceStyleTypeNil, - }, - ) - } -} - -// EnforceSliceStyleRule implements a rule to enforce `make([]type)` over `[]type{}`. -type EnforceSliceStyleRule struct { - enforceSliceStyle enforceSliceStyleType - - configureOnce sync.Once -} - -func (r *EnforceSliceStyleRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.enforceSliceStyle = enforceSliceStyleTypeAny - return - } - - enforceSliceStyle, ok := arguments[0].(string) - if !ok { - panic(fmt.Sprintf("Invalid argument '%v' for 'enforce-slice-style' rule. Expecting string, got %T", arguments[0], arguments[0])) - } - - var err error - r.enforceSliceStyle, err = sliceStyleFromString(enforceSliceStyle) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the enforce-slice-style rule: %v", err)) - } -} - -// Apply applies the rule to given file. -func (r *EnforceSliceStyleRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - if r.enforceSliceStyle == enforceSliceStyleTypeAny { - // this linter is not configured - return nil - } - - var failures []lint.Failure - - astFile := file.AST - ast.Inspect(astFile, func(n ast.Node) bool { - switch v := n.(type) { - case *ast.CompositeLit: - switch r.enforceSliceStyle { - case enforceSliceStyleTypeMake, enforceSliceStyleTypeNil: - // continue - default: - return true - } - - if !r.isSliceType(v.Type) { - return true - } - - isNotEmptySlice := len(v.Elts) > 0 - if isNotEmptySlice { - return true - } - - var failureMessage string - if r.enforceSliceStyle == enforceSliceStyleTypeNil { - failureMessage = "use nil slice declaration (e.g. var args []type) instead of []type{}" - } else { - failureMessage = "use make([]type) instead of []type{} (or declare nil slice)" - } - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: v, - Category: "style", - Failure: failureMessage, - }) - case *ast.CallExpr: - switch r.enforceSliceStyle { - case enforceSliceStyleTypeLiteral, enforceSliceStyleTypeNil: - default: - // skip any function calls, even if it's make([]type) - // we don't want to report it if literals are not enforced - return true - } - - ident, ok := v.Fun.(*ast.Ident) - if !ok || ident.Name != "make" { - return true - } - - isInvalidMakeDeclaration := len(v.Args) < 2 - if isInvalidMakeDeclaration { - return true - } - - if !r.isSliceType(v.Args[0]) { - // not a slice type - return true - } - - arg, ok := v.Args[1].(*ast.BasicLit) - if !ok { - // skip invalid make declarations - return true - } - - isSliceSizeNotZero := arg.Value != "0" - if isSliceSizeNotZero { - return true - } - - if len(v.Args) > 2 { - arg, ok := v.Args[2].(*ast.BasicLit) - if !ok { - // skip invalid make declarations - return true - } - - isNonZeroCapacitySlice := arg.Value != "0" - if isNonZeroCapacitySlice { - return true - } - } - - var failureMessage string - if r.enforceSliceStyle == enforceSliceStyleTypeNil { - failureMessage = "use nil slice declaration (e.g. var args []type) instead of make([]type, 0)" - } else { - failureMessage = "use []type{} instead of make([]type, 0) (or declare nil slice)" - } - failures = append(failures, lint.Failure{ - Confidence: 1, - Node: v.Args[0], - Category: "style", - Failure: failureMessage, - }) - } - return true - }) - - return failures -} - -// Name returns the rule name. -func (*EnforceSliceStyleRule) Name() string { - return "enforce-slice-style" -} - -func (r *EnforceSliceStyleRule) isSliceType(v ast.Expr) bool { - switch t := v.(type) { - case *ast.ArrayType: - if t.Len != nil { - // array - return false - } - // slice - return true - case *ast.Ident: - if t.Obj == nil { - return false - } - typeSpec, ok := t.Obj.Decl.(*ast.TypeSpec) - if !ok { - return false - } - return r.isSliceType(typeSpec.Type) - default: - return false - } -} diff --git a/vendor/github.com/mgechev/revive/rule/error_naming.go b/vendor/github.com/mgechev/revive/rule/error_naming.go deleted file mode 100644 index a4f24f3f0..000000000 --- a/vendor/github.com/mgechev/revive/rule/error_naming.go +++ /dev/null @@ -1,79 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "strings" - - "github.com/mgechev/revive/lint" -) - -// ErrorNamingRule lints given else constructs. -type ErrorNamingRule struct{} - -// Apply applies the rule to given file. -func (*ErrorNamingRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := lintErrors{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ErrorNamingRule) Name() string { - return "error-naming" -} - -type lintErrors struct { - file *lint.File - fileAst *ast.File - onFailure func(lint.Failure) -} - -func (w lintErrors) Visit(_ ast.Node) ast.Visitor { - for _, decl := range w.fileAst.Decls { - gd, ok := decl.(*ast.GenDecl) - if !ok || gd.Tok != token.VAR { - continue - } - for _, spec := range gd.Specs { - spec := spec.(*ast.ValueSpec) - if len(spec.Names) != 1 || len(spec.Values) != 1 { - continue - } - ce, ok := spec.Values[0].(*ast.CallExpr) - if !ok { - continue - } - if !isPkgDot(ce.Fun, "errors", "New") && !isPkgDot(ce.Fun, "fmt", "Errorf") { - continue - } - - id := spec.Names[0] - prefix := "err" - if id.IsExported() { - prefix = "Err" - } - if !strings.HasPrefix(id.Name, prefix) { - w.onFailure(lint.Failure{ - Node: id, - Confidence: 0.9, - Category: "naming", - Failure: fmt.Sprintf("error var %s should have name of the form %sFoo", id.Name, prefix), - }) - } - } - } - return nil -} diff --git a/vendor/github.com/mgechev/revive/rule/error_return.go b/vendor/github.com/mgechev/revive/rule/error_return.go deleted file mode 100644 index a724e001c..000000000 --- a/vendor/github.com/mgechev/revive/rule/error_return.go +++ /dev/null @@ -1,67 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// ErrorReturnRule lints given else constructs. -type ErrorReturnRule struct{} - -// Apply applies the rule to given file. -func (*ErrorReturnRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := lintErrorReturn{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ErrorReturnRule) Name() string { - return "error-return" -} - -type lintErrorReturn struct { - file *lint.File - fileAst *ast.File - onFailure func(lint.Failure) -} - -func (w lintErrorReturn) Visit(n ast.Node) ast.Visitor { - fn, ok := n.(*ast.FuncDecl) - if !ok || fn.Type.Results == nil { - return w - } - ret := fn.Type.Results.List - if len(ret) <= 1 { - return w - } - if isIdent(ret[len(ret)-1].Type, "error") { - return nil - } - // An error return parameter should be the last parameter. - // Flag any error parameters found before the last. - for _, r := range ret[:len(ret)-1] { - if isIdent(r.Type, "error") { - w.onFailure(lint.Failure{ - Category: "arg-order", - Confidence: 0.9, - Node: fn, - Failure: "error should be the last type when returning multiple items", - }) - break // only flag one - } - } - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/error_strings.go b/vendor/github.com/mgechev/revive/rule/error_strings.go deleted file mode 100644 index 97a0f4d06..000000000 --- a/vendor/github.com/mgechev/revive/rule/error_strings.go +++ /dev/null @@ -1,193 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - "strconv" - "strings" - "sync" - "unicode" - "unicode/utf8" - - "github.com/mgechev/revive/lint" -) - -// ErrorStringsRule lints given else constructs. -type ErrorStringsRule struct { - errorFunctions map[string]map[string]struct{} - - configureOnce sync.Once -} - -func (r *ErrorStringsRule) configure(arguments lint.Arguments) { - r.errorFunctions = map[string]map[string]struct{}{ - "fmt": { - "Errorf": {}, - }, - "errors": { - "Errorf": {}, - "WithMessage": {}, - "Wrap": {}, - "New": {}, - "WithMessagef": {}, - "Wrapf": {}, - }, - } - - var invalidCustomFunctions []string - for _, argument := range arguments { - if functionName, ok := argument.(string); ok { - fields := strings.Split(strings.TrimSpace(functionName), ".") - if len(fields) != 2 || len(fields[0]) == 0 || len(fields[1]) == 0 { - invalidCustomFunctions = append(invalidCustomFunctions, functionName) - continue - } - r.errorFunctions[fields[0]] = map[string]struct{}{fields[1]: {}} - } - } - if len(invalidCustomFunctions) != 0 { - panic("found invalid custom function: " + strings.Join(invalidCustomFunctions, ",")) - } -} - -// Apply applies the rule to given file. -func (r *ErrorStringsRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - var failures []lint.Failure - - r.configureOnce.Do(func() { r.configure(arguments) }) - - fileAst := file.AST - walker := lintErrorStrings{ - file: file, - fileAst: fileAst, - errorFunctions: r.errorFunctions, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ErrorStringsRule) Name() string { - return "error-strings" -} - -type lintErrorStrings struct { - file *lint.File - fileAst *ast.File - errorFunctions map[string]map[string]struct{} - onFailure func(lint.Failure) -} - -// Visit browses the AST -func (w lintErrorStrings) Visit(n ast.Node) ast.Visitor { - ce, ok := n.(*ast.CallExpr) - if !ok { - return w - } - - if len(ce.Args) < 1 { - return w - } - - // expression matches the known pkg.function - ok = w.match(ce) - if !ok { - return w - } - - str, ok := w.getMessage(ce) - if !ok { - return w - } - s, _ := strconv.Unquote(str.Value) // can assume well-formed Go - if s == "" { - return w - } - clean, conf := lintErrorString(s) - if clean { - return w - } - w.onFailure(lint.Failure{ - Node: str, - Confidence: conf, - Category: "errors", - Failure: "error strings should not be capitalized or end with punctuation or a newline", - }) - return w -} - -// match returns true if the expression corresponds to the known pkg.function -// i.e.: errors.Wrap -func (w lintErrorStrings) match(expr *ast.CallExpr) bool { - sel, ok := expr.Fun.(*ast.SelectorExpr) - if !ok { - return false - } - // retrieve the package - id, ok := sel.X.(*ast.Ident) - if !ok { - return false - } - functions, ok := w.errorFunctions[id.Name] - if !ok { - return false - } - // retrieve the function - _, ok = functions[sel.Sel.Name] - return ok -} - -// getMessage returns the message depending on its position -// returns false if the cast is unsuccessful -func (w lintErrorStrings) getMessage(expr *ast.CallExpr) (s *ast.BasicLit, success bool) { - str, ok := w.checkArg(expr, 0) - if ok { - return str, true - } - if len(expr.Args) < 2 { - return s, false - } - str, ok = w.checkArg(expr, 1) - if !ok { - return s, false - } - return str, true -} - -func (lintErrorStrings) checkArg(expr *ast.CallExpr, arg int) (s *ast.BasicLit, success bool) { - str, ok := expr.Args[arg].(*ast.BasicLit) - if !ok { - return s, false - } - if str.Kind != token.STRING { - return s, false - } - return str, true -} - -func lintErrorString(s string) (isClean bool, conf float64) { - const basicConfidence = 0.8 - const capConfidence = basicConfidence - 0.2 - first, firstN := utf8.DecodeRuneInString(s) - last, _ := utf8.DecodeLastRuneInString(s) - if last == '.' || last == ':' || last == '!' || last == '\n' { - return false, basicConfidence - } - if unicode.IsUpper(first) { - // People use proper nouns and exported Go identifiers in error strings, - // so decrease the confidence of warnings for capitalization. - if len(s) <= firstN { - return false, capConfidence - } - // Flag strings starting with something that doesn't look like an initialism. - if second, _ := utf8.DecodeRuneInString(s[firstN:]); !unicode.IsUpper(second) { - return false, capConfidence - } - } - return true, 0 -} diff --git a/vendor/github.com/mgechev/revive/rule/errorf.go b/vendor/github.com/mgechev/revive/rule/errorf.go deleted file mode 100644 index 1588a745d..000000000 --- a/vendor/github.com/mgechev/revive/rule/errorf.go +++ /dev/null @@ -1,93 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "regexp" - "strings" - - "github.com/mgechev/revive/lint" -) - -// ErrorfRule lints given else constructs. -type ErrorfRule struct{} - -// Apply applies the rule to given file. -func (*ErrorfRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := lintErrorf{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - file.Pkg.TypeCheck() - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ErrorfRule) Name() string { - return "errorf" -} - -type lintErrorf struct { - file *lint.File - fileAst *ast.File - onFailure func(lint.Failure) -} - -func (w lintErrorf) Visit(n ast.Node) ast.Visitor { - ce, ok := n.(*ast.CallExpr) - if !ok || len(ce.Args) != 1 { - return w - } - isErrorsNew := isPkgDot(ce.Fun, "errors", "New") - var isTestingError bool - se, ok := ce.Fun.(*ast.SelectorExpr) - if ok && se.Sel.Name == "Error" { - if typ := w.file.Pkg.TypeOf(se.X); typ != nil { - isTestingError = typ.String() == "*testing.T" - } - } - if !isErrorsNew && !isTestingError { - return w - } - arg := ce.Args[0] - ce, ok = arg.(*ast.CallExpr) - if !ok || !isPkgDot(ce.Fun, "fmt", "Sprintf") { - return w - } - errorfPrefix := "fmt" - if isTestingError { - errorfPrefix = w.file.Render(se.X) - } - - failure := lint.Failure{ - Category: "errors", - Node: n, - Confidence: 1, - Failure: fmt.Sprintf("should replace %s(fmt.Sprintf(...)) with %s.Errorf(...)", w.file.Render(se), errorfPrefix), - } - - m := srcLineWithMatch(w.file, ce, `^(.*)`+w.file.Render(se)+`\(fmt\.Sprintf\((.*)\)\)(.*)$`) - if m != nil { - failure.ReplacementLine = m[1] + errorfPrefix + ".Errorf(" + m[2] + ")" + m[3] - } - - w.onFailure(failure) - - return w -} - -func srcLineWithMatch(file *lint.File, node ast.Node, pattern string) (m []string) { - line := srcLine(file.Content(), file.ToPosition(node.Pos())) - line = strings.TrimSuffix(line, "\n") - rx := regexp.MustCompile(pattern) - return rx.FindStringSubmatch(line) -} diff --git a/vendor/github.com/mgechev/revive/rule/exported.go b/vendor/github.com/mgechev/revive/rule/exported.go deleted file mode 100644 index 7ee27b309..000000000 --- a/vendor/github.com/mgechev/revive/rule/exported.go +++ /dev/null @@ -1,435 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "strings" - "sync" - "unicode" - "unicode/utf8" - - "github.com/mgechev/revive/internal/typeparams" - "github.com/mgechev/revive/lint" -) - -// disabledChecks store ignored warnings types -type disabledChecks struct { - Const bool - Function bool - Method bool - PrivateReceivers bool - PublicInterfaces bool - Stuttering bool - Type bool - Var bool -} - -const checkNamePrivateReceivers = "privateReceivers" -const checkNamePublicInterfaces = "publicInterfaces" -const checkNameStuttering = "stuttering" - -// isDisabled returns true if the given check is disabled, false otherwise -func (dc *disabledChecks) isDisabled(checkName string) bool { - switch checkName { - case "var": - return dc.Var - case "const": - return dc.Const - case "function": - return dc.Function - case "method": - return dc.Method - case checkNamePrivateReceivers: - return dc.PrivateReceivers - case checkNamePublicInterfaces: - return dc.PublicInterfaces - case checkNameStuttering: - return dc.Stuttering - case "type": - return dc.Type - default: - return false - } -} - -// ExportedRule lints given else constructs. -type ExportedRule struct { - stuttersMsg string - disabledChecks disabledChecks - - configureOnce sync.Once -} - -func (r *ExportedRule) configure(arguments lint.Arguments) { - r.disabledChecks = disabledChecks{PrivateReceivers: true, PublicInterfaces: true} - r.stuttersMsg = "stutters" - for _, flag := range arguments { - switch flag := flag.(type) { - case string: - switch flag { - case "checkPrivateReceivers": - r.disabledChecks.PrivateReceivers = false - case "disableStutteringCheck": - r.disabledChecks.Stuttering = true - case "sayRepetitiveInsteadOfStutters": - r.stuttersMsg = "is repetitive" - case "checkPublicInterface": - r.disabledChecks.PublicInterfaces = false - case "disableChecksOnConstants": - r.disabledChecks.Const = true - case "disableChecksOnFunctions": - r.disabledChecks.Function = true - case "disableChecksOnMethods": - r.disabledChecks.Method = true - case "disableChecksOnTypes": - r.disabledChecks.Type = true - case "disableChecksOnVariables": - r.disabledChecks.Var = true - default: - panic(fmt.Sprintf("Unknown configuration flag %s for %s rule", flag, r.Name())) - } - default: - panic(fmt.Sprintf("Invalid argument for the %s rule: expecting a string, got %T", r.Name(), flag)) - } - } -} - -// Apply applies the rule to given file. -func (r *ExportedRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - - var failures []lint.Failure - if file.IsTest() { - return failures - } - - fileAst := file.AST - - walker := lintExported{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - genDeclMissingComments: make(map[*ast.GenDecl]bool), - stuttersMsg: r.stuttersMsg, - disabledChecks: r.disabledChecks, - } - - ast.Walk(&walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ExportedRule) Name() string { - return "exported" -} - -type lintExported struct { - file *lint.File - fileAst *ast.File - lastGen *ast.GenDecl - genDeclMissingComments map[*ast.GenDecl]bool - onFailure func(lint.Failure) - stuttersMsg string - disabledChecks disabledChecks -} - -func (w *lintExported) lintFuncDoc(fn *ast.FuncDecl) { - if !ast.IsExported(fn.Name.Name) { - return // func is unexported, nothing to do - } - - kind := "function" - name := fn.Name.Name - isMethod := fn.Recv != nil && len(fn.Recv.List) > 0 - if isMethod { - kind = "method" - recv := typeparams.ReceiverType(fn) - - if !ast.IsExported(recv) && w.disabledChecks.PrivateReceivers { - return - } - - if commonMethods[name] { - return - } - - switch name { - case "Len", "Less", "Swap": - sortables := w.file.Pkg.Sortable() - if sortables[recv] { - return - } - } - name = recv + "." + name - } - - if w.disabledChecks.isDisabled(kind) { - return - } - - if fn.Doc == nil { - w.onFailure(lint.Failure{ - Node: fn, - Confidence: 1, - Category: "comments", - Failure: fmt.Sprintf("exported %s %s should have comment or be unexported", kind, name), - }) - return - } - - s := normalizeText(fn.Doc.Text()) - prefix := fn.Name.Name + " " - if !strings.HasPrefix(s, prefix) { - w.onFailure(lint.Failure{ - Node: fn.Doc, - Confidence: 0.8, - Category: "comments", - Failure: fmt.Sprintf(`comment on exported %s %s should be of the form "%s..."`, kind, name, prefix), - }) - } -} - -func (w *lintExported) checkStutter(id *ast.Ident, thing string) { - if w.disabledChecks.Stuttering { - return - } - - pkg, name := w.fileAst.Name.Name, id.Name - if !ast.IsExported(name) { - // unexported name - return - } - // A name stutters if the package name is a strict prefix - // and the next character of the name starts a new word. - if len(name) <= len(pkg) { - // name is too short to stutter. - // This permits the name to be the same as the package name. - return - } - if !strings.EqualFold(pkg, name[:len(pkg)]) { - return - } - // We can assume the name is well-formed UTF-8. - // If the next rune after the package name is uppercase or an underscore - // the it's starting a new word and thus this name stutters. - rem := name[len(pkg):] - if next, _ := utf8.DecodeRuneInString(rem); next == '_' || unicode.IsUpper(next) { - w.onFailure(lint.Failure{ - Node: id, - Confidence: 0.8, - Category: "naming", - Failure: fmt.Sprintf("%s name will be used as %s.%s by other packages, and that %s; consider calling this %s", thing, pkg, name, w.stuttersMsg, rem), - }) - } -} - -func (w *lintExported) lintTypeDoc(t *ast.TypeSpec, doc *ast.CommentGroup) { - if w.disabledChecks.isDisabled("type") { - return - } - - if !ast.IsExported(t.Name.Name) { - return - } - - if doc == nil { - w.onFailure(lint.Failure{ - Node: t, - Confidence: 1, - Category: "comments", - Failure: fmt.Sprintf("exported type %v should have comment or be unexported", t.Name), - }) - return - } - - s := normalizeText(doc.Text()) - articles := [...]string{"A", "An", "The", "This"} - for _, a := range articles { - if t.Name.Name == a { - continue - } - if strings.HasPrefix(s, a+" ") { - s = s[len(a)+1:] - break - } - } - - // if comment starts with name of type and has some text after - it's ok - expectedPrefix := t.Name.Name + " " - if strings.HasPrefix(s, expectedPrefix) { - return - } - - w.onFailure(lint.Failure{ - Node: doc, - Confidence: 1, - Category: "comments", - Failure: fmt.Sprintf(`comment on exported type %v should be of the form "%s..." (with optional leading article)`, t.Name, expectedPrefix), - }) -} - -func (w *lintExported) lintValueSpecDoc(vs *ast.ValueSpec, gd *ast.GenDecl, genDeclMissingComments map[*ast.GenDecl]bool) { - kind := "var" - if gd.Tok == token.CONST { - kind = "const" - } - - if w.disabledChecks.isDisabled(kind) { - return - } - - if len(vs.Names) > 1 { - // Check that none are exported except for the first. - for _, n := range vs.Names[1:] { - if ast.IsExported(n.Name) { - w.onFailure(lint.Failure{ - Category: "comments", - Confidence: 1, - Failure: fmt.Sprintf("exported %s %s should have its own declaration", kind, n.Name), - Node: vs, - }) - return - } - } - } - - // Only one name. - name := vs.Names[0].Name - if !ast.IsExported(name) { - return - } - - if vs.Doc == nil && gd.Doc == nil { - if genDeclMissingComments[gd] { - return - } - block := "" - if kind == "const" && gd.Lparen.IsValid() { - block = " (or a comment on this block)" - } - w.onFailure(lint.Failure{ - Confidence: 1, - Node: vs, - Category: "comments", - Failure: fmt.Sprintf("exported %s %s should have comment%s or be unexported", kind, name, block), - }) - genDeclMissingComments[gd] = true - return - } - // If this GenDecl has parens and a comment, we don't check its comment form. - if gd.Doc != nil && gd.Lparen.IsValid() { - return - } - // The relevant text to check will be on either vs.Doc or gd.Doc. - // Use vs.Doc preferentially. - var doc *ast.CommentGroup - switch { - case vs.Doc != nil: - doc = vs.Doc - case vs.Comment != nil && gd.Doc == nil: - doc = vs.Comment - default: - doc = gd.Doc - } - - prefix := name + " " - s := normalizeText(doc.Text()) - if !strings.HasPrefix(s, prefix) { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: doc, - Category: "comments", - Failure: fmt.Sprintf(`comment on exported %s %s should be of the form "%s..."`, kind, name, prefix), - }) - } -} - -// normalizeText is a helper function that normalizes comment strings by: -// * removing one leading space -// -// This function is needed because ast.CommentGroup.Text() does not handle //-style and /*-style comments uniformly -func normalizeText(t string) string { - return strings.TrimSpace(t) -} - -func (w *lintExported) Visit(n ast.Node) ast.Visitor { - switch v := n.(type) { - case *ast.GenDecl: - if v.Tok == token.IMPORT { - return nil - } - // token.CONST, token.TYPE or token.VAR - w.lastGen = v - return w - case *ast.FuncDecl: - w.lintFuncDoc(v) - if v.Recv == nil { - // Only check for stutter on functions, not methods. - // Method names are not used package-qualified. - w.checkStutter(v.Name, "func") - } - // Don't proceed inside funcs. - return nil - case *ast.TypeSpec: - // inside a GenDecl, which usually has the doc - doc := v.Doc - if doc == nil { - doc = w.lastGen.Doc - } - w.lintTypeDoc(v, doc) - w.checkStutter(v.Name, "type") - - if !w.disabledChecks.PublicInterfaces { - if iface, ok := v.Type.(*ast.InterfaceType); ok { - if ast.IsExported(v.Name.Name) { - w.doCheckPublicInterface(v.Name.Name, iface) - } - } - } - - return nil - case *ast.ValueSpec: - w.lintValueSpecDoc(v, w.lastGen, w.genDeclMissingComments) - return nil - } - return w -} - -func (w *lintExported) doCheckPublicInterface(typeName string, iface *ast.InterfaceType) { - for _, m := range iface.Methods.List { - w.lintInterfaceMethod(typeName, m) - } -} - -func (w *lintExported) lintInterfaceMethod(typeName string, m *ast.Field) { - if len(m.Names) == 0 { - return - } - if !ast.IsExported(m.Names[0].Name) { - return - } - name := m.Names[0].Name - if m.Doc == nil { - w.onFailure(lint.Failure{ - Node: m, - Confidence: 1, - Category: "comments", - Failure: fmt.Sprintf("public interface method %s.%s should be commented", typeName, name), - }) - return - } - s := normalizeText(m.Doc.Text()) - expectedPrefix := m.Names[0].Name + " " - if !strings.HasPrefix(s, expectedPrefix) { - w.onFailure(lint.Failure{ - Node: m.Doc, - Confidence: 0.8, - Category: "comments", - Failure: fmt.Sprintf(`comment on exported interface method %s.%s should be of the form "%s..."`, typeName, name, expectedPrefix), - }) - } -} diff --git a/vendor/github.com/mgechev/revive/rule/file_header.go b/vendor/github.com/mgechev/revive/rule/file_header.go deleted file mode 100644 index 52513d8e8..000000000 --- a/vendor/github.com/mgechev/revive/rule/file_header.go +++ /dev/null @@ -1,84 +0,0 @@ -package rule - -import ( - "fmt" - "regexp" - "sync" - - "github.com/mgechev/revive/lint" -) - -// FileHeaderRule lints given else constructs. -type FileHeaderRule struct { - header string - - configureOnce sync.Once -} - -var ( - multiRegexp = regexp.MustCompile(`^/\*`) - singleRegexp = regexp.MustCompile("^//") -) - -func (r *FileHeaderRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - return - } - - var ok bool - r.header, ok = arguments[0].(string) - if !ok { - panic(fmt.Sprintf("invalid argument for \"file-header\" rule: argument should be a string, got %T", arguments[0])) - } -} - -// Apply applies the rule to given file. -func (r *FileHeaderRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - if r.header == "" { - return nil - } - - failure := []lint.Failure{ - { - Node: file.AST, - Confidence: 1, - Failure: "the file doesn't have an appropriate header", - }, - } - - if len(file.AST.Comments) == 0 { - return failure - } - - g := file.AST.Comments[0] - if g == nil { - return failure - } - comment := "" - for _, c := range g.List { - text := c.Text - if multiRegexp.MatchString(text) { - text = text[2 : len(text)-2] - } else if singleRegexp.MatchString(text) { - text = text[2:] - } - comment += text - } - - regex, err := regexp.Compile(r.header) - if err != nil { - panic(err.Error()) - } - - if !regex.MatchString(comment) { - return failure - } - return nil -} - -// Name returns the rule name. -func (*FileHeaderRule) Name() string { - return "file-header" -} diff --git a/vendor/github.com/mgechev/revive/rule/file_length_limit.go b/vendor/github.com/mgechev/revive/rule/file_length_limit.go deleted file mode 100644 index 0fe075c56..000000000 --- a/vendor/github.com/mgechev/revive/rule/file_length_limit.go +++ /dev/null @@ -1,132 +0,0 @@ -package rule - -import ( - "bufio" - "bytes" - "fmt" - "go/ast" - "go/token" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// FileLengthLimitRule lints the number of lines in a file. -type FileLengthLimitRule struct { - // max is the maximum number of lines allowed in a file. 0 means the rule is disabled. - max int - // skipComments indicates whether to skip comment lines when counting lines. - skipComments bool - // skipBlankLines indicates whether to skip blank lines when counting lines. - skipBlankLines bool - - configureOnce sync.Once -} - -// Apply applies the rule to given file. -func (r *FileLengthLimitRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - if r.max <= 0 { - // when max is negative or 0 the rule is disabled - return nil - } - - all := 0 - blank := 0 - scanner := bufio.NewScanner(bytes.NewReader(file.Content())) - for scanner.Scan() { - all++ - if len(bytes.TrimSpace(scanner.Bytes())) == 0 { - blank++ - } - } - - if err := scanner.Err(); err != nil { - panic(err.Error()) - } - - lines := all - if r.skipComments { - lines -= countCommentLines(file.AST.Comments) - } - - if r.skipBlankLines { - lines -= blank - } - - if lines <= r.max { - return nil - } - - return []lint.Failure{ - { - Category: "code-style", - Confidence: 1, - Position: lint.FailurePosition{ - Start: token.Position{ - Filename: file.Name, - Line: all, - }, - }, - Failure: fmt.Sprintf("file length is %d lines, which exceeds the limit of %d", lines, r.max), - }, - } -} - -func (r *FileLengthLimitRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - return // use default - } - - argKV, ok := arguments[0].(map[string]any) - if !ok { - panic(fmt.Sprintf(`invalid argument to the "file-length-limit" rule. Expecting a k,v map, got %T`, arguments[0])) - } - for k, v := range argKV { - switch k { - case "max": - maxLines, ok := v.(int64) - if !ok || maxLines < 0 { - panic(fmt.Sprintf(`invalid configuration value for max lines in "file-length-limit" rule; need positive int64 but got %T`, arguments[0])) - } - r.max = int(maxLines) - case "skipComments": - skipComments, ok := v.(bool) - if !ok { - panic(fmt.Sprintf(`invalid configuration value for skip comments in "file-length-limit" rule; need bool but got %T`, arguments[1])) - } - r.skipComments = skipComments - case "skipBlankLines": - skipBlankLines, ok := v.(bool) - if !ok { - panic(fmt.Sprintf(`invalid configuration value for skip blank lines in "file-length-limit" rule; need bool but got %T`, arguments[2])) - } - r.skipBlankLines = skipBlankLines - } - } -} - -// Name returns the rule name. -func (*FileLengthLimitRule) Name() string { - return "file-length-limit" -} - -func countCommentLines(comments []*ast.CommentGroup) int { - count := 0 - for _, cg := range comments { - for _, comment := range cg.List { - if len(comment.Text) < 2 { - continue - } - switch comment.Text[1] { - case '/': // single-line comment - count++ - case '*': // multi-line comment - count += strings.Count(comment.Text, "\n") + 1 - } - } - } - return count -} diff --git a/vendor/github.com/mgechev/revive/rule/filename_format.go b/vendor/github.com/mgechev/revive/rule/filename_format.go deleted file mode 100644 index 9d8047829..000000000 --- a/vendor/github.com/mgechev/revive/rule/filename_format.go +++ /dev/null @@ -1,81 +0,0 @@ -package rule - -import ( - "fmt" - "path/filepath" - "regexp" - "sync" - "unicode" - - "github.com/mgechev/revive/lint" -) - -// FilenameFormatRule lints source filenames according to a set of regular expressions given as arguments -type FilenameFormatRule struct { - format *regexp.Regexp - - configureOnce sync.Once -} - -// Apply applies the rule to the given file. -func (r *FilenameFormatRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - filename := filepath.Base(file.Name) - if r.format.MatchString(filename) { - return nil - } - - failureMsg := fmt.Sprintf("Filename %s is not of the format %s.%s", filename, r.format.String(), r.getMsgForNonASCIIChars(filename)) - return []lint.Failure{{ - Confidence: 1, - Failure: failureMsg, - RuleName: r.Name(), - Node: file.AST.Name, - }} -} - -func (r *FilenameFormatRule) getMsgForNonASCIIChars(str string) string { - result := "" - for _, c := range str { - if c <= unicode.MaxASCII { - continue - } - - result += fmt.Sprintf(" Non ASCII character %c (%U) found.", c, c) - } - - return result -} - -// Name returns the rule name. -func (*FilenameFormatRule) Name() string { - return "filename-format" -} - -var defaultFormat = regexp.MustCompile("^[_A-Za-z0-9][_A-Za-z0-9-]*.go$") - -func (r *FilenameFormatRule) configure(arguments lint.Arguments) { - argsCount := len(arguments) - if argsCount == 0 { - r.format = defaultFormat - return - } - - if argsCount > 1 { - panic(fmt.Sprintf("rule %q expects only one argument, got %d %v", r.Name(), argsCount, arguments)) - } - - arg := arguments[0] - str, ok := arg.(string) - if !ok { - panic(fmt.Sprintf("rule %q expects a string argument, got %v of type %T", r.Name(), arg, arg)) - } - - format, err := regexp.Compile(str) - if err != nil { - panic(fmt.Sprintf("rule %q expects a valid regexp argument, got %v for %s", r.Name(), err, arg)) - } - - r.format = format -} diff --git a/vendor/github.com/mgechev/revive/rule/flag_param.go b/vendor/github.com/mgechev/revive/rule/flag_param.go deleted file mode 100644 index f9bfb712c..000000000 --- a/vendor/github.com/mgechev/revive/rule/flag_param.go +++ /dev/null @@ -1,105 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// FlagParamRule lints given else constructs. -type FlagParamRule struct{} - -// Apply applies the rule to given file. -func (*FlagParamRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintFlagParamRule{onFailure: onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*FlagParamRule) Name() string { - return "flag-parameter" -} - -type lintFlagParamRule struct { - onFailure func(lint.Failure) -} - -func (w lintFlagParamRule) Visit(node ast.Node) ast.Visitor { - fd, ok := node.(*ast.FuncDecl) - if !ok { - return w - } - - if fd.Body == nil { - return nil // skip whole function declaration - } - - for _, p := range fd.Type.Params.List { - t := p.Type - - id, ok := t.(*ast.Ident) - if !ok { - continue - } - - if id.Name != "bool" { - continue - } - - cv := conditionVisitor{p.Names, fd, w} - ast.Walk(cv, fd.Body) - } - - return w -} - -type conditionVisitor struct { - ids []*ast.Ident - fd *ast.FuncDecl - linter lintFlagParamRule -} - -func (w conditionVisitor) Visit(node ast.Node) ast.Visitor { - ifStmt, ok := node.(*ast.IfStmt) - if !ok { - return w - } - - fselect := func(n ast.Node) bool { - ident, ok := n.(*ast.Ident) - if !ok { - return false - } - - for _, id := range w.ids { - if ident.Name == id.Name { - return true - } - } - - return false - } - - uses := pick(ifStmt.Cond, fselect) - - if len(uses) < 1 { - return w - } - - w.linter.onFailure(lint.Failure{ - Confidence: 1, - Node: w.fd.Type.Params, - Category: "bad practice", - Failure: fmt.Sprintf("parameter '%s' seems to be a control flag, avoid control coupling", uses[0]), - }) - - return nil -} diff --git a/vendor/github.com/mgechev/revive/rule/function_length.go b/vendor/github.com/mgechev/revive/rule/function_length.go deleted file mode 100644 index c58cd4c0f..000000000 --- a/vendor/github.com/mgechev/revive/rule/function_length.go +++ /dev/null @@ -1,174 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "reflect" - "sync" - - "github.com/mgechev/revive/lint" -) - -// FunctionLength lint. -type FunctionLength struct { - maxStmt int - maxLines int - - configureOnce sync.Once -} - -func (r *FunctionLength) configure(arguments lint.Arguments) { - maxStmt, maxLines := r.parseArguments(arguments) - r.maxStmt = int(maxStmt) - r.maxLines = int(maxLines) -} - -// Apply applies the rule to given file. -func (r *FunctionLength) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - walker := lintFuncLength{ - file: file, - maxStmt: r.maxStmt, - maxLines: r.maxLines, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*FunctionLength) Name() string { - return "function-length" -} - -const defaultFuncStmtsLimit = 50 -const defaultFuncLinesLimit = 75 - -func (*FunctionLength) parseArguments(arguments lint.Arguments) (maxStmt, maxLines int64) { - if len(arguments) == 0 { - return defaultFuncStmtsLimit, defaultFuncLinesLimit - } - - const minArguments = 2 - if len(arguments) != minArguments { - panic(fmt.Sprintf(`invalid configuration for "function-length" rule, expected %d arguments but got %d`, minArguments, len(arguments))) - } - - maxStmt, maxStmtOk := arguments[0].(int64) - if !maxStmtOk { - panic(fmt.Sprintf(`invalid configuration value for max statements in "function-length" rule; need int64 but got %T`, arguments[0])) - } - if maxStmt < 0 { - panic(fmt.Sprintf(`the configuration value for max statements in "function-length" rule cannot be negative, got %d`, maxStmt)) - } - - maxLines, maxLinesOk := arguments[1].(int64) - if !maxLinesOk { - panic(fmt.Sprintf(`invalid configuration value for max lines in "function-length" rule; need int64 but got %T`, arguments[1])) - } - if maxLines < 0 { - panic(fmt.Sprintf(`the configuration value for max statements in "function-length" rule cannot be negative, got %d`, maxLines)) - } - - return maxStmt, maxLines -} - -type lintFuncLength struct { - file *lint.File - maxStmt int - maxLines int - onFailure func(lint.Failure) -} - -func (w lintFuncLength) Visit(n ast.Node) ast.Visitor { - node, ok := n.(*ast.FuncDecl) - if !ok { - return w - } - - body := node.Body - emptyBody := body == nil || len(node.Body.List) == 0 - if emptyBody { - return nil - } - - if w.maxStmt > 0 { - stmtCount := w.countStmts(node.Body.List) - if stmtCount > w.maxStmt { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("maximum number of statements per function exceeded; max %d but got %d", w.maxStmt, stmtCount), - Node: node, - }) - } - } - - if w.maxLines > 0 { - lineCount := w.countLines(node.Body) - if lineCount > w.maxLines { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("maximum number of lines per function exceeded; max %d but got %d", w.maxLines, lineCount), - Node: node, - }) - } - } - - return nil -} - -func (w lintFuncLength) countLines(b *ast.BlockStmt) int { - return w.file.ToPosition(b.End()).Line - w.file.ToPosition(b.Pos()).Line - 1 -} - -func (w lintFuncLength) countStmts(b []ast.Stmt) int { - count := 0 - for _, s := range b { - switch stmt := s.(type) { - case *ast.BlockStmt: - count += w.countStmts(stmt.List) - case *ast.IfStmt: - count += 1 + w.countBodyListStmts(stmt) - if stmt.Else != nil { - elseBody, ok := stmt.Else.(*ast.BlockStmt) - if ok { - count += w.countStmts(elseBody.List) - } - } - case *ast.ForStmt, *ast.RangeStmt, - *ast.SwitchStmt, *ast.TypeSwitchStmt, *ast.SelectStmt: - count += 1 + w.countBodyListStmts(stmt) - case *ast.CaseClause: - count += w.countStmts(stmt.Body) - case *ast.AssignStmt: - count += 1 + w.countFuncLitStmts(stmt.Rhs[0]) - case *ast.GoStmt: - count += 1 + w.countFuncLitStmts(stmt.Call.Fun) - case *ast.DeferStmt: - count += 1 + w.countFuncLitStmts(stmt.Call.Fun) - default: - count++ - } - } - - return count -} - -func (w lintFuncLength) countFuncLitStmts(stmt ast.Expr) int { - if block, ok := stmt.(*ast.FuncLit); ok { - return w.countStmts(block.Body.List) - } - return 0 -} - -func (w lintFuncLength) countBodyListStmts(t any) int { - i := reflect.ValueOf(t).Elem().FieldByName(`Body`).Elem().FieldByName(`List`).Interface() - return w.countStmts(i.([]ast.Stmt)) -} diff --git a/vendor/github.com/mgechev/revive/rule/function_result_limit.go b/vendor/github.com/mgechev/revive/rule/function_result_limit.go deleted file mode 100644 index 5b72f01ab..000000000 --- a/vendor/github.com/mgechev/revive/rule/function_result_limit.go +++ /dev/null @@ -1,85 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -// FunctionResultsLimitRule lints given else constructs. -type FunctionResultsLimitRule struct { - max int - - configureOnce sync.Once -} - -const defaultResultsLimit = 3 - -func (r *FunctionResultsLimitRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.max = defaultResultsLimit - return - } - - maxResults, ok := arguments[0].(int64) // Alt. non panicking version - if !ok { - panic(fmt.Sprintf(`invalid value passed as return results number to the "function-result-limit" rule; need int64 but got %T`, arguments[0])) - } - if maxResults < 0 { - panic(`the value passed as return results number to the "function-result-limit" rule cannot be negative`) - } - - r.max = int(maxResults) -} - -// Apply applies the rule to given file. -func (r *FunctionResultsLimitRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - walker := lintFunctionResultsNum{ - max: r.max, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*FunctionResultsLimitRule) Name() string { - return "function-result-limit" -} - -type lintFunctionResultsNum struct { - max int - onFailure func(lint.Failure) -} - -func (w lintFunctionResultsNum) Visit(n ast.Node) ast.Visitor { - node, ok := n.(*ast.FuncDecl) - if ok { - num := 0 - hasResults := node.Type.Results != nil - if hasResults { - num = node.Type.Results.NumFields() - } - if num > w.max { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("maximum number of return results per function exceeded; max %d but got %d", w.max, num), - Node: node.Type, - }) - } - - return nil // skip visiting function's body - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/get_return.go b/vendor/github.com/mgechev/revive/rule/get_return.go deleted file mode 100644 index 06323a087..000000000 --- a/vendor/github.com/mgechev/revive/rule/get_return.go +++ /dev/null @@ -1,80 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - - "github.com/mgechev/revive/lint" -) - -// GetReturnRule lints given else constructs. -type GetReturnRule struct{} - -// Apply applies the rule to given file. -func (*GetReturnRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintReturnRule{onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*GetReturnRule) Name() string { - return "get-return" -} - -type lintReturnRule struct { - onFailure func(lint.Failure) -} - -const getterPrefix = "GET" - -var lenGetterPrefix = len(getterPrefix) - -func isGetter(name string) bool { - nameHasGetterPrefix := strings.HasPrefix(strings.ToUpper(name), getterPrefix) - if !nameHasGetterPrefix { - return false - } - - isJustGet := len(name) == lenGetterPrefix - if isJustGet { - return false - } - - c := name[lenGetterPrefix] - lowerCaseAfterGetterPrefix := c >= 'a' && c <= 'z' - - return !lowerCaseAfterGetterPrefix -} - -func hasResults(rs *ast.FieldList) bool { - return rs != nil && len(rs.List) > 0 -} - -func (w lintReturnRule) Visit(node ast.Node) ast.Visitor { - fd, ok := node.(*ast.FuncDecl) - if !ok { - return w - } - - if !isGetter(fd.Name.Name) { - return w - } - if !hasResults(fd.Type.Results) { - w.onFailure(lint.Failure{ - Confidence: 0.8, - Node: fd, - Category: "logic", - Failure: fmt.Sprintf("function '%s' seems to be a getter but it does not return any result", fd.Name.Name), - }) - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/identical_branches.go b/vendor/github.com/mgechev/revive/rule/identical_branches.go deleted file mode 100644 index c6008925f..000000000 --- a/vendor/github.com/mgechev/revive/rule/identical_branches.go +++ /dev/null @@ -1,87 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// IdenticalBranchesRule warns on constant logical expressions. -type IdenticalBranchesRule struct{} - -// Apply applies the rule to given file. -func (*IdenticalBranchesRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - astFile := file.AST - w := &lintIdenticalBranches{astFile, onFailure} - ast.Walk(w, astFile) - return failures -} - -// Name returns the rule name. -func (*IdenticalBranchesRule) Name() string { - return "identical-branches" -} - -type lintIdenticalBranches struct { - file *ast.File - onFailure func(lint.Failure) -} - -func (w *lintIdenticalBranches) Visit(node ast.Node) ast.Visitor { - n, ok := node.(*ast.IfStmt) - if !ok { - return w - } - - noElseBranch := n.Else == nil - if noElseBranch { - return w - } - - branches := []*ast.BlockStmt{n.Body} - - elseBranch, ok := n.Else.(*ast.BlockStmt) - if !ok { // if-else-if construction - return w - } - branches = append(branches, elseBranch) - - if w.identicalBranches(branches) { - w.newFailure(n, "both branches of the if are identical") - } - - return w -} - -func (lintIdenticalBranches) identicalBranches(branches []*ast.BlockStmt) bool { - if len(branches) < 2 { - return false // only one branch to compare thus we return - } - - referenceBranch := gofmt(branches[0]) - referenceBranchSize := len(branches[0].List) - for i := 1; i < len(branches); i++ { - currentBranch := branches[i] - currentBranchSize := len(currentBranch.List) - if currentBranchSize != referenceBranchSize || gofmt(currentBranch) != referenceBranch { - return false - } - } - - return true -} - -func (w lintIdenticalBranches) newFailure(node ast.Node, msg string) { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: node, - Category: "logic", - Failure: msg, - }) -} diff --git a/vendor/github.com/mgechev/revive/rule/if_return.go b/vendor/github.com/mgechev/revive/rule/if_return.go deleted file mode 100644 index a6a3113ad..000000000 --- a/vendor/github.com/mgechev/revive/rule/if_return.go +++ /dev/null @@ -1,115 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - "strings" - - "github.com/mgechev/revive/lint" -) - -// IfReturnRule lints given else constructs. -type IfReturnRule struct{} - -// Apply applies the rule to given file. -func (*IfReturnRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - astFile := file.AST - w := &lintElseError{astFile, onFailure} - ast.Walk(w, astFile) - return failures -} - -// Name returns the rule name. -func (*IfReturnRule) Name() string { - return "if-return" -} - -type lintElseError struct { - file *ast.File - onFailure func(lint.Failure) -} - -func (w *lintElseError) Visit(node ast.Node) ast.Visitor { - switch v := node.(type) { - case *ast.BlockStmt: - for i := 0; i < len(v.List)-1; i++ { - // if var := whatever; var != nil { return var } - s, ok := v.List[i].(*ast.IfStmt) - if !ok || s.Body == nil || len(s.Body.List) != 1 || s.Else != nil { - continue - } - assign, ok := s.Init.(*ast.AssignStmt) - if !ok || len(assign.Lhs) != 1 || !(assign.Tok == token.DEFINE || assign.Tok == token.ASSIGN) { - continue - } - id, ok := assign.Lhs[0].(*ast.Ident) - if !ok { - continue - } - expr, ok := s.Cond.(*ast.BinaryExpr) - if !ok || expr.Op != token.NEQ { - continue - } - if lhs, ok := expr.X.(*ast.Ident); !ok || lhs.Name != id.Name { - continue - } - if rhs, ok := expr.Y.(*ast.Ident); !ok || rhs.Name != "nil" { - continue - } - r, ok := s.Body.List[0].(*ast.ReturnStmt) - if !ok || len(r.Results) != 1 { - continue - } - if r, ok := r.Results[0].(*ast.Ident); !ok || r.Name != id.Name { - continue - } - - // return nil - r, ok = v.List[i+1].(*ast.ReturnStmt) - if !ok || len(r.Results) != 1 { - continue - } - if r, ok := r.Results[0].(*ast.Ident); !ok || r.Name != "nil" { - continue - } - - // check if there are any comments explaining the construct, don't emit an error if there are some. - if containsComments(s.Pos(), r.Pos(), w.file) { - continue - } - - w.onFailure(lint.Failure{ - Confidence: .9, - Node: v.List[i], - Failure: "redundant if ...; err != nil check, just return error instead.", - }) - } - } - return w -} - -func containsComments(start, end token.Pos, f *ast.File) bool { - for _, cgroup := range f.Comments { - comments := cgroup.List - if comments[0].Slash >= end { - // All comments starting with this group are after end pos. - return false - } - if comments[len(comments)-1].Slash < start { - // Comments group ends before start pos. - continue - } - for _, c := range comments { - if start <= c.Slash && c.Slash < end && !strings.HasPrefix(c.Text, "// MATCH ") { - return true - } - } - } - return false -} diff --git a/vendor/github.com/mgechev/revive/rule/import_alias_naming.go b/vendor/github.com/mgechev/revive/rule/import_alias_naming.go deleted file mode 100644 index 043bf0d76..000000000 --- a/vendor/github.com/mgechev/revive/rule/import_alias_naming.go +++ /dev/null @@ -1,120 +0,0 @@ -package rule - -import ( - "fmt" - "regexp" - "sync" - - "github.com/mgechev/revive/lint" -) - -// ImportAliasNamingRule lints import alias naming. -type ImportAliasNamingRule struct { - allowRegexp *regexp.Regexp - denyRegexp *regexp.Regexp - - configureOnce sync.Once -} - -const defaultImportAliasNamingAllowRule = "^[a-z][a-z0-9]{0,}$" - -var defaultImportAliasNamingAllowRegexp = regexp.MustCompile(defaultImportAliasNamingAllowRule) - -func (r *ImportAliasNamingRule) configure(arguments lint.Arguments) { - if len(arguments) == 0 { - r.allowRegexp = defaultImportAliasNamingAllowRegexp - return - } - - switch namingRule := arguments[0].(type) { - case string: - r.setAllowRule(namingRule) - case map[string]any: // expecting map[string]string - for k, v := range namingRule { - switch k { - case "allowRegex": - r.setAllowRule(v) - case "denyRegex": - r.setDenyRule(v) - default: - panic(fmt.Sprintf("Invalid map key for 'import-alias-naming' rule. Expecting 'allowRegex' or 'denyRegex', got %v", k)) - } - } - default: - panic(fmt.Sprintf("Invalid argument '%v' for 'import-alias-naming' rule. Expecting string or map[string]string, got %T", arguments[0], arguments[0])) - } - - if r.allowRegexp == nil && r.denyRegexp == nil { - r.allowRegexp = defaultImportAliasNamingAllowRegexp - } -} - -// Apply applies the rule to given file. -func (r *ImportAliasNamingRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - for _, is := range file.AST.Imports { - path := is.Path - if path == nil { - continue - } - - alias := is.Name - if alias == nil || alias.Name == "_" || alias.Name == "." { // "_" and "." are special types of import aliases and should be processed by another linter rule - continue - } - - if r.allowRegexp != nil && !r.allowRegexp.MatchString(alias.Name) { - failures = append(failures, lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("import name (%s) must match the regular expression: %s", alias.Name, r.allowRegexp.String()), - Node: alias, - Category: "imports", - }) - } - - if r.denyRegexp != nil && r.denyRegexp.MatchString(alias.Name) { - failures = append(failures, lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("import name (%s) must NOT match the regular expression: %s", alias.Name, r.denyRegexp.String()), - Node: alias, - Category: "imports", - }) - } - } - - return failures -} - -// Name returns the rule name. -func (*ImportAliasNamingRule) Name() string { - return "import-alias-naming" -} - -func (r *ImportAliasNamingRule) setAllowRule(value any) { - namingRule, ok := value.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument '%v' for import-alias-naming allowRegexp rule. Expecting string, got %T", value, value)) - } - - namingRuleRegexp, err := regexp.Compile(namingRule) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the import-alias-naming allowRegexp rule. Expecting %q to be a valid regular expression, got: %v", namingRule, err)) - } - r.allowRegexp = namingRuleRegexp -} - -func (r *ImportAliasNamingRule) setDenyRule(value any) { - namingRule, ok := value.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument '%v' for import-alias-naming denyRegexp rule. Expecting string, got %T", value, value)) - } - - namingRuleRegexp, err := regexp.Compile(namingRule) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the import-alias-naming denyRegexp rule. Expecting %q to be a valid regular expression, got: %v", namingRule, err)) - } - r.denyRegexp = namingRuleRegexp -} diff --git a/vendor/github.com/mgechev/revive/rule/import_shadowing.go b/vendor/github.com/mgechev/revive/rule/import_shadowing.go deleted file mode 100644 index 046aeb688..000000000 --- a/vendor/github.com/mgechev/revive/rule/import_shadowing.go +++ /dev/null @@ -1,115 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "strings" - - "github.com/mgechev/revive/lint" -) - -// ImportShadowingRule lints given else constructs. -type ImportShadowingRule struct{} - -// Apply applies the rule to given file. -func (*ImportShadowingRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - importNames := map[string]struct{}{} - for _, imp := range file.AST.Imports { - importNames[getName(imp)] = struct{}{} - } - - fileAst := file.AST - walker := importShadowing{ - packageNameIdent: fileAst.Name, - importNames: importNames, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - alreadySeen: map[*ast.Object]struct{}{}, - skipIdents: map[*ast.Ident]struct{}{}, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ImportShadowingRule) Name() string { - return "import-shadowing" -} - -func getName(imp *ast.ImportSpec) string { - const pathSep = "/" - const strDelim = `"` - if imp.Name != nil { - return imp.Name.Name - } - - path := imp.Path.Value - i := strings.LastIndex(path, pathSep) - if i == -1 { - return strings.Trim(path, strDelim) - } - - return strings.Trim(path[i+1:], strDelim) -} - -type importShadowing struct { - packageNameIdent *ast.Ident - importNames map[string]struct{} - onFailure func(lint.Failure) - alreadySeen map[*ast.Object]struct{} - skipIdents map[*ast.Ident]struct{} -} - -// Visit visits AST nodes and checks if id nodes (ast.Ident) shadow an import name -func (w importShadowing) Visit(n ast.Node) ast.Visitor { - switch n := n.(type) { - case *ast.AssignStmt: - if n.Tok == token.DEFINE { - return w // analyze variable declarations of the form id := expr - } - - return nil // skip assigns of the form id = expr (not an id declaration) - case *ast.CallExpr, // skip call expressions (not an id declaration) - *ast.ImportSpec, // skip import section subtree because we already have the list of imports - *ast.KeyValueExpr, // skip analysis of key-val expressions ({key:value}): ids of such expressions, even the same of an import name, do not shadow the import name - *ast.ReturnStmt, // skip skipping analysis of returns, ids in expression were already analyzed - *ast.SelectorExpr, // skip analysis of selector expressions (anId.otherId): because if anId shadows an import name, it was already detected, and otherId does not shadows the import name - *ast.StructType: // skip analysis of struct type because struct fields can not shadow an import name - return nil - case *ast.FuncDecl: - if n.Recv != nil { - w.skipIdents[n.Name] = struct{}{} - } - case *ast.Ident: - if n == w.packageNameIdent { - return nil // skip the ident corresponding to the package name of this file - } - - id := n.Name - if id == "_" { - return w // skip _ id - } - - _, isImportName := w.importNames[id] - _, alreadySeen := w.alreadySeen[n.Obj] - _, skipIdent := w.skipIdents[n] - if isImportName && !alreadySeen && !skipIdent { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: n, - Category: "naming", - Failure: fmt.Sprintf("The name '%s' shadows an import name", id), - }) - - w.alreadySeen[n.Obj] = struct{}{} - } - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/imports_blocklist.go b/vendor/github.com/mgechev/revive/rule/imports_blocklist.go deleted file mode 100644 index 18d77ca1c..000000000 --- a/vendor/github.com/mgechev/revive/rule/imports_blocklist.go +++ /dev/null @@ -1,68 +0,0 @@ -package rule - -import ( - "fmt" - "regexp" - "sync" - - "github.com/mgechev/revive/lint" -) - -// ImportsBlocklistRule lints given else constructs. -type ImportsBlocklistRule struct { - blocklist []*regexp.Regexp - - configureOnce sync.Once -} - -var replaceImportRegexp = regexp.MustCompile(`/?\*\*/?`) - -func (r *ImportsBlocklistRule) configure(arguments lint.Arguments) { - r.blocklist = []*regexp.Regexp{} - for _, arg := range arguments { - argStr, ok := arg.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the imports-blocklist rule. Expecting a string, got %T", arg)) - } - regStr, err := regexp.Compile(fmt.Sprintf(`(?m)"%s"$`, replaceImportRegexp.ReplaceAllString(argStr, `(\W|\w)*`))) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the imports-blocklist rule. Expecting %q to be a valid regular expression, got: %v", argStr, err)) - } - r.blocklist = append(r.blocklist, regStr) - } -} - -func (r *ImportsBlocklistRule) isBlocklisted(path string) bool { - for _, regex := range r.blocklist { - if regex.MatchString(path) { - return true - } - } - return false -} - -// Apply applies the rule to given file. -func (r *ImportsBlocklistRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - for _, is := range file.AST.Imports { - path := is.Path - if path != nil && r.isBlocklisted(path.Value) { - failures = append(failures, lint.Failure{ - Confidence: 1, - Failure: "should not use the following blocklisted import: " + path.Value, - Node: is, - Category: "imports", - }) - } - } - - return failures -} - -// Name returns the rule name. -func (*ImportsBlocklistRule) Name() string { - return "imports-blocklist" -} diff --git a/vendor/github.com/mgechev/revive/rule/increment_decrement.go b/vendor/github.com/mgechev/revive/rule/increment_decrement.go deleted file mode 100644 index 34a8e1ec5..000000000 --- a/vendor/github.com/mgechev/revive/rule/increment_decrement.go +++ /dev/null @@ -1,73 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// IncrementDecrementRule lints given else constructs. -type IncrementDecrementRule struct{} - -// Apply applies the rule to given file. -func (*IncrementDecrementRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := lintIncrementDecrement{ - file: file, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*IncrementDecrementRule) Name() string { - return "increment-decrement" -} - -type lintIncrementDecrement struct { - file *lint.File - onFailure func(lint.Failure) -} - -func (w lintIncrementDecrement) Visit(n ast.Node) ast.Visitor { - as, ok := n.(*ast.AssignStmt) - if !ok { - return w - } - if len(as.Lhs) != 1 { - return w - } - if !isOne(as.Rhs[0]) { - return w - } - var suffix string - switch as.Tok { - case token.ADD_ASSIGN: - suffix = "++" - case token.SUB_ASSIGN: - suffix = "--" - default: - return w - } - w.onFailure(lint.Failure{ - Confidence: 0.8, - Node: as, - Category: "unary-op", - Failure: fmt.Sprintf("should replace %s with %s%s", w.file.Render(as), w.file.Render(as.Lhs[0]), suffix), - }) - return w -} - -func isOne(expr ast.Expr) bool { - lit, ok := expr.(*ast.BasicLit) - return ok && lit.Kind == token.INT && lit.Value == "1" -} diff --git a/vendor/github.com/mgechev/revive/rule/indent_error_flow.go b/vendor/github.com/mgechev/revive/rule/indent_error_flow.go deleted file mode 100644 index ebc1e793a..000000000 --- a/vendor/github.com/mgechev/revive/rule/indent_error_flow.go +++ /dev/null @@ -1,45 +0,0 @@ -package rule - -import ( - "github.com/mgechev/revive/internal/ifelse" - "github.com/mgechev/revive/lint" -) - -// IndentErrorFlowRule lints given else constructs. -type IndentErrorFlowRule struct{} - -// Apply applies the rule to given file. -func (e *IndentErrorFlowRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - return ifelse.Apply(e, file.AST, ifelse.TargetElse, args) -} - -// Name returns the rule name. -func (*IndentErrorFlowRule) Name() string { - return "indent-error-flow" -} - -// CheckIfElse evaluates the rule against an ifelse.Chain and returns a failure message if applicable. -func (*IndentErrorFlowRule) CheckIfElse(chain ifelse.Chain, args ifelse.Args) string { - if !chain.If.Deviates() { - // this rule only applies if the if-block deviates control flow - return "" - } - - if chain.HasPriorNonDeviating { - // if we de-indent the "else" block then a previous branch - // might flow into it, affecting program behaviour - return "" - } - - if !chain.If.Returns() { - // avoid overlapping with superfluous-else - return "" - } - - if args.PreserveScope && !chain.AtBlockEnd && (chain.HasInitializer || chain.Else.HasDecls) { - // avoid increasing variable scope - return "" - } - - return "if block ends with a return statement, so drop this else and outdent its block" -} diff --git a/vendor/github.com/mgechev/revive/rule/line_length_limit.go b/vendor/github.com/mgechev/revive/rule/line_length_limit.go deleted file mode 100644 index 415761e1e..000000000 --- a/vendor/github.com/mgechev/revive/rule/line_length_limit.go +++ /dev/null @@ -1,99 +0,0 @@ -package rule - -import ( - "bufio" - "bytes" - "fmt" - "go/token" - "strings" - "sync" - "unicode/utf8" - - "github.com/mgechev/revive/lint" -) - -// LineLengthLimitRule lints given else constructs. -type LineLengthLimitRule struct { - max int - - configureOnce sync.Once -} - -const defaultLineLengthLimit = 80 - -func (r *LineLengthLimitRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.max = defaultLineLengthLimit - return - } - - maxLength, ok := arguments[0].(int64) // Alt. non panicking version - if !ok || maxLength < 0 { - panic(`invalid value passed as argument number to the "line-length-limit" rule`) - } - - r.max = int(maxLength) -} - -// Apply applies the rule to given file. -func (r *LineLengthLimitRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - checker := lintLineLengthNum{ - max: r.max, - file: file, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - checker.check() - - return failures -} - -// Name returns the rule name. -func (*LineLengthLimitRule) Name() string { - return "line-length-limit" -} - -type lintLineLengthNum struct { - max int - file *lint.File - onFailure func(lint.Failure) -} - -func (r lintLineLengthNum) check() { - f := bytes.NewReader(r.file.Content()) - spaces := strings.Repeat(" ", 4) // tab width = 4 - l := 1 - s := bufio.NewScanner(f) - for s.Scan() { - t := s.Text() - t = strings.ReplaceAll(t, "\t", spaces) - c := utf8.RuneCountInString(t) - if c > r.max { - r.onFailure(lint.Failure{ - Category: "code-style", - Position: lint.FailurePosition{ - // Offset not set; it is non-trivial, and doesn't appear to be needed. - Start: token.Position{ - Filename: r.file.Name, - Line: l, - Column: 0, - }, - End: token.Position{ - Filename: r.file.Name, - Line: l, - Column: c, - }, - }, - Confidence: 1, - Failure: fmt.Sprintf("line is %d characters, out of limit %d", c, r.max), - }) - } - l++ - } -} diff --git a/vendor/github.com/mgechev/revive/rule/max_control_nesting.go b/vendor/github.com/mgechev/revive/rule/max_control_nesting.go deleted file mode 100644 index b2c5af70e..000000000 --- a/vendor/github.com/mgechev/revive/rule/max_control_nesting.go +++ /dev/null @@ -1,123 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -// MaxControlNestingRule lints given else constructs. -type MaxControlNestingRule struct { - max int64 - - configureOnce sync.Once -} - -const defaultMaxControlNesting = 5 - -// Apply applies the rule to given file. -func (r *MaxControlNestingRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - fileAst := file.AST - - walker := &lintMaxControlNesting{ - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - max: int(r.max), - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*MaxControlNestingRule) Name() string { - return "max-control-nesting" -} - -type lintMaxControlNesting struct { - max int - onFailure func(lint.Failure) - nestingLevelAcc int - lastCtrlStmt ast.Node -} - -func (w *lintMaxControlNesting) Visit(n ast.Node) ast.Visitor { - if w.nestingLevelAcc > w.max { // we are visiting a node beyond the max nesting level - w.onFailure(lint.Failure{ - Failure: fmt.Sprintf("control flow nesting exceeds %d", w.max), - Confidence: 1, - Node: w.lastCtrlStmt, - Category: "complexity", - }) - return nil // stop visiting deeper - } - - switch v := n.(type) { - case *ast.IfStmt: - w.lastCtrlStmt = v - w.walkControlledBlock(v.Body) // "then" branch block - if v.Else != nil { - w.walkControlledBlock(v.Else) // "else" branch block - } - return nil // stop re-visiting nesting blocks (already visited by w.walkControlledBlock) - - case *ast.ForStmt: - w.lastCtrlStmt = v - w.walkControlledBlock(v.Body) - return nil // stop re-visiting nesting blocks (already visited by w.walkControlledBlock) - - case *ast.CaseClause: // switch case - w.lastCtrlStmt = v - for _, s := range v.Body { // visit each statement in the case clause - w.walkControlledBlock(s) - } - return nil // stop re-visiting nesting blocks (already visited by w.walkControlledBlock) - - case *ast.CommClause: // select case - w.lastCtrlStmt = v - for _, s := range v.Body { // visit each statement in the select case clause - w.walkControlledBlock(s) - } - return nil // stop re-visiting nesting blocks (already visited by w.walkControlledBlock) - - case *ast.FuncLit: - walker := &lintMaxControlNesting{ - onFailure: w.onFailure, - max: w.max, - } - ast.Walk(walker, v.Body) - return nil - } - - return w -} - -func (w *lintMaxControlNesting) walkControlledBlock(b ast.Node) { - oldNestingLevel := w.nestingLevelAcc - w.nestingLevelAcc++ - ast.Walk(w, b) - w.nestingLevelAcc = oldNestingLevel -} - -func (r *MaxControlNestingRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.max = defaultMaxControlNesting - return - } - - checkNumberOfArguments(1, arguments, r.Name()) - - maxNesting, ok := arguments[0].(int64) // Alt. non panicking version - if !ok { - panic(`invalid value passed as argument number to the "max-control-nesting" rule`) - } - r.max = maxNesting -} diff --git a/vendor/github.com/mgechev/revive/rule/max_public_structs.go b/vendor/github.com/mgechev/revive/rule/max_public_structs.go deleted file mode 100644 index d6f91e375..000000000 --- a/vendor/github.com/mgechev/revive/rule/max_public_structs.go +++ /dev/null @@ -1,90 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// MaxPublicStructsRule lints given else constructs. -type MaxPublicStructsRule struct { - max int64 - - configureOnce sync.Once -} - -const defaultMaxPublicStructs = 5 - -func (r *MaxPublicStructsRule) configure(arguments lint.Arguments) { - if len(arguments) < 1 { - r.max = defaultMaxPublicStructs - return - } - - checkNumberOfArguments(1, arguments, r.Name()) - - maxStructs, ok := arguments[0].(int64) // Alt. non panicking version - if !ok { - panic(`invalid value passed as argument number to the "max-public-structs" rule`) - } - r.max = maxStructs -} - -// Apply applies the rule to given file. -func (r *MaxPublicStructsRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - if r.max < 1 { - return failures - } - - fileAst := file.AST - - walker := &lintMaxPublicStructs{ - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, fileAst) - - if walker.current > r.max { - walker.onFailure(lint.Failure{ - Failure: fmt.Sprintf("you have exceeded the maximum number (%d) of public struct declarations", r.max), - Confidence: 1, - Node: fileAst, - Category: "style", - }) - } - - return failures -} - -// Name returns the rule name. -func (*MaxPublicStructsRule) Name() string { - return "max-public-structs" -} - -type lintMaxPublicStructs struct { - current int64 - fileAst *ast.File - onFailure func(lint.Failure) -} - -func (w *lintMaxPublicStructs) Visit(n ast.Node) ast.Visitor { - switch v := n.(type) { - case *ast.TypeSpec: - name := v.Name.Name - first := string(name[0]) - if strings.ToUpper(first) == first { - w.current++ - } - } - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/modifies_param.go b/vendor/github.com/mgechev/revive/rule/modifies_param.go deleted file mode 100644 index a68ae2501..000000000 --- a/vendor/github.com/mgechev/revive/rule/modifies_param.go +++ /dev/null @@ -1,80 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// ModifiesParamRule lints given else constructs. -type ModifiesParamRule struct{} - -// Apply applies the rule to given file. -func (*ModifiesParamRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintModifiesParamRule{onFailure: onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*ModifiesParamRule) Name() string { - return "modifies-parameter" -} - -type lintModifiesParamRule struct { - params map[string]bool - onFailure func(lint.Failure) -} - -func retrieveParamNames(pl []*ast.Field) map[string]bool { - result := make(map[string]bool, len(pl)) - for _, p := range pl { - for _, n := range p.Names { - if n.Name == "_" { - continue - } - - result[n.Name] = true - } - } - return result -} - -func (w lintModifiesParamRule) Visit(node ast.Node) ast.Visitor { - switch v := node.(type) { - case *ast.FuncDecl: - w.params = retrieveParamNames(v.Type.Params.List) - case *ast.IncDecStmt: - if id, ok := v.X.(*ast.Ident); ok { - checkParam(id, &w) - } - case *ast.AssignStmt: - lhs := v.Lhs - for _, e := range lhs { - id, ok := e.(*ast.Ident) - if ok { - checkParam(id, &w) - } - } - } - - return w -} - -func checkParam(id *ast.Ident, w *lintModifiesParamRule) { - if w.params[id.Name] { - w.onFailure(lint.Failure{ - Confidence: 0.5, // confidence is low because of shadow variables - Node: id, - Category: "bad practice", - Failure: fmt.Sprintf("parameter '%s' seems to be modified", id), - }) - } -} diff --git a/vendor/github.com/mgechev/revive/rule/modifies_value_receiver.go b/vendor/github.com/mgechev/revive/rule/modifies_value_receiver.go deleted file mode 100644 index 2f92991f5..000000000 --- a/vendor/github.com/mgechev/revive/rule/modifies_value_receiver.go +++ /dev/null @@ -1,179 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - "strings" - - "github.com/mgechev/revive/lint" -) - -// ModifiesValRecRule lints assignments to value method-receivers. -type ModifiesValRecRule struct{} - -// Apply applies the rule to given file. -func (*ModifiesValRecRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintModifiesValRecRule{file: file, onFailure: onFailure} - file.Pkg.TypeCheck() - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*ModifiesValRecRule) Name() string { - return "modifies-value-receiver" -} - -type lintModifiesValRecRule struct { - file *lint.File - onFailure func(lint.Failure) -} - -func (w lintModifiesValRecRule) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.FuncDecl: - if n.Recv == nil { - return nil // skip, not a method - } - - receiver := n.Recv.List[0] - if _, ok := receiver.Type.(*ast.StarExpr); ok { - return nil // skip, method with pointer receiver - } - - if w.skipType(receiver.Type) { - return nil // skip, receiver is a map or array - } - - if len(receiver.Names) < 1 { - return nil // skip, anonymous receiver - } - - receiverName := receiver.Names[0].Name - if receiverName == "_" { - return nil // skip, anonymous receiver - } - - receiverAssignmentFinder := func(n ast.Node) bool { - // look for assignments with the receiver in the right hand - assignment, ok := n.(*ast.AssignStmt) - if !ok { - return false - } - - for _, exp := range assignment.Lhs { - switch e := exp.(type) { - case *ast.IndexExpr: // receiver...[] = ... - continue - case *ast.StarExpr: // *receiver = ... - continue - case *ast.SelectorExpr: // receiver.field = ... - name := w.getNameFromExpr(e.X) - if name == "" || name != receiverName { - continue - } - case *ast.Ident: // receiver := ... - if e.Name != receiverName { - continue - } - default: - continue - } - - return true - } - - return false - } - - assignmentsToReceiver := pick(n.Body, receiverAssignmentFinder) - if len(assignmentsToReceiver) == 0 { - return nil // receiver is not modified - } - - methodReturnsReceiver := len(w.findReturnReceiverStatements(receiverName, n.Body)) > 0 - if methodReturnsReceiver { - return nil // modification seems legit (see issue #1066) - } - - for _, assignment := range assignmentsToReceiver { - w.onFailure(lint.Failure{ - Node: assignment, - Confidence: 1, - Failure: "suspicious assignment to a by-value method receiver", - }) - } - } - - return w -} - -func (w lintModifiesValRecRule) skipType(t ast.Expr) bool { - rt := w.file.Pkg.TypeOf(t) - if rt == nil { - return false - } - - rt = rt.Underlying() - rtName := rt.String() - - // skip when receiver is a map or array - return strings.HasPrefix(rtName, "[]") || strings.HasPrefix(rtName, "map[") -} - -func (lintModifiesValRecRule) getNameFromExpr(ie ast.Expr) string { - ident, ok := ie.(*ast.Ident) - if !ok { - return "" - } - - return ident.Name -} - -func (w lintModifiesValRecRule) findReturnReceiverStatements(receiverName string, target ast.Node) []ast.Node { - finder := func(n ast.Node) bool { - // look for returns with the receiver as value - returnStatement, ok := n.(*ast.ReturnStmt) - if !ok { - return false - } - - for _, exp := range returnStatement.Results { - switch e := exp.(type) { - case *ast.SelectorExpr: // receiver.field = ... - name := w.getNameFromExpr(e.X) - if name == "" || name != receiverName { - continue - } - case *ast.Ident: // receiver := ... - if e.Name != receiverName { - continue - } - case *ast.UnaryExpr: - if e.Op != token.AND { - continue - } - name := w.getNameFromExpr(e.X) - if name == "" || name != receiverName { - continue - } - - default: - continue - } - - return true - } - - return false - } - - return pick(target, finder) -} diff --git a/vendor/github.com/mgechev/revive/rule/nested_structs.go b/vendor/github.com/mgechev/revive/rule/nested_structs.go deleted file mode 100644 index 147bd482b..000000000 --- a/vendor/github.com/mgechev/revive/rule/nested_structs.go +++ /dev/null @@ -1,75 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// NestedStructs lints nested structs. -type NestedStructs struct{} - -// Apply applies the rule to given file. -func (*NestedStructs) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - walker := &lintNestedStructs{ - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*NestedStructs) Name() string { - return "nested-structs" -} - -type lintNestedStructs struct { - onFailure func(lint.Failure) -} - -func (l *lintNestedStructs) Visit(n ast.Node) ast.Visitor { - if v, ok := n.(*ast.StructType); ok { - ls := &lintStruct{l.onFailure} - ast.Walk(ls, v.Fields) - } - - return l -} - -type lintStruct struct { - onFailure func(lint.Failure) -} - -func (l *lintStruct) Visit(n ast.Node) ast.Visitor { - switch s := n.(type) { - case *ast.StructType: - l.fail(s) - return nil - case *ast.ArrayType: - if _, ok := s.Elt.(*ast.StructType); ok { - l.fail(s) - } - return nil - case *ast.ChanType: - return nil - case *ast.MapType: - return nil - default: - return l - } -} - -func (l *lintStruct) fail(n ast.Node) { - l.onFailure(lint.Failure{ - Failure: "no nested structs are allowed", - Category: "style", - Node: n, - Confidence: 1, - }) -} diff --git a/vendor/github.com/mgechev/revive/rule/optimize_operands_order.go b/vendor/github.com/mgechev/revive/rule/optimize_operands_order.go deleted file mode 100644 index 43d982d6b..000000000 --- a/vendor/github.com/mgechev/revive/rule/optimize_operands_order.go +++ /dev/null @@ -1,86 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// OptimizeOperandsOrderRule lints given else constructs. -type OptimizeOperandsOrderRule struct{} - -// Apply applies the rule to given file. -func (*OptimizeOperandsOrderRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - w := lintOptimizeOperandsOrderlExpr{ - onFailure: onFailure, - } - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*OptimizeOperandsOrderRule) Name() string { - return "optimize-operands-order" -} - -type lintOptimizeOperandsOrderlExpr struct { - onFailure func(failure lint.Failure) -} - -// Visit checks boolean AND and OR expressions to determine -// if swapping their operands may result in an execution speedup. -func (w lintOptimizeOperandsOrderlExpr) Visit(node ast.Node) ast.Visitor { - binExpr, ok := node.(*ast.BinaryExpr) - if !ok { - return w - } - - switch binExpr.Op { - case token.LAND, token.LOR: - default: - return w - } - - isCaller := func(n ast.Node) bool { - ce, ok := n.(*ast.CallExpr) - if !ok { - return false - } - - ident, isIdent := ce.Fun.(*ast.Ident) - if !isIdent { - return true - } - - return ident.Name != "len" || ident.Obj != nil - } - - // check if the left sub-expression contains a function call - nodes := pick(binExpr.X, isCaller) - if len(nodes) < 1 { - return w - } - - // check if the right sub-expression does not contain a function call - nodes = pick(binExpr.Y, isCaller) - if len(nodes) > 0 { - return w - } - - newExpr := ast.BinaryExpr{X: binExpr.Y, Y: binExpr.X, Op: binExpr.Op} - w.onFailure(lint.Failure{ - Failure: fmt.Sprintf("for better performance '%v' might be rewritten as '%v'", gofmt(binExpr), gofmt(&newExpr)), - Node: node, - Category: "optimization", - Confidence: 0.3, - }) - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/package_comments.go b/vendor/github.com/mgechev/revive/rule/package_comments.go deleted file mode 100644 index f1e5462fe..000000000 --- a/vendor/github.com/mgechev/revive/rule/package_comments.go +++ /dev/null @@ -1,164 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// PackageCommentsRule lints the package comments. It complains if -// there is no package comment, or if it is not of the right form. -// This has a notable false positive in that a package comment -// could rightfully appear in a different file of the same package, -// but that's not easy to fix since this linter is file-oriented. -type PackageCommentsRule struct { - checkPackageCommentCache sync.Map -} - -// Apply applies the rule to given file. -func (r *PackageCommentsRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - if file.IsTest() { - return failures - } - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - fileAst := file.AST - w := &lintPackageComments{fileAst, file, onFailure, r} - ast.Walk(w, fileAst) - return failures -} - -// Name returns the rule name. -func (*PackageCommentsRule) Name() string { - return "package-comments" -} - -type lintPackageComments struct { - fileAst *ast.File - file *lint.File - onFailure func(lint.Failure) - rule *PackageCommentsRule -} - -func (l *lintPackageComments) checkPackageComment() []lint.Failure { - // deduplicate warnings in package - if _, exists := l.rule.checkPackageCommentCache.LoadOrStore(l.file.Pkg, struct{}{}); exists { - return nil - } - var docFile *ast.File // which name is doc.go - var packageFile *ast.File // which name is $package.go - var firstFile *ast.File - var firstFileName string - var fileSource string - for name, file := range l.file.Pkg.Files() { - if file.AST.Doc != nil { - return nil - } - if name == "doc.go" { - docFile = file.AST - fileSource = "doc.go" - } - if name == file.AST.Name.String()+".go" { - packageFile = file.AST - } - if firstFileName == "" || firstFileName > name { - firstFile = file.AST - firstFileName = name - } - } - // prefer warning on doc.go, $package.go over first file - if docFile == nil { - docFile = packageFile - fileSource = l.fileAst.Name.String() + ".go" - } - if docFile == nil { - docFile = firstFile - fileSource = firstFileName - } - - if docFile != nil { - pkgFile := l.file.Pkg.Files()[fileSource] - return []lint.Failure{{ - Category: "comments", - Position: lint.FailurePosition{ - Start: pkgFile.ToPosition(docFile.Pos()), - End: pkgFile.ToPosition(docFile.Name.End()), - }, - Confidence: 1, - Failure: "should have a package comment", - }} - } - return nil -} - -func (l *lintPackageComments) Visit(_ ast.Node) ast.Visitor { - if l.file.IsTest() { - return nil - } - - prefix := "Package " + l.fileAst.Name.Name + " " - - // Look for a detached package comment. - // First, scan for the last comment that occurs before the "package" keyword. - var lastCG *ast.CommentGroup - for _, cg := range l.fileAst.Comments { - if cg.Pos() > l.fileAst.Package { - // Gone past "package" keyword. - break - } - lastCG = cg - } - if lastCG != nil && strings.HasPrefix(lastCG.Text(), prefix) { - endPos := l.file.ToPosition(lastCG.End()) - pkgPos := l.file.ToPosition(l.fileAst.Package) - if endPos.Line+1 < pkgPos.Line { - // There isn't a great place to anchor this error; - // the start of the blank lines between the doc and the package statement - // is at least pointing at the location of the problem. - pos := token.Position{ - Filename: endPos.Filename, - // Offset not set; it is non-trivial, and doesn't appear to be needed. - Line: endPos.Line + 1, - Column: 1, - } - l.onFailure(lint.Failure{ - Category: "comments", - Position: lint.FailurePosition{ - Start: pos, - End: pos, - }, - Confidence: 0.9, - Failure: "package comment is detached; there should be no blank lines between it and the package statement", - }) - return nil - } - } - - if l.fileAst.Doc == nil { - for _, failure := range l.checkPackageComment() { - l.onFailure(failure) - } - return nil - } - s := l.fileAst.Doc.Text() - - // Only non-main packages need to keep to this form. - if !l.file.Pkg.IsMain() && !strings.HasPrefix(s, prefix) && !isDirectiveComment(s) { - l.onFailure(lint.Failure{ - Category: "comments", - Node: l.fileAst.Doc, - Confidence: 1, - Failure: fmt.Sprintf(`package comment should be of the form "%s..."`, prefix), - }) - } - return nil -} diff --git a/vendor/github.com/mgechev/revive/rule/range.go b/vendor/github.com/mgechev/revive/rule/range.go deleted file mode 100644 index 9d483a673..000000000 --- a/vendor/github.com/mgechev/revive/rule/range.go +++ /dev/null @@ -1,82 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - - "github.com/mgechev/revive/lint" -) - -// RangeRule lints given else constructs. -type RangeRule struct{} - -// Apply applies the rule to given file. -func (*RangeRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := &lintRanges{file, onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*RangeRule) Name() string { - return "range" -} - -type lintRanges struct { - file *lint.File - onFailure func(lint.Failure) -} - -func (w *lintRanges) Visit(node ast.Node) ast.Visitor { - rs, ok := node.(*ast.RangeStmt) - if !ok { - return w - } - if rs.Value == nil { - // for x = range m { ... } - return w // single var form - } - if !isIdent(rs.Value, "_") { - // for ?, y = range m { ... } - return w - } - - newRS := *rs // shallow copy - newRS.Value = nil - - w.onFailure(lint.Failure{ - Failure: fmt.Sprintf("should omit 2nd value from range; this loop is equivalent to `for %s %s range ...`", w.file.Render(rs.Key), rs.Tok), - Confidence: 1, - Node: rs.Value, - ReplacementLine: firstLineOf(w.file, &newRS, rs), - }) - - return w -} - -func firstLineOf(f *lint.File, node, match ast.Node) string { - line := f.Render(node) - if i := strings.Index(line, "\n"); i >= 0 { - line = line[:i] - } - return indentOf(f, match) + line -} - -func indentOf(f *lint.File, node ast.Node) string { - line := srcLine(f.Content(), f.ToPosition(node.Pos())) - for i, r := range line { - switch r { - case ' ', '\t': - default: - return line[:i] - } - } - return line // unusual or empty line -} diff --git a/vendor/github.com/mgechev/revive/rule/range_val_address.go b/vendor/github.com/mgechev/revive/rule/range_val_address.go deleted file mode 100644 index d2ab0392a..000000000 --- a/vendor/github.com/mgechev/revive/rule/range_val_address.go +++ /dev/null @@ -1,166 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "strings" - - "github.com/mgechev/revive/lint" -) - -// RangeValAddress lints -type RangeValAddress struct{} - -// Apply applies the rule to given file. -func (*RangeValAddress) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - if file.Pkg.IsAtLeastGo122() { - return failures - } - - walker := rangeValAddress{ - file: file, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - file.Pkg.TypeCheck() - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*RangeValAddress) Name() string { - return "range-val-address" -} - -type rangeValAddress struct { - file *lint.File - onFailure func(lint.Failure) -} - -func (w rangeValAddress) Visit(node ast.Node) ast.Visitor { - n, ok := node.(*ast.RangeStmt) - if !ok { - return w - } - - value, ok := n.Value.(*ast.Ident) - if !ok { - return w - } - - valueIsStarExpr := false - if t := w.file.Pkg.TypeOf(value); t != nil { - valueIsStarExpr = strings.HasPrefix(t.String(), "*") - } - - ast.Walk(rangeBodyVisitor{ - valueIsStarExpr: valueIsStarExpr, - valueID: value.Obj, - onFailure: w.onFailure, - }, n.Body) - - return w -} - -type rangeBodyVisitor struct { - valueIsStarExpr bool - valueID *ast.Object - onFailure func(lint.Failure) -} - -func (bw rangeBodyVisitor) Visit(node ast.Node) ast.Visitor { - asgmt, ok := node.(*ast.AssignStmt) - if !ok { - return bw - } - - for _, exp := range asgmt.Lhs { - e, ok := exp.(*ast.IndexExpr) - if !ok { - continue - } - if bw.isAccessingRangeValueAddress(e.Index) { // e.g. a[&value]... - bw.onFailure(bw.newFailure(e.Index)) - } - } - - for _, exp := range asgmt.Rhs { - switch e := exp.(type) { - case *ast.UnaryExpr: // e.g. ...&value, ...&value.id - if bw.isAccessingRangeValueAddress(e) { - bw.onFailure(bw.newFailure(e)) - } - case *ast.CallExpr: - if fun, ok := e.Fun.(*ast.Ident); ok && fun.Name == "append" { // e.g. ...append(arr, &value) - for _, v := range e.Args { - if lit, ok := v.(*ast.CompositeLit); ok { // e.g. ...append(arr, v{id:&value}) - bw.checkCompositeLit(lit) - continue - } - if bw.isAccessingRangeValueAddress(v) { // e.g. ...append(arr, &value) - bw.onFailure(bw.newFailure(v)) - } - } - } - case *ast.CompositeLit: // e.g. ...v{id:&value} - bw.checkCompositeLit(e) - } - } - return bw -} - -func (bw rangeBodyVisitor) checkCompositeLit(comp *ast.CompositeLit) { - for _, exp := range comp.Elts { - e, ok := exp.(*ast.KeyValueExpr) - if !ok { - continue - } - if bw.isAccessingRangeValueAddress(e.Value) { - bw.onFailure(bw.newFailure(e.Value)) - } - } -} - -func (bw rangeBodyVisitor) isAccessingRangeValueAddress(exp ast.Expr) bool { - u, ok := exp.(*ast.UnaryExpr) - if !ok { - return false - } - - if u.Op != token.AND { - return false - } - - v, ok := u.X.(*ast.Ident) - if !ok { - var s *ast.SelectorExpr - s, ok = u.X.(*ast.SelectorExpr) - if !ok { - return false - } - v, ok = s.X.(*ast.Ident) - if !ok { - return false - } - - if bw.valueIsStarExpr { // check type of value - return false - } - } - - return ok && v.Obj == bw.valueID -} - -func (bw rangeBodyVisitor) newFailure(node ast.Node) lint.Failure { - return lint.Failure{ - Node: node, - Confidence: 1, - Failure: fmt.Sprintf("suspicious assignment of '%s'. range-loop variables always have the same address", bw.valueID.Name), - } -} diff --git a/vendor/github.com/mgechev/revive/rule/range_val_in_closure.go b/vendor/github.com/mgechev/revive/rule/range_val_in_closure.go deleted file mode 100644 index 6f9255a74..000000000 --- a/vendor/github.com/mgechev/revive/rule/range_val_in_closure.go +++ /dev/null @@ -1,125 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// RangeValInClosureRule lints given else constructs. -type RangeValInClosureRule struct{} - -// Apply applies the rule to given file. -func (*RangeValInClosureRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - if file.Pkg.IsAtLeastGo122() { - return failures - } - - walker := rangeValInClosure{ - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*RangeValInClosureRule) Name() string { - return "range-val-in-closure" -} - -type rangeValInClosure struct { - onFailure func(lint.Failure) -} - -func (w rangeValInClosure) Visit(node ast.Node) ast.Visitor { - // Find the variables updated by the loop statement. - var vars []*ast.Ident - addVar := func(expr ast.Expr) { - if id, ok := expr.(*ast.Ident); ok { - vars = append(vars, id) - } - } - var body *ast.BlockStmt - switch n := node.(type) { - case *ast.RangeStmt: - body = n.Body - addVar(n.Key) - addVar(n.Value) - case *ast.ForStmt: - body = n.Body - switch post := n.Post.(type) { - case *ast.AssignStmt: - // e.g. for p = head; p != nil; p = p.next - for _, lhs := range post.Lhs { - addVar(lhs) - } - case *ast.IncDecStmt: - // e.g. for i := 0; i < n; i++ - addVar(post.X) - } - } - if vars == nil { - return w - } - - // Inspect a go or defer statement - // if it's the last one in the loop body. - // (We give up if there are following statements, - // because it's hard to prove go isn't followed by wait, - // or defer by return.) - if len(body.List) == 0 { - return w - } - var last *ast.CallExpr - switch s := body.List[len(body.List)-1].(type) { - case *ast.GoStmt: - last = s.Call - case *ast.DeferStmt: - last = s.Call - default: - return w - } - lit, ok := last.Fun.(*ast.FuncLit) - if !ok { - return w - } - - if lit.Type == nil { - // Not referring to a variable (e.g. struct field name) - return w - } - - var inspector func(n ast.Node) bool - inspector = func(n ast.Node) bool { - kv, ok := n.(*ast.KeyValueExpr) - if ok { - // do not check identifiers acting as key in key-value expressions (see issue #637) - ast.Inspect(kv.Value, inspector) - return false - } - id, ok := n.(*ast.Ident) - if !ok || id.Obj == nil { - return true - } - - for _, v := range vars { - if v.Obj == id.Obj { - w.onFailure(lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("loop variable %v captured by func literal", id.Name), - Node: n, - }) - } - } - return true - } - ast.Inspect(lit.Body, inspector) - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/receiver_naming.go b/vendor/github.com/mgechev/revive/rule/receiver_naming.go deleted file mode 100644 index c83bacc2f..000000000 --- a/vendor/github.com/mgechev/revive/rule/receiver_naming.go +++ /dev/null @@ -1,128 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/internal/typeparams" - "github.com/mgechev/revive/lint" -) - -// ReceiverNamingRule lints given else constructs. -type ReceiverNamingRule struct { - receiverNameMaxLength int - - configureOnce sync.Once -} - -const defaultReceiverNameMaxLength = -1 // thus will not check - -func (r *ReceiverNamingRule) configure(arguments lint.Arguments) { - r.receiverNameMaxLength = defaultReceiverNameMaxLength - if len(arguments) < 1 { - return - } - - args, ok := arguments[0].(map[string]any) - if !ok { - panic(fmt.Sprintf("Unable to get arguments for rule %s. Expected object of key-value-pairs.", r.Name())) - } - - for k, v := range args { - switch k { - case "maxLength": - value, ok := v.(int64) - if !ok { - panic(fmt.Sprintf("Invalid value %v for argument %s of rule %s, expected integer value got %T", v, k, r.Name(), v)) - } - r.receiverNameMaxLength = int(value) - default: - panic(fmt.Sprintf("Unknown argument %s for %s rule.", k, r.Name())) - } - } -} - -// Apply applies the rule to given file. -func (r *ReceiverNamingRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - - var failures []lint.Failure - - fileAst := file.AST - walker := lintReceiverName{ - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - typeReceiver: map[string]string{}, - receiverNameMaxLength: r.receiverNameMaxLength, - } - - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*ReceiverNamingRule) Name() string { - return "receiver-naming" -} - -type lintReceiverName struct { - onFailure func(lint.Failure) - typeReceiver map[string]string - receiverNameMaxLength int -} - -func (w lintReceiverName) Visit(n ast.Node) ast.Visitor { - fn, ok := n.(*ast.FuncDecl) - if !ok || fn.Recv == nil || len(fn.Recv.List) == 0 { - return w - } - names := fn.Recv.List[0].Names - if len(names) < 1 { - return w - } - name := names[0].Name - if name == "_" { - w.onFailure(lint.Failure{ - Node: n, - Confidence: 1, - Category: "naming", - Failure: "receiver name should not be an underscore, omit the name if it is unused", - }) - return w - } - if name == "this" || name == "self" { - w.onFailure(lint.Failure{ - Node: n, - Confidence: 1, - Category: "naming", - Failure: `receiver name should be a reflection of its identity; don't use generic names such as "this" or "self"`, - }) - return w - } - - if w.receiverNameMaxLength > 0 && len([]rune(name)) > w.receiverNameMaxLength { - w.onFailure(lint.Failure{ - Node: n, - Confidence: 1, - Category: "naming", - Failure: fmt.Sprintf("receiver name %s is longer than %d characters", name, w.receiverNameMaxLength), - }) - return w - } - - recv := typeparams.ReceiverType(fn) - if prev, ok := w.typeReceiver[recv]; ok && prev != name { - w.onFailure(lint.Failure{ - Node: n, - Confidence: 1, - Category: "naming", - Failure: fmt.Sprintf("receiver name %s should be consistent with previous receiver name %s for %s", name, prev, recv), - }) - return w - } - w.typeReceiver[recv] = name - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/redefines_builtin_id.go b/vendor/github.com/mgechev/revive/rule/redefines_builtin_id.go deleted file mode 100644 index 10ea16ae1..000000000 --- a/vendor/github.com/mgechev/revive/rule/redefines_builtin_id.go +++ /dev/null @@ -1,224 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "maps" - - "github.com/mgechev/revive/lint" -) - -var builtInConstAndVars = map[string]bool{ - "true": true, - "false": true, - "iota": true, - "nil": true, -} - -var builtFunctions = map[string]bool{ - "append": true, - "cap": true, - "close": true, - "complex": true, - "copy": true, - "delete": true, - "imag": true, - "len": true, - "make": true, - "new": true, - "panic": true, - "print": true, - "println": true, - "real": true, - "recover": true, -} - -var builtFunctionsAfterGo121 = map[string]bool{ - "clear": true, - "max": true, - "min": true, -} - -var builtInTypes = map[string]bool{ - "bool": true, - "byte": true, - "complex128": true, - "complex64": true, - "error": true, - "float32": true, - "float64": true, - "int": true, - "int16": true, - "int32": true, - "int64": true, - "int8": true, - "rune": true, - "string": true, - "uint": true, - "uint16": true, - "uint32": true, - "uint64": true, - "uint8": true, - "uintptr": true, - "any": true, -} - -// RedefinesBuiltinIDRule warns when a builtin identifier is shadowed. -type RedefinesBuiltinIDRule struct{} - -// Apply applies the rule to given file. -func (*RedefinesBuiltinIDRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - astFile := file.AST - - builtFuncs := maps.Clone(builtFunctions) - if file.Pkg.IsAtLeastGo121() { - maps.Copy(builtFuncs, builtFunctionsAfterGo121) - } - w := &lintRedefinesBuiltinID{ - onFailure: onFailure, - builtInConstAndVars: builtInConstAndVars, - builtFunctions: builtFuncs, - builtInTypes: builtInTypes, - } - ast.Walk(w, astFile) - - return failures -} - -// Name returns the rule name. -func (*RedefinesBuiltinIDRule) Name() string { - return "redefines-builtin-id" -} - -type lintRedefinesBuiltinID struct { - onFailure func(lint.Failure) - builtInConstAndVars map[string]bool - builtFunctions map[string]bool - builtInTypes map[string]bool -} - -func (w *lintRedefinesBuiltinID) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.GenDecl: - switch n.Tok { - case token.TYPE: - if len(n.Specs) < 1 { - return nil - } - typeSpec, ok := n.Specs[0].(*ast.TypeSpec) - if !ok { - return nil - } - id := typeSpec.Name.Name - if ok, bt := w.isBuiltIn(id); ok { - w.addFailure(n, fmt.Sprintf("redefinition of the built-in %s %s", bt, id)) - } - case token.VAR, token.CONST: - for _, vs := range n.Specs { - valSpec, ok := vs.(*ast.ValueSpec) - if !ok { - continue - } - for _, name := range valSpec.Names { - if ok, bt := w.isBuiltIn(name.Name); ok { - w.addFailure(n, fmt.Sprintf("redefinition of the built-in %s %s", bt, name)) - } - } - } - default: - return nil // skip if not type/var/const declaration - } - - case *ast.FuncDecl: - if n.Recv != nil { - return w // skip methods - } - - id := n.Name.Name - if ok, bt := w.isBuiltIn(id); ok { - w.addFailure(n, fmt.Sprintf("redefinition of the built-in %s %s", bt, id)) - } - case *ast.FuncType: - var fields []*ast.Field - if n.TypeParams != nil { - fields = append(fields, n.TypeParams.List...) - } - if n.Params != nil { - fields = append(fields, n.Params.List...) - } - if n.Results != nil { - fields = append(fields, n.Results.List...) - } - for _, field := range fields { - for _, name := range field.Names { - obj := name.Obj - isTypeOrName := obj != nil && (obj.Kind == ast.Var || obj.Kind == ast.Typ) - if !isTypeOrName { - continue - } - - id := obj.Name - if ok, bt := w.isBuiltIn(id); ok { - w.addFailure(name, fmt.Sprintf("redefinition of the built-in %s %s", bt, id)) - } - } - } - case *ast.AssignStmt: - for _, e := range n.Lhs { - id, ok := e.(*ast.Ident) - if !ok { - continue - } - - if ok, bt := w.isBuiltIn(id.Name); ok { - var msg string - switch bt { - case "constant or variable": - if n.Tok == token.DEFINE { - msg = fmt.Sprintf("assignment creates a shadow of built-in identifier %s", id.Name) - } else { - msg = fmt.Sprintf("assignment modifies built-in identifier %s", id.Name) - } - default: - msg = fmt.Sprintf("redefinition of the built-in %s %s", bt, id) - } - - w.addFailure(n, msg) - } - } - } - - return w -} - -func (w lintRedefinesBuiltinID) addFailure(node ast.Node, msg string) { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: node, - Category: "logic", - Failure: msg, - }) -} - -func (w *lintRedefinesBuiltinID) isBuiltIn(id string) (r bool, builtInKind string) { - if w.builtFunctions[id] { - return true, "function" - } - - if w.builtInConstAndVars[id] { - return true, "constant or variable" - } - - if w.builtInTypes[id] { - return true, "type" - } - - return false, "" -} diff --git a/vendor/github.com/mgechev/revive/rule/redundant_import_alias.go b/vendor/github.com/mgechev/revive/rule/redundant_import_alias.go deleted file mode 100644 index fa5281f24..000000000 --- a/vendor/github.com/mgechev/revive/rule/redundant_import_alias.go +++ /dev/null @@ -1,52 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strings" - - "github.com/mgechev/revive/lint" -) - -// RedundantImportAlias lints given else constructs. -type RedundantImportAlias struct{} - -// Apply applies the rule to given file. -func (*RedundantImportAlias) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - for _, imp := range file.AST.Imports { - if imp.Name == nil { - continue - } - - if getImportPackageName(imp) == imp.Name.Name { - failures = append(failures, lint.Failure{ - Confidence: 1, - Failure: fmt.Sprintf("Import alias \"%s\" is redundant", imp.Name.Name), - Node: imp, - Category: "imports", - }) - } - } - - return failures -} - -// Name returns the rule name. -func (*RedundantImportAlias) Name() string { - return "redundant-import-alias" -} - -func getImportPackageName(imp *ast.ImportSpec) string { - const pathSep = "/" - const strDelim = `"` - - path := imp.Path.Value - i := strings.LastIndex(path, pathSep) - if i == -1 { - return strings.Trim(path, strDelim) - } - - return strings.Trim(path[i+1:], strDelim) -} diff --git a/vendor/github.com/mgechev/revive/rule/string_format.go b/vendor/github.com/mgechev/revive/rule/string_format.go deleted file mode 100644 index ecac3fa7c..000000000 --- a/vendor/github.com/mgechev/revive/rule/string_format.go +++ /dev/null @@ -1,328 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "regexp" - "strconv" - "strings" - - "github.com/mgechev/revive/lint" -) - -// #region Revive API - -// StringFormatRule lints strings and/or comments according to a set of regular expressions given as Arguments -type StringFormatRule struct{} - -// Apply applies the rule to the given file. -func (*StringFormatRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintStringFormatRule{onFailure: onFailure} - w.parseArguments(arguments) - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*StringFormatRule) Name() string { - return "string-format" -} - -// ParseArgumentsTest is a public wrapper around w.parseArguments used for testing. Returns the error message provided to panic, or nil if no error was encountered -func (StringFormatRule) ParseArgumentsTest(arguments lint.Arguments) *string { - w := lintStringFormatRule{} - c := make(chan any) - // Parse the arguments in a goroutine, defer a recover() call, return the error encountered (or nil if there was no error) - go func() { - defer func() { - err := recover() - c <- err - }() - w.parseArguments(arguments) - }() - err := <-c - if err != nil { - e := fmt.Sprintf("%s", err) - return &e - } - return nil -} - -// #endregion - -// #region Internal structure - -type lintStringFormatRule struct { - onFailure func(lint.Failure) - rules []stringFormatSubrule -} - -type stringFormatSubrule struct { - parent *lintStringFormatRule - scopes stringFormatSubruleScopes - regexp *regexp.Regexp - negated bool - errorMessage string -} - -type stringFormatSubruleScopes []*stringFormatSubruleScope - -type stringFormatSubruleScope struct { - funcName string // Function name the rule is scoped to - argument int // (optional) Which argument in calls to the function is checked against the rule (the first argument is checked by default) - field string // (optional) If the argument to be checked is a struct, which member of the struct is checked against the rule (top level members only) -} - -// Regex inserted to match valid function/struct field identifiers -const identRegex = "[_A-Za-z][_A-Za-z0-9]*" - -var parseStringFormatScope = regexp.MustCompile( - fmt.Sprintf("^(%s(?:\\.%s)?)(?:\\[([0-9]+)\\](?:\\.(%s))?)?$", identRegex, identRegex, identRegex)) - -// #endregion - -// #region Argument parsing - -func (w *lintStringFormatRule) parseArguments(arguments lint.Arguments) { - for i, argument := range arguments { - scopes, regex, negated, errorMessage := w.parseArgument(argument, i) - w.rules = append(w.rules, stringFormatSubrule{ - parent: w, - scopes: scopes, - regexp: regex, - negated: negated, - errorMessage: errorMessage, - }) - } -} - -func (w lintStringFormatRule) parseArgument(argument any, ruleNum int) (scopes stringFormatSubruleScopes, regex *regexp.Regexp, negated bool, errorMessage string) { - g, ok := argument.([]any) // Cast to generic slice first - if !ok { - w.configError("argument is not a slice", ruleNum, 0) - } - if len(g) < 2 { - w.configError("less than two slices found in argument, scope and regex are required", ruleNum, len(g)-1) - } - rule := make([]string, len(g)) - for i, obj := range g { - val, ok := obj.(string) - if !ok { - w.configError("unexpected value, string was expected", ruleNum, i) - } - rule[i] = val - } - - // Validate scope and regex length - if rule[0] == "" { - w.configError("empty scope provided", ruleNum, 0) - } else if len(rule[1]) < 2 { - w.configError("regex is too small (regexes should begin and end with '/')", ruleNum, 1) - } - - // Parse rule scopes - rawScopes := strings.Split(rule[0], ",") - - scopes = make([]*stringFormatSubruleScope, 0, len(rawScopes)) - for scopeNum, rawScope := range rawScopes { - rawScope = strings.TrimSpace(rawScope) - - if len(rawScope) == 0 { - w.parseScopeError("empty scope in rule scopes:", ruleNum, 0, scopeNum) - } - - scope := stringFormatSubruleScope{} - matches := parseStringFormatScope.FindStringSubmatch(rawScope) - if matches == nil { - // The rule's scope didn't match the parsing regex at all, probably a configuration error - w.parseScopeError("unable to parse rule scope", ruleNum, 0, scopeNum) - } else if len(matches) != 4 { - // The rule's scope matched the parsing regex, but an unexpected number of submatches was returned, probably a bug - w.parseScopeError(fmt.Sprintf("unexpected number of submatches when parsing scope: %d, expected 4", len(matches)), ruleNum, 0, scopeNum) - } - scope.funcName = matches[1] - if len(matches[2]) > 0 { - var err error - scope.argument, err = strconv.Atoi(matches[2]) - if err != nil { - w.parseScopeError("unable to parse argument number in rule scope", ruleNum, 0, scopeNum) - } - } - if len(matches[3]) > 0 { - scope.field = matches[3] - } - - scopes = append(scopes, &scope) - } - - // Strip / characters from the beginning and end of rule[1] before compiling - negated = rule[1][0] == '!' - offset := 1 - if negated { - offset++ - } - regex, err := regexp.Compile(rule[1][offset : len(rule[1])-1]) - if err != nil { - w.parseError(fmt.Sprintf("unable to compile %s as regexp", rule[1]), ruleNum, 1) - } - - // Use custom error message if provided - if len(rule) == 3 { - errorMessage = rule[2] - } - return scopes, regex, negated, errorMessage -} - -// Report an invalid config, this is specifically the user's fault -func (lintStringFormatRule) configError(msg string, ruleNum, option int) { - panic(fmt.Sprintf("invalid configuration for string-format: %s [argument %d, option %d]", msg, ruleNum, option)) -} - -// Report a general config parsing failure, this may be the user's fault, but it isn't known for certain -func (lintStringFormatRule) parseError(msg string, ruleNum, option int) { - panic(fmt.Sprintf("failed to parse configuration for string-format: %s [argument %d, option %d]", msg, ruleNum, option)) -} - -// Report a general scope config parsing failure, this may be the user's fault, but it isn't known for certain -func (lintStringFormatRule) parseScopeError(msg string, ruleNum, option, scopeNum int) { - panic(fmt.Sprintf("failed to parse configuration for string-format: %s [argument %d, option %d, scope index %d]", msg, ruleNum, option, scopeNum)) -} - -// #endregion - -// #region Node traversal - -func (w lintStringFormatRule) Visit(node ast.Node) ast.Visitor { - // First, check if node is a call expression - call, ok := node.(*ast.CallExpr) - if !ok { - return w - } - - // Get the name of the call expression to check against rule scope - callName, ok := w.getCallName(call) - if !ok { - return w - } - - for _, rule := range w.rules { - for _, scope := range rule.scopes { - if scope.funcName == callName { - rule.apply(call, scope) - } - } - } - - return w -} - -// Return the name of a call expression in the form of package.Func or Func -func (lintStringFormatRule) getCallName(call *ast.CallExpr) (callName string, ok bool) { - if ident, ok := call.Fun.(*ast.Ident); ok { - // Local function call - return ident.Name, true - } - - if selector, ok := call.Fun.(*ast.SelectorExpr); ok { - // Scoped function call - scope, ok := selector.X.(*ast.Ident) - if ok { - return scope.Name + "." + selector.Sel.Name, true - } - // Scoped function call inside structure - recv, ok := selector.X.(*ast.SelectorExpr) - if ok { - return recv.Sel.Name + "." + selector.Sel.Name, true - } - } - - return "", false -} - -// #endregion - -// #region Linting logic - -// apply a single format rule to a call expression (should be done after verifying the that the call expression matches the rule's scope) -func (r *stringFormatSubrule) apply(call *ast.CallExpr, scope *stringFormatSubruleScope) { - if len(call.Args) <= scope.argument { - return - } - - arg := call.Args[scope.argument] - var lit *ast.BasicLit - if len(scope.field) > 0 { - // Try finding the scope's Field, treating arg as a composite literal - composite, ok := arg.(*ast.CompositeLit) - if !ok { - return - } - for _, el := range composite.Elts { - kv, ok := el.(*ast.KeyValueExpr) - if !ok { - continue - } - key, ok := kv.Key.(*ast.Ident) - if !ok || key.Name != scope.field { - continue - } - - // We're now dealing with the exact field in the rule's scope, so if anything fails, we can safely return instead of continuing the loop - lit, ok = kv.Value.(*ast.BasicLit) - if !ok || lit.Kind != token.STRING { - return - } - } - } else { - var ok bool - // Treat arg as a string literal - lit, ok = arg.(*ast.BasicLit) - if !ok || lit.Kind != token.STRING { - return - } - } - // Unquote the string literal before linting - unquoted := lit.Value[1 : len(lit.Value)-1] - if r.stringIsOK(unquoted) { - return - } - - r.generateFailure(lit) -} - -func (r *stringFormatSubrule) stringIsOK(s string) bool { - matches := r.regexp.MatchString(s) - if r.negated { - return !matches - } - - return matches -} - -func (r *stringFormatSubrule) generateFailure(node ast.Node) { - var failure string - switch { - case len(r.errorMessage) > 0: - failure = r.errorMessage - case r.negated: - failure = fmt.Sprintf("string literal matches user defined regex /%s/", r.regexp.String()) - case !r.negated: - failure = fmt.Sprintf("string literal doesn't match user defined regex /%s/", r.regexp.String()) - } - - r.parent.onFailure(lint.Failure{ - Confidence: 1, - Failure: failure, - Node: node, - }) -} - -// #endregion diff --git a/vendor/github.com/mgechev/revive/rule/string_of_int.go b/vendor/github.com/mgechev/revive/rule/string_of_int.go deleted file mode 100644 index 3bec1d6ac..000000000 --- a/vendor/github.com/mgechev/revive/rule/string_of_int.go +++ /dev/null @@ -1,95 +0,0 @@ -package rule - -import ( - "go/ast" - "go/types" - - "github.com/mgechev/revive/lint" -) - -// StringOfIntRule warns when logic expressions contains Boolean literals. -type StringOfIntRule struct{} - -// Apply applies the rule to given file. -func (*StringOfIntRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - astFile := file.AST - file.Pkg.TypeCheck() - - w := &lintStringInt{file, onFailure} - ast.Walk(w, astFile) - - return failures -} - -// Name returns the rule name. -func (*StringOfIntRule) Name() string { - return "string-of-int" -} - -type lintStringInt struct { - file *lint.File - onFailure func(lint.Failure) -} - -func (w *lintStringInt) Visit(node ast.Node) ast.Visitor { - ce, ok := node.(*ast.CallExpr) - if !ok { - return w - } - - if !w.isCallStringCast(ce.Fun) { - return w - } - - if !w.isIntExpression(ce.Args) { - return w - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: ce, - Failure: "dubious conversion of an integer into a string, use strconv.Itoa", - }) - - return w -} - -func (w *lintStringInt) isCallStringCast(e ast.Expr) bool { - t := w.file.Pkg.TypeOf(e) - if t == nil { - return false - } - - tb, _ := t.Underlying().(*types.Basic) - - return tb != nil && tb.Kind() == types.String -} - -func (w *lintStringInt) isIntExpression(es []ast.Expr) bool { - if len(es) != 1 { - return false - } - - t := w.file.Pkg.TypeOf(es[0]) - if t == nil { - return false - } - - ut, _ := t.Underlying().(*types.Basic) - if ut == nil || ut.Info()&types.IsInteger == 0 { - return false - } - - switch ut.Kind() { - case types.Byte, types.Rune, types.UntypedRune: - return false - } - - return true -} diff --git a/vendor/github.com/mgechev/revive/rule/struct_tag.go b/vendor/github.com/mgechev/revive/rule/struct_tag.go deleted file mode 100644 index 4dd927827..000000000 --- a/vendor/github.com/mgechev/revive/rule/struct_tag.go +++ /dev/null @@ -1,424 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "strconv" - "strings" - "sync" - - "github.com/fatih/structtag" - "github.com/mgechev/revive/lint" -) - -// StructTagRule lints struct tags. -type StructTagRule struct { - userDefined map[string][]string // map: key -> []option - - configureOnce sync.Once -} - -func (r *StructTagRule) configure(arguments lint.Arguments) { - if len(arguments) == 0 { - return - } - - checkNumberOfArguments(1, arguments, r.Name()) - r.userDefined = make(map[string][]string, len(arguments)) - for _, arg := range arguments { - item, ok := arg.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the %s rule. Expecting a string, got %v (of type %T)", r.Name(), arg, arg)) - } - parts := strings.Split(item, ",") - if len(parts) < 2 { - panic(fmt.Sprintf("Invalid argument to the %s rule. Expecting a string of the form key[,option]+, got %s", r.Name(), item)) - } - key := strings.TrimSpace(parts[0]) - for i := 1; i < len(parts); i++ { - option := strings.TrimSpace(parts[i]) - r.userDefined[key] = append(r.userDefined[key], option) - } - } -} - -// Apply applies the rule to given file. -func (r *StructTagRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintStructTagRule{ - onFailure: onFailure, - userDefined: r.userDefined, - } - - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*StructTagRule) Name() string { - return "struct-tag" -} - -type lintStructTagRule struct { - onFailure func(lint.Failure) - userDefined map[string][]string // map: key -> []option - usedTagNbr map[int]bool // list of used tag numbers - usedTagName map[string]bool // list of used tag keys -} - -func (w lintStructTagRule) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.StructType: - isEmptyStruct := n.Fields == nil || n.Fields.NumFields() < 1 - if isEmptyStruct { - return nil // skip empty structs - } - - w.usedTagNbr = map[int]bool{} - w.usedTagName = map[string]bool{} - for _, f := range n.Fields.List { - if f.Tag != nil { - w.checkTaggedField(f) - } - } - } - - return w -} - -const keyASN1 = "asn1" -const keyBSON = "bson" -const keyDefault = "default" -const keyJSON = "json" -const keyProtobuf = "protobuf" -const keyRequired = "required" -const keyXML = "xml" -const keyYAML = "yaml" - -func (w lintStructTagRule) checkTagNameIfNeed(tag *structtag.Tag) (string, bool) { - isUnnamedTag := tag.Name == "" || tag.Name == "-" - if isUnnamedTag { - return "", true - } - - needsToCheckTagName := tag.Key == keyBSON || - tag.Key == keyJSON || - tag.Key == keyXML || - tag.Key == keyYAML || - tag.Key == keyProtobuf - - if !needsToCheckTagName { - return "", true - } - - tagName := w.getTagName(tag) - if tagName == "" { - return "", true // No tag name found - } - - // We concat the key and name as the mapping key here - // to allow the same tag name in different tag type. - key := tag.Key + ":" + tagName - if _, ok := w.usedTagName[key]; ok { - return fmt.Sprintf("duplicate tag name: '%s'", tagName), false - } - - w.usedTagName[key] = true - - return "", true -} - -func (lintStructTagRule) getTagName(tag *structtag.Tag) string { - switch tag.Key { - case keyProtobuf: - for _, option := range tag.Options { - if strings.HasPrefix(option, "name=") { - return strings.TrimPrefix(option, "name=") - } - } - return "" // protobuf tag lacks 'name' option - default: - return tag.Name - } -} - -// checkTaggedField checks the tag of the given field. -// precondition: the field has a tag -func (w lintStructTagRule) checkTaggedField(f *ast.Field) { - if len(f.Names) > 0 && !f.Names[0].IsExported() { - w.addFailure(f, "tag on not-exported field "+f.Names[0].Name) - } - - tags, err := structtag.Parse(strings.Trim(f.Tag.Value, "`")) - if err != nil || tags == nil { - w.addFailure(f.Tag, "malformed tag") - return - } - - for _, tag := range tags.Tags() { - if msg, ok := w.checkTagNameIfNeed(tag); !ok { - w.addFailure(f.Tag, msg) - } - - switch key := tag.Key; key { - case keyASN1: - msg, ok := w.checkASN1Tag(f.Type, tag) - if !ok { - w.addFailure(f.Tag, msg) - } - case keyBSON: - msg, ok := w.checkBSONTag(tag.Options) - if !ok { - w.addFailure(f.Tag, msg) - } - case keyDefault: - if !w.typeValueMatch(f.Type, tag.Name) { - w.addFailure(f.Tag, "field's type and default value's type mismatch") - } - case keyJSON: - msg, ok := w.checkJSONTag(tag.Name, tag.Options) - if !ok { - w.addFailure(f.Tag, msg) - } - case keyProtobuf: - msg, ok := w.checkProtobufTag(tag) - if !ok { - w.addFailure(f.Tag, msg) - } - case keyRequired: - if tag.Name != "true" && tag.Name != "false" { - w.addFailure(f.Tag, "required should be 'true' or 'false'") - } - case keyXML: - msg, ok := w.checkXMLTag(tag.Options) - if !ok { - w.addFailure(f.Tag, msg) - } - case keyYAML: - msg, ok := w.checkYAMLTag(tag.Options) - if !ok { - w.addFailure(f.Tag, msg) - } - default: - // unknown key - } - } -} - -func (w lintStructTagRule) checkASN1Tag(t ast.Expr, tag *structtag.Tag) (string, bool) { - checkList := append(tag.Options, tag.Name) - for _, opt := range checkList { - switch opt { - case "application", "explicit", "generalized", "ia5", "omitempty", "optional", "set", "utf8": - - default: - if strings.HasPrefix(opt, "tag:") { - parts := strings.Split(opt, ":") - tagNumber := parts[1] - number, err := strconv.Atoi(tagNumber) - if err != nil { - return fmt.Sprintf("ASN1 tag must be a number, got '%s'", tagNumber), false - } - if w.usedTagNbr[number] { - return fmt.Sprintf("duplicated tag number %v", number), false - } - w.usedTagNbr[number] = true - - continue - } - - if strings.HasPrefix(opt, "default:") { - parts := strings.Split(opt, ":") - if len(parts) < 2 { - return "malformed default for ASN1 tag", false - } - if !w.typeValueMatch(t, parts[1]) { - return "field's type and default value's type mismatch", false - } - - continue - } - - if w.isUserDefined(keyASN1, opt) { - continue - } - - return fmt.Sprintf("unknown option '%s' in ASN1 tag", opt), false - } - } - - return "", true -} - -func (w lintStructTagRule) checkBSONTag(options []string) (string, bool) { - for _, opt := range options { - switch opt { - case "inline", "minsize", "omitempty": - default: - if w.isUserDefined(keyBSON, opt) { - continue - } - return fmt.Sprintf("unknown option '%s' in BSON tag", opt), false - } - } - - return "", true -} - -func (w lintStructTagRule) checkJSONTag(name string, options []string) (string, bool) { - for _, opt := range options { - switch opt { - case "omitempty", "string": - case "": - // special case for JSON key "-" - if name != "-" { - return "option can not be empty in JSON tag", false - } - default: - if w.isUserDefined(keyJSON, opt) { - continue - } - return fmt.Sprintf("unknown option '%s' in JSON tag", opt), false - } - } - - return "", true -} - -func (w lintStructTagRule) checkXMLTag(options []string) (string, bool) { - for _, opt := range options { - switch opt { - case "any", "attr", "cdata", "chardata", "comment", "innerxml", "omitempty", "typeattr": - default: - if w.isUserDefined(keyXML, opt) { - continue - } - return fmt.Sprintf("unknown option '%s' in XML tag", opt), false - } - } - - return "", true -} - -func (w lintStructTagRule) checkYAMLTag(options []string) (string, bool) { - for _, opt := range options { - switch opt { - case "flow", "inline", "omitempty": - default: - if w.isUserDefined(keyYAML, opt) { - continue - } - return fmt.Sprintf("unknown option '%s' in YAML tag", opt), false - } - } - - return "", true -} - -func (lintStructTagRule) typeValueMatch(t ast.Expr, val string) bool { - tID, ok := t.(*ast.Ident) - if !ok { - return true - } - - typeMatches := true - switch tID.Name { - case "bool": - typeMatches = val == "true" || val == "false" - case "float64": - _, err := strconv.ParseFloat(val, 64) - typeMatches = err == nil - case "int": - _, err := strconv.ParseInt(val, 10, 64) - typeMatches = err == nil - case "string": - case "nil": - default: - // unchecked type - } - - return typeMatches -} - -func (w lintStructTagRule) checkProtobufTag(tag *structtag.Tag) (string, bool) { - // check name - switch tag.Name { - case "bytes", "fixed32", "fixed64", "group", "varint", "zigzag32", "zigzag64": - // do nothing - default: - return fmt.Sprintf("invalid protobuf tag name '%s'", tag.Name), false - } - - // check options - seenOptions := map[string]bool{} - for _, opt := range tag.Options { - if number, err := strconv.Atoi(opt); err == nil { - _, alreadySeen := w.usedTagNbr[number] - if alreadySeen { - return fmt.Sprintf("duplicated tag number %v", number), false - } - w.usedTagNbr[number] = true - continue // option is an integer - } - - switch { - case opt == "opt" || opt == "proto3" || opt == "rep" || opt == "req": - // do nothing - case strings.Contains(opt, "="): - o := strings.Split(opt, "=")[0] - _, alreadySeen := seenOptions[o] - if alreadySeen { - return fmt.Sprintf("protobuf tag has duplicated option '%s'", o), false - } - seenOptions[o] = true - continue - } - } - _, hasName := seenOptions["name"] - if !hasName { - return "protobuf tag lacks mandatory option 'name'", false - } - - for k := range seenOptions { - switch k { - case "name", "json": - // do nothing - default: - if w.isUserDefined(keyProtobuf, k) { - continue - } - return fmt.Sprintf("unknown option '%s' in protobuf tag", k), false - } - } - - return "", true -} - -func (w lintStructTagRule) addFailure(n ast.Node, msg string) { - w.onFailure(lint.Failure{ - Node: n, - Failure: msg, - Confidence: 1, - }) -} - -func (w lintStructTagRule) isUserDefined(key, opt string) bool { - if w.userDefined == nil { - return false - } - - options := w.userDefined[key] - for _, o := range options { - if opt == o { - return true - } - } - return false -} diff --git a/vendor/github.com/mgechev/revive/rule/superfluous_else.go b/vendor/github.com/mgechev/revive/rule/superfluous_else.go deleted file mode 100644 index 18e8f3bdd..000000000 --- a/vendor/github.com/mgechev/revive/rule/superfluous_else.go +++ /dev/null @@ -1,47 +0,0 @@ -package rule - -import ( - "fmt" - - "github.com/mgechev/revive/internal/ifelse" - "github.com/mgechev/revive/lint" -) - -// SuperfluousElseRule lints given else constructs. -type SuperfluousElseRule struct{} - -// Apply applies the rule to given file. -func (e *SuperfluousElseRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - return ifelse.Apply(e, file.AST, ifelse.TargetElse, args) -} - -// Name returns the rule name. -func (*SuperfluousElseRule) Name() string { - return "superfluous-else" -} - -// CheckIfElse evaluates the rule against an ifelse.Chain and returns a failure message if applicable. -func (*SuperfluousElseRule) CheckIfElse(chain ifelse.Chain, args ifelse.Args) string { - if !chain.If.Deviates() { - // this rule only applies if the if-block deviates control flow - return "" - } - - if chain.HasPriorNonDeviating { - // if we de-indent the "else" block then a previous branch - // might flow into it, affecting program behaviour - return "" - } - - if chain.If.Returns() { - // avoid overlapping with indent-error-flow - return "" - } - - if args.PreserveScope && !chain.AtBlockEnd && (chain.HasInitializer || chain.Else.HasDecls) { - // avoid increasing variable scope - return "" - } - - return fmt.Sprintf("if block ends with %v, so drop this else and outdent its block", chain.If.LongString()) -} diff --git a/vendor/github.com/mgechev/revive/rule/time_equal.go b/vendor/github.com/mgechev/revive/rule/time_equal.go deleted file mode 100644 index a4fab88b3..000000000 --- a/vendor/github.com/mgechev/revive/rule/time_equal.go +++ /dev/null @@ -1,73 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// TimeEqualRule shows where "==" and "!=" used for equality check time.Time -type TimeEqualRule struct{} - -// Apply applies the rule to given file. -func (*TimeEqualRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := &lintTimeEqual{file, onFailure} - if w.file.Pkg.TypeCheck() != nil { - return nil - } - - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*TimeEqualRule) Name() string { - return "time-equal" -} - -type lintTimeEqual struct { - file *lint.File - onFailure func(lint.Failure) -} - -func (l *lintTimeEqual) Visit(node ast.Node) ast.Visitor { - expr, ok := node.(*ast.BinaryExpr) - if !ok { - return l - } - - switch expr.Op { - case token.EQL, token.NEQ: - default: - return l - } - - typeOfX := l.file.Pkg.TypeOf(expr.X) - typeOfY := l.file.Pkg.TypeOf(expr.Y) - bothAreOfTimeType := isNamedType(typeOfX, "time", "Time") && isNamedType(typeOfY, "time", "Time") - if !bothAreOfTimeType { - return l - } - - negateStr := "" - if token.NEQ == expr.Op { - negateStr = "!" - } - - l.onFailure(lint.Failure{ - Category: "time", - Confidence: 1, - Node: node, - Failure: fmt.Sprintf("use %s%s.Equal(%s) instead of %q operator", negateStr, gofmt(expr.X), gofmt(expr.Y), expr.Op), - }) - - return l -} diff --git a/vendor/github.com/mgechev/revive/rule/time_naming.go b/vendor/github.com/mgechev/revive/rule/time_naming.go deleted file mode 100644 index 5bccf8a7a..000000000 --- a/vendor/github.com/mgechev/revive/rule/time_naming.go +++ /dev/null @@ -1,96 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/types" - "strings" - - "github.com/mgechev/revive/lint" -) - -// TimeNamingRule lints given else constructs. -type TimeNamingRule struct{} - -// Apply applies the rule to given file. -func (*TimeNamingRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := &lintTimeNames{file, onFailure} - - file.Pkg.TypeCheck() - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*TimeNamingRule) Name() string { - return "time-naming" -} - -type lintTimeNames struct { - file *lint.File - onFailure func(lint.Failure) -} - -func (w *lintTimeNames) Visit(node ast.Node) ast.Visitor { - v, ok := node.(*ast.ValueSpec) - if !ok { - return w - } - for _, name := range v.Names { - origTyp := w.file.Pkg.TypeOf(name) - // Look for time.Duration or *time.Duration; - // the latter is common when using flag.Duration. - typ := origTyp - if pt, ok := typ.(*types.Pointer); ok { - typ = pt.Elem() - } - if !isNamedType(typ, "time", "Duration") { - continue - } - suffix := "" - for _, suf := range timeSuffixes { - if strings.HasSuffix(name.Name, suf) { - suffix = suf - break - } - } - if suffix == "" { - continue - } - w.onFailure(lint.Failure{ - Category: "time", - Confidence: 0.9, - Node: v, - Failure: fmt.Sprintf("var %s is of type %v; don't use unit-specific suffix %q", name.Name, origTyp, suffix), - }) - } - return w -} - -// timeSuffixes is a list of name suffixes that imply a time unit. -// This is not an exhaustive list. -var timeSuffixes = []string{ - "Hour", "Hours", - "Min", "Mins", "Minutes", "Minute", - "Sec", "Secs", "Seconds", "Second", - "Msec", "Msecs", - "Milli", "Millis", "Milliseconds", "Millisecond", - "Usec", "Usecs", "Microseconds", "Microsecond", - "MS", "Ms", -} - -func isNamedType(typ types.Type, importPath, name string) bool { - n, ok := typ.(*types.Named) - if !ok { - return false - } - - typeName := n.Obj() - return typeName != nil && typeName.Pkg() != nil && typeName.Pkg().Path() == importPath && typeName.Name() == name -} diff --git a/vendor/github.com/mgechev/revive/rule/unchecked_type_assertion.go b/vendor/github.com/mgechev/revive/rule/unchecked_type_assertion.go deleted file mode 100644 index 34d854e8f..000000000 --- a/vendor/github.com/mgechev/revive/rule/unchecked_type_assertion.go +++ /dev/null @@ -1,189 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "sync" - - "github.com/mgechev/revive/lint" -) - -const ( - ruleUTAMessagePanic = "type assertion will panic if not matched" - ruleUTAMessageIgnored = "type assertion result ignored" -) - -// UncheckedTypeAssertionRule lints missing or ignored `ok`-value in dynamic type casts. -type UncheckedTypeAssertionRule struct { - acceptIgnoredAssertionResult bool - - configureOnce sync.Once -} - -func (r *UncheckedTypeAssertionRule) configure(arguments lint.Arguments) { - if len(arguments) == 0 { - return - } - - args, ok := arguments[0].(map[string]any) - if !ok { - panic("Unable to get arguments. Expected object of key-value-pairs.") - } - - for k, v := range args { - switch k { - case "acceptIgnoredAssertionResult": - r.acceptIgnoredAssertionResult, ok = v.(bool) - if !ok { - panic(fmt.Sprintf("Unable to parse argument '%s'. Expected boolean.", k)) - } - default: - panic(fmt.Sprintf("Unknown argument: %s", k)) - } - } -} - -// Apply applies the rule to given file. -func (r *UncheckedTypeAssertionRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - - var failures []lint.Failure - - walker := &lintUncheckedTypeAssertion{ - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - acceptIgnoredTypeAssertionResult: r.acceptIgnoredAssertionResult, - } - - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*UncheckedTypeAssertionRule) Name() string { - return "unchecked-type-assertion" -} - -type lintUncheckedTypeAssertion struct { - onFailure func(lint.Failure) - acceptIgnoredTypeAssertionResult bool -} - -func isIgnored(e ast.Expr) bool { - ident, ok := e.(*ast.Ident) - if !ok { - return false - } - - return ident.Name == "_" -} - -func isTypeSwitch(e *ast.TypeAssertExpr) bool { - return e.Type == nil -} - -func (w *lintUncheckedTypeAssertion) requireNoTypeAssert(expr ast.Expr) { - e, ok := expr.(*ast.TypeAssertExpr) - if ok && !isTypeSwitch(e) { - w.addFailure(e, ruleUTAMessagePanic) - } -} - -func (w *lintUncheckedTypeAssertion) handleIfStmt(n *ast.IfStmt) { - ifCondition, ok := n.Cond.(*ast.BinaryExpr) - if ok { - w.requireNoTypeAssert(ifCondition.X) - w.requireNoTypeAssert(ifCondition.Y) - } -} - -func (w *lintUncheckedTypeAssertion) requireBinaryExpressionWithoutTypeAssertion(expr ast.Expr) { - binaryExpr, ok := expr.(*ast.BinaryExpr) - if ok { - w.requireNoTypeAssert(binaryExpr.X) - w.requireNoTypeAssert(binaryExpr.Y) - } -} - -func (w *lintUncheckedTypeAssertion) handleCaseClause(n *ast.CaseClause) { - for _, expr := range n.List { - w.requireNoTypeAssert(expr) - w.requireBinaryExpressionWithoutTypeAssertion(expr) - } -} - -func (w *lintUncheckedTypeAssertion) handleSwitch(n *ast.SwitchStmt) { - w.requireNoTypeAssert(n.Tag) - w.requireBinaryExpressionWithoutTypeAssertion(n.Tag) -} - -func (w *lintUncheckedTypeAssertion) handleAssignment(n *ast.AssignStmt) { - if len(n.Rhs) == 0 { - return - } - - e, ok := n.Rhs[0].(*ast.TypeAssertExpr) - if !ok || e == nil { - return - } - - if isTypeSwitch(e) { - return - } - - if len(n.Lhs) == 1 { - w.addFailure(e, ruleUTAMessagePanic) - } - - if !w.acceptIgnoredTypeAssertionResult && len(n.Lhs) == 2 && isIgnored(n.Lhs[1]) { - w.addFailure(e, ruleUTAMessageIgnored) - } -} - -// handles "return foo(.*bar)" - one of them is enough to fail as golang does not forward the type cast tuples in return statements -func (w *lintUncheckedTypeAssertion) handleReturn(n *ast.ReturnStmt) { - for _, r := range n.Results { - w.requireNoTypeAssert(r) - } -} - -func (w *lintUncheckedTypeAssertion) handleRange(n *ast.RangeStmt) { - w.requireNoTypeAssert(n.X) -} - -func (w *lintUncheckedTypeAssertion) handleChannelSend(n *ast.SendStmt) { - w.requireNoTypeAssert(n.Value) -} - -func (w *lintUncheckedTypeAssertion) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.RangeStmt: - w.handleRange(n) - case *ast.SwitchStmt: - w.handleSwitch(n) - case *ast.ReturnStmt: - w.handleReturn(n) - case *ast.AssignStmt: - w.handleAssignment(n) - case *ast.IfStmt: - w.handleIfStmt(n) - case *ast.CaseClause: - w.handleCaseClause(n) - case *ast.SendStmt: - w.handleChannelSend(n) - } - - return w -} - -func (w *lintUncheckedTypeAssertion) addFailure(n *ast.TypeAssertExpr, why string) { - s := fmt.Sprintf("type cast result is unchecked in %v - %s", gofmt(n), why) - w.onFailure(lint.Failure{ - Category: "bad practice", - Confidence: 1, - Node: n, - Failure: s, - }) -} diff --git a/vendor/github.com/mgechev/revive/rule/unconditional_recursion.go b/vendor/github.com/mgechev/revive/rule/unconditional_recursion.go deleted file mode 100644 index d806b6757..000000000 --- a/vendor/github.com/mgechev/revive/rule/unconditional_recursion.go +++ /dev/null @@ -1,200 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// UnconditionalRecursionRule lints given else constructs. -type UnconditionalRecursionRule struct{} - -// Apply applies the rule to given file. -func (*UnconditionalRecursionRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintUnconditionalRecursionRule{onFailure: onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*UnconditionalRecursionRule) Name() string { - return "unconditional-recursion" -} - -type funcDesc struct { - receiverID *ast.Ident - id *ast.Ident -} - -func (fd *funcDesc) equal(other *funcDesc) bool { - receiversAreEqual := (fd.receiverID == nil && other.receiverID == nil) || fd.receiverID != nil && other.receiverID != nil && fd.receiverID.Name == other.receiverID.Name - idsAreEqual := (fd.id == nil && other.id == nil) || fd.id.Name == other.id.Name - - return receiversAreEqual && idsAreEqual -} - -type funcStatus struct { - funcDesc *funcDesc - seenConditionalExit bool -} - -type lintUnconditionalRecursionRule struct { - onFailure func(lint.Failure) - currentFunc *funcStatus - inGoStatement bool -} - -// Visit will traverse the file AST. -// The rule is based in the following algorithm: inside each function body we search for calls to the function itself. -// We do not search inside conditional control structures (if, for, switch, ...) because any recursive call inside them is conditioned -// We do search inside conditional control structures are statements that will take the control out of the function (return, exit, panic) -// If we find conditional control exits, it means the function is NOT unconditionally-recursive -// If we find a recursive call before finding any conditional exit, a failure is generated -// In resume: if we found a recursive call control-dependant from the entry point of the function then we raise a failure. -func (w lintUnconditionalRecursionRule) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.FuncDecl: - var rec *ast.Ident - switch { - case n.Recv == nil: - rec = nil - case n.Recv.NumFields() < 1 || len(n.Recv.List[0].Names) < 1: - rec = &ast.Ident{Name: "_"} - default: - rec = n.Recv.List[0].Names[0] - } - w.currentFunc = &funcStatus{&funcDesc{rec, n.Name}, false} - case *ast.CallExpr: - // check if call arguments has a recursive call - for _, arg := range n.Args { - ast.Walk(w, arg) - } - - var funcID *ast.Ident - var selector *ast.Ident - switch c := n.Fun.(type) { - case *ast.Ident: - selector = nil - funcID = c - case *ast.SelectorExpr: - var ok bool - selector, ok = c.X.(*ast.Ident) - if !ok { // a.b....Foo() - return nil - } - funcID = c.Sel - case *ast.FuncLit: - ast.Walk(w, c.Body) // analyze the body of the function literal - return nil - default: - return w - } - - if w.currentFunc != nil && // not in a func body - !w.currentFunc.seenConditionalExit && // there is a conditional exit in the function - w.currentFunc.funcDesc.equal(&funcDesc{selector, funcID}) { - w.onFailure(lint.Failure{ - Category: "logic", - Confidence: 0.8, - Node: n, - Failure: "unconditional recursive call", - }) - } - return nil - case *ast.IfStmt: - w.updateFuncStatus(n.Body) - w.updateFuncStatus(n.Else) - return nil - case *ast.SelectStmt: - w.updateFuncStatus(n.Body) - return nil - case *ast.RangeStmt: - w.updateFuncStatus(n.Body) - return nil - case *ast.TypeSwitchStmt: - w.updateFuncStatus(n.Body) - return nil - case *ast.SwitchStmt: - w.updateFuncStatus(n.Body) - return nil - case *ast.GoStmt: - w.inGoStatement = true - ast.Walk(w, n.Call) - w.inGoStatement = false - return nil - case *ast.ForStmt: - if n.Cond != nil { - return nil - } - // unconditional loop - return w - case *ast.FuncLit: - if w.inGoStatement { - return w - } - return nil // literal call (closure) is not necessarily an issue - } - - return w -} - -func (w *lintUnconditionalRecursionRule) updateFuncStatus(node ast.Node) { - if node == nil || w.currentFunc == nil || w.currentFunc.seenConditionalExit { - return - } - - w.currentFunc.seenConditionalExit = w.hasControlExit(node) -} - -var exitFunctions = map[string]map[string]bool{ - "os": {"Exit": true}, - "syscall": {"Exit": true}, - "log": { - "Fatal": true, - "Fatalf": true, - "Fatalln": true, - "Panic": true, - "Panicf": true, - "Panicln": true, - }, -} - -func (lintUnconditionalRecursionRule) hasControlExit(node ast.Node) bool { - // isExit returns true if the given node makes control exit the function - isExit := func(node ast.Node) bool { - switch n := node.(type) { - case *ast.ReturnStmt: - return true - case *ast.CallExpr: - if isIdent(n.Fun, "panic") { - return true - } - se, ok := n.Fun.(*ast.SelectorExpr) - if !ok { - return false - } - - id, ok := se.X.(*ast.Ident) - if !ok { - return false - } - - functionName := se.Sel.Name - pkgName := id.Name - isCallToExitFunction := exitFunctions[pkgName] != nil && exitFunctions[pkgName][functionName] - if isCallToExitFunction { - return true - } - } - - return false - } - - return len(pick(node, isExit)) != 0 -} diff --git a/vendor/github.com/mgechev/revive/rule/unexported_naming.go b/vendor/github.com/mgechev/revive/rule/unexported_naming.go deleted file mode 100644 index 0c2b39d41..000000000 --- a/vendor/github.com/mgechev/revive/rule/unexported_naming.go +++ /dev/null @@ -1,115 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// UnexportedNamingRule lints wrongly named unexported symbols. -type UnexportedNamingRule struct{} - -// Apply applies the rule to given file. -func (*UnexportedNamingRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - ba := &unexportablenamingLinter{onFailure} - ast.Walk(ba, file.AST) - - return failures -} - -// Name returns the rule name. -func (*UnexportedNamingRule) Name() string { - return "unexported-naming" -} - -type unexportablenamingLinter struct { - onFailure func(lint.Failure) -} - -func (unl unexportablenamingLinter) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.FuncDecl: - unl.lintFunction(n.Type, n.Body) - return nil - case *ast.FuncLit: - unl.lintFunction(n.Type, n.Body) - - return nil - case *ast.AssignStmt: - if n.Tok != token.DEFINE { - return nil - } - - ids := []*ast.Ident{} - for _, e := range n.Lhs { - id, ok := e.(*ast.Ident) - if !ok { - continue - } - ids = append(ids, id) - } - - unl.lintIDs(ids) - - case *ast.DeclStmt: - gd, ok := n.Decl.(*ast.GenDecl) - if !ok { - return nil - } - - if len(gd.Specs) < 1 { - return nil - } - - vs, ok := gd.Specs[0].(*ast.ValueSpec) - if !ok { - return nil - } - - unl.lintIDs(vs.Names) - } - - return unl -} - -func (unl unexportablenamingLinter) lintFunction(ft *ast.FuncType, body *ast.BlockStmt) { - unl.lintFields(ft.Params) - unl.lintFields(ft.Results) - - if body != nil { - ast.Walk(unl, body) - } -} - -func (unl unexportablenamingLinter) lintFields(fields *ast.FieldList) { - if fields == nil { - return - } - - ids := []*ast.Ident{} - for _, field := range fields.List { - ids = append(ids, field.Names...) - } - - unl.lintIDs(ids) -} - -func (unl unexportablenamingLinter) lintIDs(ids []*ast.Ident) { - for _, id := range ids { - if id.IsExported() { - unl.onFailure(lint.Failure{ - Node: id, - Confidence: 1, - Category: "naming", - Failure: fmt.Sprintf("the symbol %s is local, its name should start with a lowercase letter", id.String()), - }) - } - } -} diff --git a/vendor/github.com/mgechev/revive/rule/unexported_return.go b/vendor/github.com/mgechev/revive/rule/unexported_return.go deleted file mode 100644 index 10f8e3fbe..000000000 --- a/vendor/github.com/mgechev/revive/rule/unexported_return.go +++ /dev/null @@ -1,107 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/types" - - "github.com/mgechev/revive/internal/typeparams" - "github.com/mgechev/revive/lint" -) - -// UnexportedReturnRule lints given else constructs. -type UnexportedReturnRule struct{} - -// Apply applies the rule to given file. -func (*UnexportedReturnRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := lintUnexportedReturn{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - file.Pkg.TypeCheck() - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*UnexportedReturnRule) Name() string { - return "unexported-return" -} - -type lintUnexportedReturn struct { - file *lint.File - fileAst *ast.File - onFailure func(lint.Failure) -} - -func (w lintUnexportedReturn) Visit(n ast.Node) ast.Visitor { - fn, ok := n.(*ast.FuncDecl) - if !ok { - return w - } - if fn.Type.Results == nil { - return nil - } - if !fn.Name.IsExported() { - return nil - } - thing := "func" - if fn.Recv != nil && len(fn.Recv.List) > 0 { - thing = "method" - if !ast.IsExported(typeparams.ReceiverType(fn)) { - // Don't report exported methods of unexported types, - // such as private implementations of sort.Interface. - return nil - } - } - for _, ret := range fn.Type.Results.List { - typ := w.file.Pkg.TypeOf(ret.Type) - if exportedType(typ) { - continue - } - w.onFailure(lint.Failure{ - Category: "unexported-type-in-api", - Node: ret.Type, - Confidence: 0.8, - Failure: fmt.Sprintf("exported %s %s returns unexported type %s, which can be annoying to use", - thing, fn.Name.Name, typ), - }) - break // only flag one - } - return nil -} - -// exportedType reports whether typ is an exported type. -// It is imprecise, and will err on the side of returning true, -// such as for composite types. -func exportedType(typ types.Type) bool { - switch t := typ.(type) { - case *types.Named: - obj := t.Obj() - switch { - // Builtin types have no package. - case obj.Pkg() == nil: - case obj.Exported(): - default: - _, ok := t.Underlying().(*types.Interface) - return ok - } - return true - case *types.Map: - return exportedType(t.Key()) && exportedType(t.Elem()) - case interface { - Elem() types.Type - }: // array, slice, pointer, chan - return exportedType(t.Elem()) - } - // Be conservative about other types, such as struct, interface, etc. - return true -} diff --git a/vendor/github.com/mgechev/revive/rule/unhandled_error.go b/vendor/github.com/mgechev/revive/rule/unhandled_error.go deleted file mode 100644 index 4fad8ccfc..000000000 --- a/vendor/github.com/mgechev/revive/rule/unhandled_error.go +++ /dev/null @@ -1,175 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/types" - "regexp" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -// UnhandledErrorRule lints given else constructs. -type UnhandledErrorRule struct { - ignoreList []*regexp.Regexp - - configureOnce sync.Once -} - -func (r *UnhandledErrorRule) configure(arguments lint.Arguments) { - for _, arg := range arguments { - argStr, ok := arg.(string) - if !ok { - panic(fmt.Sprintf("Invalid argument to the unhandled-error rule. Expecting a string, got %T", arg)) - } - - argStr = strings.Trim(argStr, " ") - if argStr == "" { - panic("Invalid argument to the unhandled-error rule, expected regular expression must not be empty.") - } - - exp, err := regexp.Compile(argStr) - if err != nil { - panic(fmt.Sprintf("Invalid argument to the unhandled-error rule: regexp %q does not compile: %v", argStr, err)) - } - - r.ignoreList = append(r.ignoreList, exp) - } -} - -// Apply applies the rule to given file. -func (r *UnhandledErrorRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - - var failures []lint.Failure - - walker := &lintUnhandledErrors{ - ignoreList: r.ignoreList, - pkg: file.Pkg, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - file.Pkg.TypeCheck() - ast.Walk(walker, file.AST) - - return failures -} - -// Name returns the rule name. -func (*UnhandledErrorRule) Name() string { - return "unhandled-error" -} - -type lintUnhandledErrors struct { - ignoreList []*regexp.Regexp - pkg *lint.Package - onFailure func(lint.Failure) -} - -// Visit looks for statements that are function calls. -// If the called function returns a value of type error a failure will be created. -func (w *lintUnhandledErrors) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.ExprStmt: - fCall, ok := n.X.(*ast.CallExpr) - if !ok { - return nil // not a function call - } - - funcType := w.pkg.TypeOf(fCall) - if funcType == nil { - return nil // skip, type info not available - } - - switch t := funcType.(type) { - case *types.Named: - if !w.isTypeError(t) { - return nil // func call does not return an error - } - - w.addFailure(fCall) - default: - retTypes, ok := funcType.Underlying().(*types.Tuple) - if !ok { - return nil // skip, unable to retrieve return type of the called function - } - - if w.returnsAnError(retTypes) { - w.addFailure(fCall) - } - } - } - return w -} - -func (w *lintUnhandledErrors) addFailure(n *ast.CallExpr) { - name := w.funcName(n) - if w.isIgnoredFunc(name) { - return - } - - w.onFailure(lint.Failure{ - Category: "bad practice", - Confidence: 1, - Node: n, - Failure: fmt.Sprintf("Unhandled error in call to function %v", name), - }) -} - -func (w *lintUnhandledErrors) funcName(call *ast.CallExpr) string { - fn, ok := w.getFunc(call) - if !ok { - return gofmt(call.Fun) - } - - name := fn.FullName() - name = strings.ReplaceAll(name, "(", "") - name = strings.ReplaceAll(name, ")", "") - name = strings.ReplaceAll(name, "*", "") - - return name -} - -func (w *lintUnhandledErrors) isIgnoredFunc(funcName string) bool { - for _, pattern := range w.ignoreList { - if len(pattern.FindString(funcName)) == len(funcName) { - return true - } - } - - return false -} - -func (*lintUnhandledErrors) isTypeError(t *types.Named) bool { - const errorTypeName = "_.error" - - return t.Obj().Id() == errorTypeName -} - -func (w *lintUnhandledErrors) returnsAnError(tt *types.Tuple) bool { - for i := 0; i < tt.Len(); i++ { - nt, ok := tt.At(i).Type().(*types.Named) - if ok && w.isTypeError(nt) { - return true - } - } - return false -} - -func (w *lintUnhandledErrors) getFunc(call *ast.CallExpr) (*types.Func, bool) { - sel, ok := call.Fun.(*ast.SelectorExpr) - if !ok { - return nil, false - } - - fn, ok := w.pkg.TypesInfo().ObjectOf(sel.Sel).(*types.Func) - if !ok { - return nil, false - } - - return fn, true -} diff --git a/vendor/github.com/mgechev/revive/rule/unnecessary_stmt.go b/vendor/github.com/mgechev/revive/rule/unnecessary_stmt.go deleted file mode 100644 index 8e0784ba4..000000000 --- a/vendor/github.com/mgechev/revive/rule/unnecessary_stmt.go +++ /dev/null @@ -1,107 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// UnnecessaryStmtRule warns on unnecessary statements. -type UnnecessaryStmtRule struct{} - -// Apply applies the rule to given file. -func (*UnnecessaryStmtRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintUnnecessaryStmtRule{onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*UnnecessaryStmtRule) Name() string { - return "unnecessary-stmt" -} - -type lintUnnecessaryStmtRule struct { - onFailure func(lint.Failure) -} - -func (w lintUnnecessaryStmtRule) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.FuncDecl: - if n.Body == nil || n.Type.Results != nil { - return w - } - stmts := n.Body.List - if len(stmts) == 0 { - return w - } - - lastStmt := stmts[len(stmts)-1] - rs, ok := lastStmt.(*ast.ReturnStmt) - if !ok { - return w - } - - if len(rs.Results) == 0 { - w.newFailure(lastStmt, "omit unnecessary return statement") - } - - case *ast.SwitchStmt: - w.checkSwitchBody(n.Body) - case *ast.TypeSwitchStmt: - w.checkSwitchBody(n.Body) - case *ast.CaseClause: - if n.Body == nil { - return w - } - stmts := n.Body - if len(stmts) == 0 { - return w - } - - lastStmt := stmts[len(stmts)-1] - rs, ok := lastStmt.(*ast.BranchStmt) - if !ok { - return w - } - - if rs.Tok == token.BREAK && rs.Label == nil { - w.newFailure(lastStmt, "omit unnecessary break at the end of case clause") - } - } - - return w -} - -func (w lintUnnecessaryStmtRule) checkSwitchBody(b *ast.BlockStmt) { - cases := b.List - if len(cases) != 1 { - return - } - - cc, ok := cases[0].(*ast.CaseClause) - if !ok { - return - } - - if len(cc.List) > 1 { // skip cases with multiple expressions - return - } - - w.newFailure(b, "switch with only one case can be replaced by an if-then") -} - -func (w lintUnnecessaryStmtRule) newFailure(node ast.Node, msg string) { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: node, - Category: "style", - Failure: msg, - }) -} diff --git a/vendor/github.com/mgechev/revive/rule/unreachable_code.go b/vendor/github.com/mgechev/revive/rule/unreachable_code.go deleted file mode 100644 index dcc5b7905..000000000 --- a/vendor/github.com/mgechev/revive/rule/unreachable_code.go +++ /dev/null @@ -1,122 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// UnreachableCodeRule lints unreachable code. -type UnreachableCodeRule struct{} - -// Apply applies the rule to given file. -func (*UnreachableCodeRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - testingFunctions := map[string]bool{ - "Fatal": true, - "Fatalf": true, - "FailNow": true, - } - branchingFunctions := map[string]map[string]bool{ - "os": {"Exit": true}, - "log": { - "Fatal": true, - "Fatalf": true, - "Fatalln": true, - "Panic": true, - "Panicf": true, - "Panicln": true, - }, - "t": testingFunctions, - "b": testingFunctions, - "f": testingFunctions, - } - - w := lintUnreachableCode{onFailure, branchingFunctions} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*UnreachableCodeRule) Name() string { - return "unreachable-code" -} - -type lintUnreachableCode struct { - onFailure func(lint.Failure) - branchingFunctions map[string]map[string]bool -} - -func (w lintUnreachableCode) Visit(node ast.Node) ast.Visitor { - blk, ok := node.(*ast.BlockStmt) - if !ok { - return w - } - - if len(blk.List) < 2 { - return w - } -loop: - for i, stmt := range blk.List[:len(blk.List)-1] { - // println("iterating ", len(blk.List)) - next := blk.List[i+1] - if _, ok := next.(*ast.LabeledStmt); ok { - continue // skip if next statement is labeled - } - - switch s := stmt.(type) { - case *ast.ReturnStmt: - w.onFailure(newUnreachableCodeFailure(s)) - break loop - case *ast.BranchStmt: - token := s.Tok.String() - if token != "fallthrough" { - w.onFailure(newUnreachableCodeFailure(s)) - break loop - } - case *ast.ExprStmt: - ce, ok := s.X.(*ast.CallExpr) - if !ok { - continue - } - // it's a function call - fc, ok := ce.Fun.(*ast.SelectorExpr) - if !ok { - continue - } - - id, ok := fc.X.(*ast.Ident) - - if !ok { - continue - } - fn := fc.Sel.Name - pkg := id.Name - if !w.branchingFunctions[pkg][fn] { // it isn't a call to a branching function - continue - } - - if _, ok := next.(*ast.ReturnStmt); ok { // return statement needed to satisfy function signature - continue - } - - w.onFailure(newUnreachableCodeFailure(s)) - break loop - } - } - - return w -} - -func newUnreachableCodeFailure(node ast.Node) lint.Failure { - return lint.Failure{ - Confidence: 1, - Node: node, - Category: "logic", - Failure: "unreachable code after this statement", - } -} diff --git a/vendor/github.com/mgechev/revive/rule/unused_param.go b/vendor/github.com/mgechev/revive/rule/unused_param.go deleted file mode 100644 index a8514ac2d..000000000 --- a/vendor/github.com/mgechev/revive/rule/unused_param.go +++ /dev/null @@ -1,159 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "regexp" - "sync" - - "github.com/mgechev/revive/lint" -) - -// UnusedParamRule lints unused params in functions. -type UnusedParamRule struct { - // regex to check if some name is valid for unused parameter, "^_$" by default - allowRegex *regexp.Regexp - failureMsg string - - configureOnce sync.Once -} - -func (r *UnusedParamRule) configure(args lint.Arguments) { - // while by default args is an array, i think it's good to provide structures inside it by default, not arrays or primitives - // it's more compatible to JSON nature of configurations - var allowedRegexStr string - if len(args) == 0 { - allowedRegexStr = "^_$" - r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it as _" - } else { - // Arguments = [{}] - options := args[0].(map[string]any) - // Arguments = [{allowedRegex="^_"}] - - if allowedRegexParam, ok := options["allowRegex"]; ok { - allowedRegexStr, ok = allowedRegexParam.(string) - if !ok { - panic(fmt.Errorf("error configuring %s rule: allowedRegex is not string but [%T]", r.Name(), allowedRegexParam)) - } - } - } - var err error - r.allowRegex, err = regexp.Compile(allowedRegexStr) - if err != nil { - panic(fmt.Errorf("error configuring %s rule: allowedRegex is not valid regex [%s]: %v", r.Name(), allowedRegexStr, err)) - } - - if r.failureMsg == "" { - r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it to match " + r.allowRegex.String() - } -} - -// Apply applies the rule to given file. -func (r *UnusedParamRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - w := lintUnusedParamRule{ - onFailure: onFailure, - allowRegex: r.allowRegex, - failureMsg: r.failureMsg, - } - - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*UnusedParamRule) Name() string { - return "unused-parameter" -} - -type lintUnusedParamRule struct { - onFailure func(lint.Failure) - allowRegex *regexp.Regexp - failureMsg string -} - -func (w lintUnusedParamRule) Visit(node ast.Node) ast.Visitor { - var ( - funcType *ast.FuncType - funcBody *ast.BlockStmt - ) - switch n := node.(type) { - case *ast.FuncLit: - funcType = n.Type - funcBody = n.Body - case *ast.FuncDecl: - if n.Body == nil { - return nil // skip, is a function prototype - } - - funcType = n.Type - funcBody = n.Body - default: - return w // skip, not a function - } - - params := retrieveNamedParams(funcType.Params) - if len(params) < 1 { - return w // skip, func without parameters - } - - // inspect the func body looking for references to parameters - fselect := func(n ast.Node) bool { - ident, isAnID := n.(*ast.Ident) - - if !isAnID { - return false - } - - _, isAParam := params[ident.Obj] - if isAParam { - params[ident.Obj] = false // mark as used - } - - return false - } - _ = pick(funcBody, fselect) - - for _, p := range funcType.Params.List { - for _, n := range p.Names { - if w.allowRegex.FindStringIndex(n.Name) != nil { - continue - } - if params[n.Obj] { - w.onFailure(lint.Failure{ - Confidence: 1, - Node: n, - Category: "bad practice", - Failure: fmt.Sprintf(w.failureMsg, n.Name), - }) - } - } - } - - return w // full method body was inspected -} - -func retrieveNamedParams(params *ast.FieldList) map[*ast.Object]bool { - result := map[*ast.Object]bool{} - if params.List == nil { - return result - } - - for _, p := range params.List { - for _, n := range p.Names { - if n.Name == "_" { - continue - } - - result[n.Obj] = true - } - } - - return result -} diff --git a/vendor/github.com/mgechev/revive/rule/unused_receiver.go b/vendor/github.com/mgechev/revive/rule/unused_receiver.go deleted file mode 100644 index 131aae5fb..000000000 --- a/vendor/github.com/mgechev/revive/rule/unused_receiver.go +++ /dev/null @@ -1,125 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "regexp" - "sync" - - "github.com/mgechev/revive/lint" -) - -// UnusedReceiverRule lints unused params in functions. -type UnusedReceiverRule struct { - // regex to check if some name is valid for unused parameter, "^_$" by default - allowRegex *regexp.Regexp - failureMsg string - - configureOnce sync.Once -} - -func (r *UnusedReceiverRule) configure(args lint.Arguments) { - // while by default args is an array, i think it's good to provide structures inside it by default, not arrays or primitives - // it's more compatible to JSON nature of configurations - var allowedRegexStr string - if len(args) == 0 { - allowedRegexStr = "^_$" - r.failureMsg = "method receiver '%s' is not referenced in method's body, consider removing or renaming it as _" - } else { - // Arguments = [{}] - options := args[0].(map[string]any) - // Arguments = [{allowedRegex="^_"}] - - if allowedRegexParam, ok := options["allowRegex"]; ok { - allowedRegexStr, ok = allowedRegexParam.(string) - if !ok { - panic(fmt.Errorf("error configuring [unused-receiver] rule: allowedRegex is not string but [%T]", allowedRegexParam)) - } - } - } - var err error - r.allowRegex, err = regexp.Compile(allowedRegexStr) - if err != nil { - panic(fmt.Errorf("error configuring [unused-receiver] rule: allowedRegex is not valid regex [%s]: %v", allowedRegexStr, err)) - } - if r.failureMsg == "" { - r.failureMsg = "method receiver '%s' is not referenced in method's body, consider removing or renaming it to match " + r.allowRegex.String() - } -} - -// Apply applies the rule to given file. -func (r *UnusedReceiverRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(args) }) - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintUnusedReceiverRule{ - onFailure: onFailure, - allowRegex: r.allowRegex, - failureMsg: r.failureMsg, - } - - ast.Walk(w, file.AST) - - return failures -} - -// Name returns the rule name. -func (*UnusedReceiverRule) Name() string { - return "unused-receiver" -} - -type lintUnusedReceiverRule struct { - onFailure func(lint.Failure) - allowRegex *regexp.Regexp - failureMsg string -} - -func (w lintUnusedReceiverRule) Visit(node ast.Node) ast.Visitor { - switch n := node.(type) { - case *ast.FuncDecl: - if n.Recv == nil { - return nil // skip this func decl, not a method - } - - rec := n.Recv.List[0] // safe to access only the first (unique) element of the list - if len(rec.Names) < 1 { - return nil // the receiver is anonymous: func (aType) Foo(...) ... - } - - recID := rec.Names[0] - if recID.Name == "_" { - return nil // the receiver is already named _ - } - - if w.allowRegex != nil && w.allowRegex.FindStringIndex(recID.Name) != nil { - return nil - } - - // inspect the func body looking for references to the receiver id - fselect := func(n ast.Node) bool { - ident, isAnID := n.(*ast.Ident) - - return isAnID && ident.Obj == recID.Obj - } - refs2recID := pick(n.Body, fselect) - - if len(refs2recID) > 0 { - return nil // the receiver is referenced in the func body - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: recID, - Category: "bad practice", - Failure: fmt.Sprintf(w.failureMsg, recID.Name), - }) - - return nil // full method body already inspected - } - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/use_any.go b/vendor/github.com/mgechev/revive/rule/use_any.go deleted file mode 100644 index 88160c2fa..000000000 --- a/vendor/github.com/mgechev/revive/rule/use_any.go +++ /dev/null @@ -1,54 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// UseAnyRule lints given else constructs. -type UseAnyRule struct{} - -// Apply applies the rule to given file. -func (*UseAnyRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - walker := lintUseAny{ - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - fileAst := file.AST - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*UseAnyRule) Name() string { - return "use-any" -} - -type lintUseAny struct { - onFailure func(lint.Failure) -} - -func (w lintUseAny) Visit(n ast.Node) ast.Visitor { - it, ok := n.(*ast.InterfaceType) - if !ok { - return w - } - - if len(it.Methods.List) != 0 { - return w // it is not and empty interface - } - - w.onFailure(lint.Failure{ - Node: n, - Confidence: 1, - Category: "naming", - Failure: "since Go 1.18 'interface{}' can be replaced by 'any'", - }) - - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/useless_break.go b/vendor/github.com/mgechev/revive/rule/useless_break.go deleted file mode 100644 index 8db20c9b8..000000000 --- a/vendor/github.com/mgechev/revive/rule/useless_break.go +++ /dev/null @@ -1,82 +0,0 @@ -package rule - -import ( - "go/ast" - "go/token" - - "github.com/mgechev/revive/lint" -) - -// UselessBreak lint rule. -type UselessBreak struct{} - -// Apply applies the rule to given file. -func (*UselessBreak) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - astFile := file.AST - w := &lintUselessBreak{onFailure, false} - ast.Walk(w, astFile) - return failures -} - -// Name returns the rule name. -func (*UselessBreak) Name() string { - return "useless-break" -} - -type lintUselessBreak struct { - onFailure func(lint.Failure) - inLoopBody bool -} - -func (w *lintUselessBreak) Visit(node ast.Node) ast.Visitor { - switch v := node.(type) { - case *ast.ForStmt: - w.inLoopBody = true - ast.Walk(w, v.Body) - w.inLoopBody = false - return nil - case *ast.RangeStmt: - w.inLoopBody = true - ast.Walk(w, v.Body) - w.inLoopBody = false - return nil - case *ast.CommClause: - for _, n := range v.Body { - w.inspectCaseStatement(n) - } - return nil - case *ast.CaseClause: - for _, n := range v.Body { - w.inspectCaseStatement(n) - } - return nil - } - return w -} - -func (w *lintUselessBreak) inspectCaseStatement(n ast.Stmt) { - switch s := n.(type) { - case *ast.BranchStmt: - if s.Tok != token.BREAK { - return // not a break statement - } - if s.Label != nil { - return // labeled break statement, usually affects a nesting loop - } - msg := "useless break in case clause" - if w.inLoopBody { - msg += " (WARN: this break statement affects this switch or select statement and not the loop enclosing it)" - } - w.onFailure(lint.Failure{ - Confidence: 1, - Node: s, - Failure: msg, - }) - } -} diff --git a/vendor/github.com/mgechev/revive/rule/utils.go b/vendor/github.com/mgechev/revive/rule/utils.go deleted file mode 100644 index 1267c2d39..000000000 --- a/vendor/github.com/mgechev/revive/rule/utils.go +++ /dev/null @@ -1,173 +0,0 @@ -package rule - -import ( - "bytes" - "fmt" - "go/ast" - "go/printer" - "go/token" - "go/types" - "regexp" - "strings" - - "github.com/mgechev/revive/lint" -) - -// isBlank returns whether id is the blank identifier "_". -// If id == nil, the answer is false. -func isBlank(id *ast.Ident) bool { return id != nil && id.Name == "_" } - -var commonMethods = map[string]bool{ - "Error": true, - "Read": true, - "ServeHTTP": true, - "String": true, - "Write": true, - "Unwrap": true, -} - -var knownNameExceptions = map[string]bool{ - "LastInsertId": true, // must match database/sql - "kWh": true, -} - -func isCgoExported(f *ast.FuncDecl) bool { - if f.Recv != nil || f.Doc == nil { - return false - } - - cgoExport := regexp.MustCompile(fmt.Sprintf("(?m)^//export %s$", regexp.QuoteMeta(f.Name.Name))) - for _, c := range f.Doc.List { - if cgoExport.MatchString(c.Text) { - return true - } - } - return false -} - -var allCapsRE = regexp.MustCompile(`^[A-Z0-9_]+$`) - -func isIdent(expr ast.Expr, ident string) bool { - id, ok := expr.(*ast.Ident) - return ok && id.Name == ident -} - -var zeroLiteral = map[string]bool{ - "false": true, // bool - // runes - `'\x00'`: true, - `'\000'`: true, - // strings - `""`: true, - "``": true, - // numerics - "0": true, - "0.": true, - "0.0": true, - "0i": true, -} - -func validType(t types.Type) bool { - return t != nil && - t != types.Typ[types.Invalid] && - !strings.Contains(t.String(), "invalid type") // good but not foolproof -} - -// isPkgDot checks if the expression is . -func isPkgDot(expr ast.Expr, pkg, name string) bool { - sel, ok := expr.(*ast.SelectorExpr) - return ok && isIdent(sel.X, pkg) && isIdent(sel.Sel, name) -} - -func srcLine(src []byte, p token.Position) string { - // Run to end of line in both directions if not at line start/end. - lo, hi := p.Offset, p.Offset+1 - for lo > 0 && src[lo-1] != '\n' { - lo-- - } - for hi < len(src) && src[hi-1] != '\n' { - hi++ - } - return string(src[lo:hi]) -} - -// pick yields a list of nodes by picking them from a sub-ast with root node n. -// Nodes are selected by applying the fselect function -func pick(n ast.Node, fselect func(n ast.Node) bool) []ast.Node { - var result []ast.Node - - if n == nil { - return result - } - - onSelect := func(n ast.Node) { - result = append(result, n) - } - p := picker{fselect: fselect, onSelect: onSelect} - ast.Walk(p, n) - return result -} - -type picker struct { - fselect func(n ast.Node) bool - onSelect func(n ast.Node) -} - -func (p picker) Visit(node ast.Node) ast.Visitor { - if p.fselect == nil { - return nil - } - - if p.fselect(node) { - p.onSelect(node) - } - - return p -} - -// isBoolOp returns true if the given token corresponds to -// a bool operator -func isBoolOp(t token.Token) bool { - switch t { - case token.LAND, token.LOR, token.EQL, token.NEQ: - return true - } - - return false -} - -const ( - trueName = "true" - falseName = "false" -) - -func isExprABooleanLit(n ast.Node) (lexeme string, ok bool) { - oper, ok := n.(*ast.Ident) - - if !ok { - return "", false - } - - return oper.Name, (oper.Name == trueName || oper.Name == falseName) -} - -// gofmt returns a string representation of an AST subtree. -func gofmt(x any) string { - buf := bytes.Buffer{} - fs := token.NewFileSet() - printer.Fprint(&buf, fs, x) - return buf.String() -} - -// checkNumberOfArguments fails if the given number of arguments is not, at least, the expected one -func checkNumberOfArguments(expected int, args lint.Arguments, ruleName string) { - if len(args) < expected { - panic(fmt.Sprintf("not enough arguments for %s rule, expected %d, got %d. Please check the rule's documentation", ruleName, expected, len(args))) - } -} - -var directiveCommentRE = regexp.MustCompile("^//(line |extern |export |[a-z0-9]+:[a-z0-9])") // see https://go-review.googlesource.com/c/website/+/442516/1..2/_content/doc/comment.md#494 - -func isDirectiveComment(line string) bool { - return directiveCommentRE.MatchString(line) -} diff --git a/vendor/github.com/mgechev/revive/rule/var_declarations.go b/vendor/github.com/mgechev/revive/rule/var_declarations.go deleted file mode 100644 index 3f9d7068a..000000000 --- a/vendor/github.com/mgechev/revive/rule/var_declarations.go +++ /dev/null @@ -1,122 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "go/types" - - "github.com/mgechev/revive/lint" -) - -// VarDeclarationsRule lints given else constructs. -type VarDeclarationsRule struct{} - -// Apply applies the rule to given file. -func (*VarDeclarationsRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - fileAst := file.AST - walker := &lintVarDeclarations{ - file: file, - fileAst: fileAst, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - } - - file.Pkg.TypeCheck() - ast.Walk(walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*VarDeclarationsRule) Name() string { - return "var-declaration" -} - -type lintVarDeclarations struct { - fileAst *ast.File - file *lint.File - lastGen *ast.GenDecl - onFailure func(lint.Failure) -} - -func (w *lintVarDeclarations) Visit(node ast.Node) ast.Visitor { - switch v := node.(type) { - case *ast.GenDecl: - isVarOrConstDeclaration := v.Tok == token.CONST || v.Tok == token.VAR - if !isVarOrConstDeclaration { - return nil - } - w.lastGen = v - return w - case *ast.ValueSpec: - isConstDeclaration := w.lastGen.Tok == token.CONST - if isConstDeclaration { - return nil - } - if len(v.Names) > 1 || v.Type == nil || len(v.Values) == 0 { - return nil - } - rhs := v.Values[0] - // An underscore var appears in a common idiom for compile-time interface satisfaction, - // as in "var _ Interface = (*Concrete)(nil)". - if isIdent(v.Names[0], "_") { - return nil - } - // If the RHS is a isZero value, suggest dropping it. - isZero := false - if lit, ok := rhs.(*ast.BasicLit); ok { - isZero = zeroLiteral[lit.Value] - } else if isIdent(rhs, "nil") { - isZero = true - } - if isZero { - w.onFailure(lint.Failure{ - Confidence: 0.9, - Node: rhs, - Category: "zero-value", - Failure: fmt.Sprintf("should drop = %s from declaration of var %s; it is the zero value", w.file.Render(rhs), v.Names[0]), - }) - return nil - } - lhsTyp := w.file.Pkg.TypeOf(v.Type) - rhsTyp := w.file.Pkg.TypeOf(rhs) - - if !validType(lhsTyp) || !validType(rhsTyp) { - // Type checking failed (often due to missing imports). - return nil - } - - if !types.Identical(lhsTyp, rhsTyp) { - // Assignment to a different type is not redundant. - return nil - } - - // The next three conditions are for suppressing the warning in situations - // where we were unable to typecheck. - - // If the LHS type is an interface, don't warn, since it is probably a - // concrete type on the RHS. Note that our feeble lexical check here - // will only pick up interface{} and other literal interface types; - // that covers most of the cases we care to exclude right now. - if _, ok := v.Type.(*ast.InterfaceType); ok { - return nil - } - // If the RHS is an untyped const, only warn if the LHS type is its default type. - if defType, ok := w.file.IsUntypedConst(rhs); ok && !isIdent(v.Type, defType) { - return nil - } - - w.onFailure(lint.Failure{ - Category: "type-inference", - Confidence: 0.8, - Node: v.Type, - Failure: fmt.Sprintf("should omit type %s from declaration of var %s; it will be inferred from the right-hand side", w.file.Render(v.Type), v.Names[0]), - }) - return nil - } - return w -} diff --git a/vendor/github.com/mgechev/revive/rule/var_naming.go b/vendor/github.com/mgechev/revive/rule/var_naming.go deleted file mode 100644 index 2c2198dbd..000000000 --- a/vendor/github.com/mgechev/revive/rule/var_naming.go +++ /dev/null @@ -1,273 +0,0 @@ -package rule - -import ( - "fmt" - "go/ast" - "go/token" - "regexp" - "strings" - "sync" - - "github.com/mgechev/revive/lint" -) - -var anyCapsRE = regexp.MustCompile(`[A-Z]`) - -// regexp for constant names like `SOME_CONST`, `SOME_CONST_2`, `X123_3`, `_SOME_PRIVATE_CONST` (#851, #865) -var upperCaseConstRE = regexp.MustCompile(`^_?[A-Z][A-Z\d]*(_[A-Z\d]+)*$`) - -// VarNamingRule lints given else constructs. -type VarNamingRule struct { - allowList []string - blockList []string - allowUpperCaseConst bool // if true - allows to use UPPER_SOME_NAMES for constants - skipPackageNameChecks bool - - configureOnce sync.Once -} - -func (r *VarNamingRule) configure(arguments lint.Arguments) { - if len(arguments) >= 1 { - r.allowList = getList(arguments[0], "allowlist") - } - - if len(arguments) >= 2 { - r.blockList = getList(arguments[1], "blocklist") - } - - if len(arguments) >= 3 { - // not pretty code because should keep compatibility with TOML (no mixed array types) and new map parameters - thirdArgument := arguments[2] - asSlice, ok := thirdArgument.([]any) - if !ok { - panic(fmt.Sprintf("Invalid third argument to the var-naming rule. Expecting a %s of type slice, got %T", "options", arguments[2])) - } - if len(asSlice) != 1 { - panic(fmt.Sprintf("Invalid third argument to the var-naming rule. Expecting a %s of type slice, of len==1, but %d", "options", len(asSlice))) - } - args, ok := asSlice[0].(map[string]any) - if !ok { - panic(fmt.Sprintf("Invalid third argument to the var-naming rule. Expecting a %s of type slice, of len==1, with map, but %T", "options", asSlice[0])) - } - r.allowUpperCaseConst = fmt.Sprint(args["upperCaseConst"]) == "true" - r.skipPackageNameChecks = fmt.Sprint(args["skipPackageNameChecks"]) == "true" - } -} - -func (r *VarNamingRule) applyPackageCheckRules(walker *lintNames) { - // Package names need slightly different handling than other names. - if strings.Contains(walker.fileAst.Name.Name, "_") && !strings.HasSuffix(walker.fileAst.Name.Name, "_test") { - walker.onFailure(lint.Failure{ - Failure: "don't use an underscore in package name", - Confidence: 1, - Node: walker.fileAst.Name, - Category: "naming", - }) - } - if anyCapsRE.MatchString(walker.fileAst.Name.Name) { - walker.onFailure(lint.Failure{ - Failure: fmt.Sprintf("don't use MixedCaps in package name; %s should be %s", walker.fileAst.Name.Name, strings.ToLower(walker.fileAst.Name.Name)), - Confidence: 1, - Node: walker.fileAst.Name, - Category: "naming", - }) - } -} - -// Apply applies the rule to given file. -func (r *VarNamingRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure { - r.configureOnce.Do(func() { r.configure(arguments) }) - - var failures []lint.Failure - - fileAst := file.AST - - walker := lintNames{ - file: file, - fileAst: fileAst, - allowList: r.allowList, - blockList: r.blockList, - onFailure: func(failure lint.Failure) { - failures = append(failures, failure) - }, - upperCaseConst: r.allowUpperCaseConst, - } - - if !r.skipPackageNameChecks { - r.applyPackageCheckRules(&walker) - } - - ast.Walk(&walker, fileAst) - - return failures -} - -// Name returns the rule name. -func (*VarNamingRule) Name() string { - return "var-naming" -} - -func (w *lintNames) checkList(fl *ast.FieldList, thing string) { - if fl == nil { - return - } - for _, f := range fl.List { - for _, id := range f.Names { - w.check(id, thing) - } - } -} - -func (w *lintNames) check(id *ast.Ident, thing string) { - if id.Name == "_" { - return - } - if knownNameExceptions[id.Name] { - return - } - - // #851 upperCaseConst support - // if it's const - if thing == token.CONST.String() && w.upperCaseConst && upperCaseConstRE.MatchString(id.Name) { - return - } - - // Handle two common styles from other languages that don't belong in Go. - if len(id.Name) >= 5 && allCapsRE.MatchString(id.Name) && strings.Contains(id.Name, "_") { - w.onFailure(lint.Failure{ - Failure: "don't use ALL_CAPS in Go names; use CamelCase", - Confidence: 0.8, - Node: id, - Category: "naming", - }) - return - } - - should := lint.Name(id.Name, w.allowList, w.blockList) - if id.Name == should { - return - } - - if len(id.Name) > 2 && strings.Contains(id.Name[1:], "_") { - w.onFailure(lint.Failure{ - Failure: fmt.Sprintf("don't use underscores in Go names; %s %s should be %s", thing, id.Name, should), - Confidence: 0.9, - Node: id, - Category: "naming", - }) - return - } - w.onFailure(lint.Failure{ - Failure: fmt.Sprintf("%s %s should be %s", thing, id.Name, should), - Confidence: 0.8, - Node: id, - Category: "naming", - }) -} - -type lintNames struct { - file *lint.File - fileAst *ast.File - onFailure func(lint.Failure) - allowList []string - blockList []string - upperCaseConst bool -} - -func (w *lintNames) Visit(n ast.Node) ast.Visitor { - switch v := n.(type) { - case *ast.AssignStmt: - if v.Tok == token.ASSIGN { - return w - } - for _, exp := range v.Lhs { - if id, ok := exp.(*ast.Ident); ok { - w.check(id, "var") - } - } - case *ast.FuncDecl: - funcName := v.Name.Name - if w.file.IsTest() && - (strings.HasPrefix(funcName, "Example") || - strings.HasPrefix(funcName, "Test") || - strings.HasPrefix(funcName, "Benchmark") || - strings.HasPrefix(funcName, "Fuzz")) { - return w - } - - thing := "func" - if v.Recv != nil { - thing = "method" - } - - // Exclude naming warnings for functions that are exported to C but - // not exported in the Go API. - // See https://github.com/golang/lint/issues/144. - if ast.IsExported(v.Name.Name) || !isCgoExported(v) { - w.check(v.Name, thing) - } - - w.checkList(v.Type.Params, thing+" parameter") - w.checkList(v.Type.Results, thing+" result") - case *ast.GenDecl: - if v.Tok == token.IMPORT { - return w - } - - thing := v.Tok.String() - for _, spec := range v.Specs { - switch s := spec.(type) { - case *ast.TypeSpec: - w.check(s.Name, thing) - case *ast.ValueSpec: - for _, id := range s.Names { - w.check(id, thing) - } - } - } - case *ast.InterfaceType: - // Do not check interface method names. - // They are often constrained by the method names of concrete types. - for _, x := range v.Methods.List { - ft, ok := x.Type.(*ast.FuncType) - if !ok { // might be an embedded interface name - continue - } - w.checkList(ft.Params, "interface method parameter") - w.checkList(ft.Results, "interface method result") - } - case *ast.RangeStmt: - if v.Tok == token.ASSIGN { - return w - } - if id, ok := v.Key.(*ast.Ident); ok { - w.check(id, "range var") - } - if id, ok := v.Value.(*ast.Ident); ok { - w.check(id, "range var") - } - case *ast.StructType: - for _, f := range v.Fields.List { - for _, id := range f.Names { - w.check(id, "struct field") - } - } - } - return w -} - -func getList(arg any, argName string) []string { - args, ok := arg.([]any) - if !ok { - panic(fmt.Sprintf("Invalid argument to the var-naming rule. Expecting a %s of type slice with initialisms, got %T", argName, arg)) - } - var list []string - for _, v := range args { - val, ok := v.(string) - if !ok { - panic(fmt.Sprintf("Invalid %s values of the var-naming rule. Expecting slice of strings but got element of type %T", val, arg)) - } - list = append(list, val) - } - return list -} diff --git a/vendor/github.com/mgechev/revive/rule/waitgroup_by_value.go b/vendor/github.com/mgechev/revive/rule/waitgroup_by_value.go deleted file mode 100644 index a2d304ae5..000000000 --- a/vendor/github.com/mgechev/revive/rule/waitgroup_by_value.go +++ /dev/null @@ -1,66 +0,0 @@ -package rule - -import ( - "go/ast" - - "github.com/mgechev/revive/lint" -) - -// WaitGroupByValueRule lints sync.WaitGroup passed by copy in functions. -type WaitGroupByValueRule struct{} - -// Apply applies the rule to given file. -func (*WaitGroupByValueRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure { - var failures []lint.Failure - - onFailure := func(failure lint.Failure) { - failures = append(failures, failure) - } - - w := lintWaitGroupByValueRule{onFailure: onFailure} - ast.Walk(w, file.AST) - return failures -} - -// Name returns the rule name. -func (*WaitGroupByValueRule) Name() string { - return "waitgroup-by-value" -} - -type lintWaitGroupByValueRule struct { - onFailure func(lint.Failure) -} - -func (w lintWaitGroupByValueRule) Visit(node ast.Node) ast.Visitor { - // look for function declarations - fd, ok := node.(*ast.FuncDecl) - if !ok { - return w - } - - // Check all function's parameters - for _, field := range fd.Type.Params.List { - if !w.isWaitGroup(field.Type) { - continue - } - - w.onFailure(lint.Failure{ - Confidence: 1, - Node: field, - Failure: "sync.WaitGroup passed by value, the function will get a copy of the original one", - }) - } - - return nil // skip visiting function body -} - -func (lintWaitGroupByValueRule) isWaitGroup(ft ast.Expr) bool { - se, ok := ft.(*ast.SelectorExpr) - if !ok { - return false - } - - x, _ := se.X.(*ast.Ident) - sel := se.Sel.Name - return x.Name == "sync" && sel == "WaitGroup" -} -- cgit mrf-deployment