Draft: fix: linter build err

.gitignore

@@ -24,4 +24,6 @@ cover.out
 /swag.exe
 cmd/swag/docs/*
 
-.vscode/launch.json
+.vscode/launch.json
+
+vendor/

.golangci.yaml

@@ -0,0 +1,10 @@
+linters:
+  disable-all: true
+  enable:
+    - errcheck
+    - govet
+    - typecheck
+    - unused
+    - goimports
+    - misspell
+  fast: true

Makefile

@@ -64,12 +64,11 @@ deps:
 
 .PHONY: devel-deps
 devel-deps:
-	GO111MODULE=off $(GOGET) -v -u \
-		golang.org/x/lint/golint
+	go install github.com/golangci/golangci-lint/cmd/[email protected]
 
 .PHONY: lint
 lint: devel-deps
-	for PKG in $(PACKAGES); do golint -set_exit_status $$PKG || exit 1; done;
+	golangci-lint run .
 
 .PHONY: vet
 vet: deps devel-deps

field_parserv3.go

@@ -380,48 +380,6 @@ func getIntTagV3(structTag reflect.StructTag, tagName string) (*int, error) {
 	return &value, nil
 }
 
-func parseValidTagsV3(validTag string, sf *structFieldV3) {
-
-	// `validate:"required,max=10,min=1"`
-	// ps. required checked by IsRequired().
-	for _, val := range strings.Split(validTag, ",") {
-		var (
-			valValue string
-			keyVal   = strings.Split(val, "=")
-		)
-
-		switch len(keyVal) {
-		case 1:
-		case 2:
-			valValue = strings.ReplaceAll(strings.ReplaceAll(keyVal[1], utf8HexComma, ","), utf8Pipe, "|")
-		default:
-			continue
-		}
-
-		switch keyVal[0] {
-		case "max", "lte":
-			sf.setMax(valValue)
-		case "min", "gte":
-			sf.setMin(valValue)
-		case "oneof":
-			if strings.Contains(validTag, "swaggerIgnore") {
-				continue
-			}
-
-			sf.setOneOf(valValue)
-		case "unique":
-			if sf.schemaType == ARRAY {
-				sf.unique = true
-			}
-		case "dive":
-			// ignore dive
-			return
-		default:
-			continue
-		}
-	}
-}
-
 func (sf *structFieldV3) parseValidTags(validTag string) {
 
 	// `validate:"required,max=10,min=1"`

generics_test.go

@@ -95,9 +95,10 @@ func TestParseGenericsProperty(t *testing.T) {
 
 	p := New()
 	err = p.ParseAPI(searchDir, mainAPIFile, defaultParseDepth)
+	assert.Empty(t, err)
 	assert.NoError(t, err)
 	b, err := json.MarshalIndent(p.swagger, "", "    ")
-	os.WriteFile(searchDir+"/expected.json", b, fs.ModePerm)
+	err = os.WriteFile(searchDir+"/expected.json", b, fs.ModePerm)
 	assert.NoError(t, err)
 	assert.Equal(t, string(expected), string(b))
 }

operation_test.go

@@ -1870,17 +1870,20 @@ func TestParseParamCommentByExampleUnsupportedType(t *testing.T) {
 	t.Parallel()
 	var param spec.Parameter
 
-	setExample(&param, "something", "random value")
+	err := setExample(&param, "something", "random value")
 	assert.Equal(t, param.Example, nil)
 
-	setExample(&param, STRING, "string value")
+	err = setExample(&param, STRING, "string value")
 	assert.Equal(t, param.Example, "string value")
+	assert.Empty(t, err)
 
-	setExample(&param, INTEGER, "10")
+	err = setExample(&param, INTEGER, "10")
 	assert.Equal(t, param.Example, 10)
+	assert.Empty(t, err)
 
-	setExample(&param, NUMBER, "10")
+	err = setExample(&param, NUMBER, "10")
 	assert.Equal(t, param.Example, float64(10))
+	assert.Empty(t, err)
 }
 
 func TestParseParamCommentBySchemaExampleString(t *testing.T) {
@@ -1911,24 +1914,30 @@ func TestParseParamCommentBySchemaExampleUnsupportedType(t *testing.T) {
 	t.Parallel()
 	var param spec.Parameter
 
-	setSchemaExample(&param, "something", "random value")
+	err := setSchemaExample(&param, "something", "random value")
 	assert.Nil(t, param.Schema)
+	assert.Empty(t, err)
 
-	setSchemaExample(&param, STRING, "string value")
+	err = setSchemaExample(&param, STRING, "string value")
 	assert.Nil(t, param.Schema)
+	assert.Empty(t, err)
 
 	param.Schema = &spec.Schema{}
-	setSchemaExample(&param, STRING, "string value")
+	err = setSchemaExample(&param, STRING, "string value")
 	assert.Equal(t, "string value", param.Schema.Example)
+	assert.Empty(t, err)
 
-	setSchemaExample(&param, INTEGER, "10")
+	err = setSchemaExample(&param, INTEGER, "10")
 	assert.Equal(t, 10, param.Schema.Example)
+	assert.Empty(t, err)
 
-	setSchemaExample(&param, NUMBER, "10")
+	err = setSchemaExample(&param, NUMBER, "10")
 	assert.Equal(t, float64(10), param.Schema.Example)
+	assert.Empty(t, err)
 
-	setSchemaExample(&param, STRING, "string \\r\\nvalue")
+	err = setSchemaExample(&param, STRING, "string \\r\\nvalue")
 	assert.Equal(t, "string \r\nvalue", param.Schema.Example)
+	assert.Empty(t, err)
 }
 
 func TestParseParamArrayWithEnums(t *testing.T) {

operationv3.go

@@ -602,17 +602,6 @@ func setSchemaExampleV3(param *spec.Schema, schemaType string, value string) err
 	return nil
 }
 
-func setExampleParameterV3(param *spec.Parameter, schemaType string, value string) error {
-	val, err := defineType(schemaType, value)
-	if err != nil {
-		return nil // Don't set a example value if it's not valid
-	}
-
-	param.Example = val
-
-	return nil
-}
-
 func setStringParamV3(param *spec.Schema, name, schemaType, attr, commentLine string) error {
 	if schemaType != STRING {
 		return fmt.Errorf("%s is attribute to set to a number. comment=%s got=%s", name, commentLine, schemaType)

operationv3_test.go

@@ -1571,24 +1571,30 @@ func TestParseParamCommentBySchemaExampleUnsupportedTypeV3(t *testing.T) {
 	t.Parallel()
 	var param spec.Parameter
 
-	setSchemaExampleV3(nil, "something", "random value")
+	err := setSchemaExampleV3(nil, "something", "random value")
 	assert.Nil(t, param.Schema)
+	assert.Empty(t, err)
 
-	setSchemaExampleV3(nil, STRING, "string value")
+	err = setSchemaExampleV3(nil, STRING, "string value")
 	assert.Nil(t, param.Schema)
+	assert.Empty(t, err)
 
 	param.Schema = spec.NewSchemaSpec()
-	setSchemaExampleV3(param.Schema.Spec, STRING, "string value")
+	err = setSchemaExampleV3(param.Schema.Spec, STRING, "string value")
 	assert.Equal(t, "string value", param.Schema.Spec.Example)
+	assert.Empty(t, err)
 
-	setSchemaExampleV3(param.Schema.Spec, INTEGER, "10")
+	err = setSchemaExampleV3(param.Schema.Spec, INTEGER, "10")
 	assert.Equal(t, 10, param.Schema.Spec.Example)
+	assert.Empty(t, err)
 
-	setSchemaExampleV3(param.Schema.Spec, NUMBER, "10")
+	err = setSchemaExampleV3(param.Schema.Spec, NUMBER, "10")
 	assert.Equal(t, float64(10), param.Schema.Spec.Example)
+	assert.Empty(t, err)
 
-	setSchemaExampleV3(param.Schema.Spec, STRING, "string \\r\\nvalue")
+	err = setSchemaExampleV3(param.Schema.Spec, STRING, "string \\r\\nvalue")
 	assert.Equal(t, "string \r\nvalue", param.Schema.Spec.Example)
+	assert.Empty(t, err)
 }
 
 func TestParseParamArrayWithEnumsV3(t *testing.T) {

packages.go

@@ -595,17 +595,3 @@ func (pkgDefs *PackagesDefinitions) FindTypeSpec(typeName string, file *ast.File
 
 	return pkgDefs.parametrizeGenericType(file, typeDef, typeName)
 }
-
-func isAliasPkgName(file *ast.File, pkgName string) bool {
-	if file == nil && file.Imports == nil {
-		return false
-	}
-
-	for _, pkg := range file.Imports {
-		if pkg.Name != nil && pkg.Name.Name == pkgName {
-			return true
-		}
-	}
-
-	return false
-}

parser.go

@@ -405,7 +405,7 @@ func (parser *Parser) ParseAPIMultiSearchDir(searchDirs []string, mainAPIFile st
 
 	// Use 'go list' command instead of depth.Resolve()
 	if parser.ParseDependency {
-		parser.parseDeps(absMainAPIFilePath, parseDepth)
+		_ = parser.parseDeps(absMainAPIFilePath, parseDepth)
 	}
 
 	err = parser.ParseGeneralAPIInfo(absMainAPIFilePath)
@@ -922,7 +922,8 @@ func isExistsScope(scope string) (bool, error) {
 	for _, v := range s {
 		if strings.Contains(v, scopeAttrPrefix) {
 			if strings.Contains(v, ",") {
-				return false, fmt.Errorf("@scope can't use comma(,) get=" + v)
+
+				return false, errors.New("@scope can't use comma(,) get=" + v)
 			}
 		}
 	}

parser_test.go

@@ -3729,14 +3729,9 @@ func TestGetFieldType(t *testing.T) {
 }
 
 func TestTryAddDescription(t *testing.T) {
-	type args struct {
-		spec       *spec.SecurityScheme
-		extensions map[string]interface{}
-	}
 	tests := []struct {
 		name  string
 		lines []string
-		args  args
 		want  *spec.SecurityScheme
 	}{
 		{

schema.go

@@ -3,6 +3,7 @@ package swag
 import (
 	"errors"
 	"fmt"
+
 	"github.com/go-openapi/spec"
 )
 

utils_test.go

@@ -2,6 +2,7 @@ package swag
 
 import (
 	"github.com/stretchr/testify/assert"
+
 	"testing"
 )