feat(fix): add support for --fix (#29)

* feat(fix): draft supporting fix

* feat(fix): draft supporting fix

* feat(fix): draft supporting fix

* feat(fix): draft supporting fix

* feat(fix): draft supporting fix

* Apply suggestions from code review

Co-authored-by: Oleksandr Redko <oleksandr.red+github@gmail.com>

* fixing compilation issues

* small refactor

* feat(fix): draft supporting fix

* feat(fix): draft supporting fix

* feat(fix): draft supporting fix

* feat(fix): draft supporting fix

* feat(fix): supporting fix

* adding directive test case

* adding directive test case

* using only one suggestedFix entry

* applying alexandear's comments

* fix: bug with first struct method with comments

* refactor: small refactor

---------

Co-authored-by: Oleksandr Redko <oleksandr.red+github@gmail.com>
Co-authored-by: manuelarte <manuel.doncel.martos@gmail.com>

Author: 3 people

README.md

@@ -8,7 +8,7 @@
     - [As A Golangci-lint linter](#as-a-golangci-lint-linter)
     - [Standalone application](#standalone-application)
   - [🚀 Features](#-features)
-    - [Check exported methods are placed before non-exported methods](#check-exported-methods-are-placed-before-non-exported-methods)
+    - [Check exported methods are placed before unexported methods](#check-exported-methods-are-placed-before-unexported-methods)
     - [Check `Constructors` functions are placed after struct declaration](#check-constructors-functions-are-placed-after-struct-declaration)
     - [Check Constructors/Methods are sorted alphabetically](#check-constructorsmethods-are-sorted-alphabetically)
   - [Resources](#resources)
@@ -32,7 +32,7 @@ linters:
       # Checks that constructors are placed after the structure declaration.
       # Default: true
       constructor: false
-      # Checks if the exported methods of a structure are placed before the non-exported ones.
+      # Checks if the exported methods of a structure are placed before the unexported ones.
       # Default: true
       struct-method: false
       # Checks if the constructors and/or structure methods are sorted alphabetically.
@@ -51,20 +51,21 @@ go install github.com/manuelarte/funcorder@latest
 And then use it with
 
 ```
-funcorder [-constructor=true|false] [-struct-method=true|false] [-alphabetical=true|false] ./...
+funcorder [-constructor=true|false] [-struct-method=true|false] [-alphabetical=true|false] [--fix] ./...
 ```
 
 Parameters:
 
 - `constructor`: `true|false` (default `true`) Checks that constructors are placed after the structure declaration.
-- `struct-method`: `true|false` (default `true`) Checks if the exported methods of a structure are placed before the non-exported ones.
+- `struct-method`: `true|false` (default `true`) Checks if the exported methods of a structure are placed before the unexported ones.
 - `alphabetical`: `true|false` (default `false`) Checks if the constructors and/or structure methods are sorted alphabetically.
+- `fix`: Fix the source code to adhere to the enabled features.
 
 ## 🚀 Features
 
-### Check exported methods are placed before non-exported methods
+### Check exported methods are placed before unexported methods
 
-This rule checks that the exported method are placed before the non-exported ones, e.g:
+This rule checks that the exported method are placed before the unexported ones, e.g:
 
 <table>
 <thead><tr><th>❌ Bad</th><th>✅ Good</th></tr></thead>
@@ -76,7 +77,7 @@ type MyStruct struct {
  Name string
 }
 
-// ❌ non-exported method 
+// ❌ unexported method 
 // placed before exported method
 func (m MyStruct) lenName() int { 
  return len(m.Name)
@@ -96,7 +97,7 @@ type MyStruct struct {
 }
 
 // ✅ exported methods before 
-// non-exported methods
+// unexported methods
 func (m MyStruct) GetName() string {
  return m.Name
 }
@@ -171,7 +172,7 @@ func NewMyStruct() MyStruct {
 This rule checks:
 
 - `Constructor` functions are sorted alphabetically (if `constructor` setting/parameter is `true`).
-- `Methods` are sorted alphabetically (if `struct-method` setting/parameter is `true`) for each group (exported and non-exported).
+- `Methods` are sorted alphabetically (if `struct-method` setting/parameter is `true`) for each group (exported and unexported).
 
 <table>
 <thead><tr><th>❌ Bad</th><th>✅ Good</th></tr></thead>
@@ -241,7 +242,7 @@ func (m MyStruct) GoodMorning() string {
     return "good morning"
 }
 
-// ✅ non-exported methods sorted alphabetically
+// ✅ unexported methods sorted alphabetically
 func (m MyStruct) bye() string {
     return "bye"
 }

analyzer/analyzer.go

@@ -23,14 +23,15 @@ func NewAnalyzer() *analysis.Analyzer {
 	a := &analysis.Analyzer{
 		Name:     "funcorder",
 		Doc:      "checks the order of functions, methods, and constructors",
+		URL:      "https://github.com/manuelarte/funcorder",
 		Run:      f.run,
 		Requires: []*analysis.Analyzer{inspect.Analyzer},
 	}
 
 	a.Flags.BoolVar(&f.constructorCheck, ConstructorCheckName, true,
 		"Checks that constructors are placed after the structure declaration.")
 	a.Flags.BoolVar(&f.structMethodCheck, StructMethodCheckName, true,
-		"Checks if the exported methods of a structure are placed before the non-exported ones.")
+		"Checks if the exported methods of a structure are placed before the unexported ones.")
 	a.Flags.BoolVar(&f.alphabeticalCheck, AlphabeticalCheckName, false,
 		"Checks if the constructors and/or structure methods are sorted alphabetically.")
 
@@ -57,7 +58,7 @@ func (f *funcorder) run(pass *analysis.Pass) (any, error) {
 		enabledCheckers.Enable(features.AlphabeticalCheck)
 	}
 
-	fp := fileprocessor.NewFileProcessor(enabledCheckers)
+	fp := fileprocessor.NewFileProcessor(pass.Fset, enabledCheckers)
 
 	insp, found := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
 	if !found {
@@ -71,10 +72,19 @@ func (f *funcorder) run(pass *analysis.Pass) (any, error) {
 		(*ast.TypeSpec)(nil),
 	}
 
+	var errProcessing error
 	insp.Preorder(nodeFilter, func(n ast.Node) {
+		if errProcessing != nil {
+			return
+		}
 		switch node := n.(type) {
 		case *ast.File:
-			for _, report := range fp.Analyze() {
+			reports, err := fp.Analyze()
+			if err != nil {
+				errProcessing = err
+				return
+			}
+			for _, report := range reports {
 				pass.Report(report)
 			}
 
@@ -87,8 +97,15 @@ func (f *funcorder) run(pass *analysis.Pass) (any, error) {
 			fp.NewTypeSpec(node)
 		}
 	})
+	if errProcessing != nil {
+		return nil, errProcessing
+	}
 
-	for _, report := range fp.Analyze() {
+	reports, err := fp.Analyze()
+	if err != nil {
+		return nil, err
+	}
+	for _, report := range reports {
 		pass.Report(report)
 	}
 

analyzer/analyzer_test.go

@@ -73,3 +73,89 @@ func TestAnalyzer(t *testing.T) {
 		})
 	}
 }
+
+func TestAnalyzerWithFix(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		patterns string
+		options  map[string]string
+	}{
+		{
+			desc:     "constructor fix",
+			patterns: "constructor-check-fix",
+			options: map[string]string{
+				ConstructorCheckName:  "true",
+				StructMethodCheckName: "false",
+				AlphabeticalCheckName: "false",
+			},
+		},
+		{
+			desc:     "constructor alphabetical fix",
+			patterns: "constructor-check-alphabetical-fix",
+			options: map[string]string{
+				ConstructorCheckName:  "true",
+				StructMethodCheckName: "false",
+				AlphabeticalCheckName: "true",
+			},
+		},
+		{
+			desc:     "struct method fix",
+			patterns: "struct-method-fix",
+			options: map[string]string{
+				ConstructorCheckName:  "false",
+				StructMethodCheckName: "true",
+				AlphabeticalCheckName: "false",
+			},
+		},
+		{
+			desc:     "struct method alphabetical fix",
+			patterns: "struct-method-alphabetical-fix",
+			options: map[string]string{
+				ConstructorCheckName:  "false",
+				StructMethodCheckName: "true",
+				AlphabeticalCheckName: "true",
+			},
+		},
+		{
+			desc:     "simple fix",
+			patterns: "simple-fix",
+			options: map[string]string{
+				ConstructorCheckName:  "true",
+				StructMethodCheckName: "true",
+				AlphabeticalCheckName: "false",
+			},
+		},
+		{
+			desc:     "simple alphabetical fix",
+			patterns: "simple-alphabetical-fix",
+			options: map[string]string{
+				ConstructorCheckName:  "true",
+				StructMethodCheckName: "true",
+				AlphabeticalCheckName: "true",
+			},
+		},
+		{
+			desc:     "special cases",
+			patterns: "special-cases-fix",
+			options: map[string]string{
+				ConstructorCheckName:  "true",
+				StructMethodCheckName: "true",
+				AlphabeticalCheckName: "false",
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.desc, func(t *testing.T) {
+			a := NewAnalyzer()
+
+			for k, v := range test.options {
+				if err := a.Flags.Set(k, v); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			analysistest.RunWithSuggestedFixes(t, analysistest.TestData(), a, test.patterns)
+		})
+	}
+}

analyzer/testdata/src/constructor-check-alphabetical-fix/constructors_after_struct_methods_with_comments.go

@@ -0,0 +1,28 @@
+package constructor_check_alphabetical_fix
+
+type ConstructorAfterStructMethodsWithComments struct {
+	Name string
+}
+
+// GetName returns the name.
+func (m ConstructorAfterStructMethodsWithComments) GetName() string {
+	return m.Name
+}
+
+// SetName sets the name
+// multi line comment
+func (m *ConstructorAfterStructMethodsWithComments) SetName(name string) {
+	m.Name = name
+}
+
+// NewOtherConstructorAfterStructMethodsWithComments This constructor creates the
+// struct ConstructorAfterStructMethodsWithComments
+// with a named return
+func NewOtherConstructorAfterStructMethodsWithComments() (m *ConstructorAfterStructMethodsWithComments) { // want `constructor \"NewOtherConstructorAfterStructMethodsWithComments\" for struct \"ConstructorAfterStructMethodsWithComments\" should be placed before struct method \"GetName\"`
+	m = &ConstructorAfterStructMethodsWithComments{Name: "John"}
+	return
+}
+
+func NewConstructorAfterStructMethodsWithComments() *ConstructorAfterStructMethodsWithComments { // want `constructor \"NewConstructorAfterStructMethodsWithComments\" for struct \"ConstructorAfterStructMethodsWithComments\" should be placed before struct method \"GetName\"` `constructor \"NewConstructorAfterStructMethodsWithComments\" for struct \"ConstructorAfterStructMethodsWithComments\" should be placed before constructor \"NewOtherConstructorAfterStructMethodsWithComments\"`
+	return &ConstructorAfterStructMethodsWithComments{Name: "John"}
+}

analyzer/testdata/src/constructor-check-alphabetical-fix/constructors_after_struct_methods_with_comments.go.golden

@@ -0,0 +1,28 @@
+package constructor_check_alphabetical_fix
+
+type ConstructorAfterStructMethodsWithComments struct {
+	Name string
+}
+
+func NewConstructorAfterStructMethodsWithComments() *ConstructorAfterStructMethodsWithComments {
+	return &ConstructorAfterStructMethodsWithComments{Name: "John"}
+}
+
+// NewOtherConstructorAfterStructMethodsWithComments This constructor creates the
+// struct ConstructorAfterStructMethodsWithComments
+// with a named return
+func NewOtherConstructorAfterStructMethodsWithComments() (m *ConstructorAfterStructMethodsWithComments) {
+	m = &ConstructorAfterStructMethodsWithComments{Name: "John"}
+	return
+}
+
+// GetName returns the name.
+func (m ConstructorAfterStructMethodsWithComments) GetName() string {
+	return m.Name
+}
+
+// SetName sets the name
+// multi line comment
+func (m *ConstructorAfterStructMethodsWithComments) SetName(name string) {
+	m.Name = name
+}

analyzer/testdata/src/constructor-check-alphabetical-fix/constructors_before_struct_with_comments.go

@@ -0,0 +1,28 @@
+package constructor_check_alphabetical_fix
+
+// NewOtherConstructorAfterStructMethodsWithComments This constructor creates the
+// struct ConstructorBeforeStructWithComments
+// with a named return
+func NewOtherConstructorBeforeStructWithComments() (m *ConstructorBeforeStructWithComments) { // want `constructor \"NewOtherConstructorBeforeStructWithComments\" for struct \"ConstructorBeforeStructWithComments\" should be placed after the struct declaration`
+	m = &ConstructorBeforeStructWithComments{Name: "John"}
+	return
+}
+
+func NewConstructorBeforeStructWithComments() *ConstructorBeforeStructWithComments { // want `constructor \"NewConstructorBeforeStructWithComments\" for struct \"ConstructorBeforeStructWithComments\" should be placed after the struct declaration` `constructor \"NewConstructorBeforeStructWithComments\" for struct \"ConstructorBeforeStructWithComments\" should be placed before constructor \"NewOtherConstructorBeforeStructWithComments\"`
+	return &ConstructorBeforeStructWithComments{Name: "John"}
+}
+
+type ConstructorBeforeStructWithComments struct {
+	Name string
+}
+
+// GetName returns the name.
+func (m ConstructorBeforeStructWithComments) GetName() string {
+	return m.Name
+}
+
+// SetName sets the name
+// multi line comment
+func (m *ConstructorBeforeStructWithComments) SetName(name string) {
+	m.Name = name
+}

analyzer/testdata/src/constructor-check-alphabetical-fix/constructors_before_struct_with_comments.go.golden

@@ -0,0 +1,28 @@
+package constructor_check_alphabetical_fix
+
+type ConstructorBeforeStructWithComments struct {
+	Name string
+}
+
+func NewConstructorBeforeStructWithComments() *ConstructorBeforeStructWithComments {
+	return &ConstructorBeforeStructWithComments{Name: "John"}
+}
+
+// NewOtherConstructorAfterStructMethodsWithComments This constructor creates the
+// struct ConstructorBeforeStructWithComments
+// with a named return
+func NewOtherConstructorBeforeStructWithComments() (m *ConstructorBeforeStructWithComments) {
+	m = &ConstructorBeforeStructWithComments{Name: "John"}
+	return
+}
+
+// GetName returns the name.
+func (m ConstructorBeforeStructWithComments) GetName() string {
+	return m.Name
+}
+
+// SetName sets the name
+// multi line comment
+func (m *ConstructorBeforeStructWithComments) SetName(name string) {
+	m.Name = name
+}

analyzer/testdata/src/constructor-check-fix/constructors_after_struct_methods_with_comments.go

@@ -0,0 +1,28 @@
+package constructor_check_fix
+
+type ConstructorAfterStructMethodsWithComments struct {
+	Name string
+}
+
+// GetName returns the name.
+func (m ConstructorAfterStructMethodsWithComments) GetName() string {
+	return m.Name
+}
+
+// SetName sets the name
+// multi line comment
+func (m *ConstructorAfterStructMethodsWithComments) SetName(name string) {
+	m.Name = name
+}
+
+// NewOtherConstructorAfterStructMethodsWithComments This constructor creates the
+// struct ConstructorAfterStructMethodsWithComments
+// with a named return
+func NewOtherConstructorAfterStructMethodsWithComments() (m *ConstructorAfterStructMethodsWithComments) { // want `constructor \"NewOtherConstructorAfterStructMethodsWithComments\" for struct \"ConstructorAfterStructMethodsWithComments\" should be placed before struct method \"GetName\"`
+	m = &ConstructorAfterStructMethodsWithComments{Name: "John"}
+	return
+}
+
+func NewConstructorAfterStructMethodsWithComments() *ConstructorAfterStructMethodsWithComments { // want `constructor \"NewConstructorAfterStructMethodsWithComments\" for struct \"ConstructorAfterStructMethodsWithComments\" should be placed before struct method \"GetName\"`
+	return &ConstructorAfterStructMethodsWithComments{Name: "John"}
+}