ci: update golangci-lint to v2

PascalBourdier · PascalBourdier · commit 43667d329409 · 2025-12-01T19:39:19.000+01:00
update method:
```
golangci-lint migrate
golangci-lint run --fix
```

and fix the last ones manually
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -14,9 +14,9 @@ jobs:
         with:
           go-version: "1.25.x"
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v9
         with:
-          version: v1.64.8
+          version: v2.6.2
 
   test:
     runs-on: ubuntu-latest
diff --git a/.golangci.yml b/.golangci.yml
@@ -1,30 +1,37 @@
-run:
-  # timeout for analysis, e.g. 30s, 5m, default is 1m
-  timeout: 5m
+version: "2"
 linters:
   enable:
-    #- golint
-    #- interfacer
-    - unconvert
-    #- dupl
     - goconst
-    - gofmt
     - misspell
-    - unparam
     - nakedret
     - prealloc
     - revive
-    #- gosec
-linters-settings:
-  misspell:
-    locale: US
-  revive:
+    - unconvert
+    - unparam
+  settings:
+    misspell:
+      locale: US
+    revive:
+      rules:
+        - name: redundant-build-tag
+  exclusions:
+    generated: lax
     rules:
-      - name: redundant-build-tag
+      - path: (.+)\.go$
+        text: G104
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
 issues:
-  max-same-issues: 0
   max-issues-per-linter: 0
-  exclude-use-default: false
-  exclude:
-    # gosec: Duplicated errcheck checks
-    - G104
+  max-same-issues: 0
+formatters:
+  enable:
+    - gofmt
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
diff --git a/database/cassandra/cassandra.go b/database/cassandra/cassandra.go
@@ -336,7 +336,7 @@ func parseConsistency(consistencyStr string) (consistency gocql.Consistency, err
 			var ok bool
 			err, ok = r.(error)
 			if !ok {
-				err = fmt.Errorf("Failed to parse consistency \"%s\": %v", consistencyStr, r)
+				err = fmt.Errorf("failed to parse consistency \"%s\": %v", consistencyStr, r)
 			}
 		}
 	}()
diff --git a/database/clickhouse/clickhouse.go b/database/clickhouse/clickhouse.go
@@ -307,5 +307,5 @@ func quoteIdentifier(name string) string {
 	if end > -1 {
 		name = name[:end]
 	}
-	return `"` + strings.Replace(name, `"`, `""`, -1) + `"`
+	return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
 }
diff --git a/database/mysql/mysql.go b/database/mysql/mysql.go
@@ -34,7 +34,7 @@ var (
 	ErrNilConfig        = fmt.Errorf("no config")
 	ErrNoDatabaseName   = fmt.Errorf("no database name")
 	ErrAppendPEM        = fmt.Errorf("failed to append PEM")
-	ErrTLSCertKeyConfig = fmt.Errorf("To use TLS client authentication, both x-tls-cert and x-tls-key must not be empty")
+	ErrTLSCertKeyConfig = fmt.Errorf("to use TLS client authentication, both x-tls-cert and x-tls-key must not be empty")
 )
 
 type Config struct {
diff --git a/database/pgx/pgx.go b/database/pgx/pgx.go
@@ -181,7 +181,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 	if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {
 		migrationsTableQuoted, err = strconv.ParseBool(s)
 		if err != nil {
-			return nil, fmt.Errorf("Unable to parse option x-migrations-table-quoted: %w", err)
+			return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)
 		}
 	}
 	if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') || (migrationsTable[len(migrationsTable)-1] != '"')) {
@@ -212,7 +212,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 	if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {
 		multiStatementEnabled, err = strconv.ParseBool(s)
 		if err != nil {
-			return nil, fmt.Errorf("Unable to parse option x-multi-statement: %w", err)
+			return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)
 		}
 	}
 
@@ -412,7 +412,7 @@ func (p *Postgres) runStatement(statement []byte) error {
 
 func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
 	// replace crlf with lf
-	s = strings.Replace(s, "\r\n", "\n", -1)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes
 	runes := []rune(s)
 	if pos > len(runes) {
@@ -613,5 +613,5 @@ func quoteIdentifier(name string) string {
 	if end > -1 {
 		name = name[:end]
 	}
-	return `"` + strings.Replace(name, `"`, `""`, -1) + `"`
+	return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
 }
diff --git a/database/pgx/pgx_test.go b/database/pgx/pgx_test.go
@@ -755,10 +755,10 @@ func Test_computeLineFromPos(t *testing.T) {
 				t.Run(name, func(t *testing.T) {
 					input := tc.input
 					if crlf {
-						input = strings.Replace(input, "\n", "\r\n", -1)
+						input = strings.ReplaceAll(input, "\n", "\r\n")
 					}
 					if nonASCII {
-						input = strings.Replace(input, "FROM", "FRÖM", -1)
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
 					}
 					gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)
 
diff --git a/database/pgx/v5/pgx.go b/database/pgx/v5/pgx.go
@@ -157,7 +157,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 	if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {
 		migrationsTableQuoted, err = strconv.ParseBool(s)
 		if err != nil {
-			return nil, fmt.Errorf("Unable to parse option x-migrations-table-quoted: %w", err)
+			return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)
 		}
 	}
 	if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') || (migrationsTable[len(migrationsTable)-1] != '"')) {
@@ -188,7 +188,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 	if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {
 		multiStatementEnabled, err = strconv.ParseBool(s)
 		if err != nil {
-			return nil, fmt.Errorf("Unable to parse option x-multi-statement: %w", err)
+			return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)
 		}
 	}
 
@@ -303,7 +303,7 @@ func (p *Postgres) runStatement(statement []byte) error {
 
 func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
 	// replace crlf with lf
-	s = strings.Replace(s, "\r\n", "\n", -1)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes
 	runes := []rune(s)
 	if pos > len(runes) {
@@ -476,5 +476,5 @@ func quoteIdentifier(name string) string {
 	if end > -1 {
 		name = name[:end]
 	}
-	return `"` + strings.Replace(name, `"`, `""`, -1) + `"`
+	return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
 }
diff --git a/database/pgx/v5/pgx_test.go b/database/pgx/v5/pgx_test.go
@@ -730,10 +730,10 @@ func Test_computeLineFromPos(t *testing.T) {
 				t.Run(name, func(t *testing.T) {
 					input := tc.input
 					if crlf {
-						input = strings.Replace(input, "\n", "\r\n", -1)
+						input = strings.ReplaceAll(input, "\n", "\r\n")
 					}
 					if nonASCII {
-						input = strings.Replace(input, "FROM", "FRÖM", -1)
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
 					}
 					gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)
 
diff --git a/database/postgres/postgres.go b/database/postgres/postgres.go
@@ -165,7 +165,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 	if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {
 		migrationsTableQuoted, err = strconv.ParseBool(s)
 		if err != nil {
-			return nil, fmt.Errorf("Unable to parse option x-migrations-table-quoted: %w", err)
+			return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)
 		}
 	}
 	if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') || (migrationsTable[len(migrationsTable)-1] != '"')) {
@@ -196,7 +196,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {
 	if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {
 		multiStatementEnabled, err = strconv.ParseBool(s)
 		if err != nil {
-			return nil, fmt.Errorf("Unable to parse option x-multi-statement: %w", err)
+			return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)
 		}
 	}
 
@@ -319,7 +319,7 @@ func (p *Postgres) runStatement(statement []byte) error {
 
 func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
 	// replace crlf with lf
-	s = strings.Replace(s, "\r\n", "\n", -1)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes
 	runes := []rune(s)
 	if pos > len(runes) {
diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go
@@ -798,10 +798,10 @@ func Test_computeLineFromPos(t *testing.T) {
 				t.Run(name, func(t *testing.T) {
 					input := tc.input
 					if crlf {
-						input = strings.Replace(input, "\n", "\r\n", -1)
+						input = strings.ReplaceAll(input, "\n", "\r\n")
 					}
 					if nonASCII {
-						input = strings.Replace(input, "FROM", "FRÖM", -1)
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
 					}
 					gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)
 
diff --git a/database/redshift/redshift.go b/database/redshift/redshift.go
@@ -174,7 +174,7 @@ func (p *Redshift) Run(migration io.Reader) error {
 
 func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
 	// replace crlf with lf
-	s = strings.Replace(s, "\r\n", "\n", -1)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes
 	runes := []rune(s)
 	if pos > len(runes) {
diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go
@@ -378,10 +378,10 @@ func Test_computeLineFromPos(t *testing.T) {
 				t.Run(name, func(t *testing.T) {
 					input := tc.input
 					if crlf {
-						input = strings.Replace(input, "\n", "\r\n", -1)
+						input = strings.ReplaceAll(input, "\n", "\r\n")
 					}
 					if nonASCII {
-						input = strings.Replace(input, "FROM", "FRÖM", -1)
+						input = strings.ReplaceAll(input, "FROM", "FRÖM")
 					}
 					gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)
 
diff --git a/database/snowflake/snowflake.go b/database/snowflake/snowflake.go
@@ -206,7 +206,7 @@ func (p *Snowflake) Run(migration io.Reader) error {
 
 func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {
 	// replace crlf with lf
-	s = strings.Replace(s, "\r\n", "\n", -1)
+	s = strings.ReplaceAll(s, "\r\n", "\n")
 	// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes
 	runes := []rune(s)
 	if pos > len(runes) {
diff --git a/database/sqlserver/sqlserver.go b/database/sqlserver/sqlserver.go
@@ -29,7 +29,7 @@ var (
 	ErrNoDatabaseName            = fmt.Errorf("no database name")
 	ErrNoSchema                  = fmt.Errorf("no schema")
 	ErrDatabaseDirty             = fmt.Errorf("database is dirty")
-	ErrMultipleAuthOptionsPassed = fmt.Errorf("both password and useMsi=true were passed.")
+	ErrMultipleAuthOptionsPassed = fmt.Errorf("both password and useMsi=true were passed")
 )
 
 var lockErrorMap = map[int]string{
diff --git a/database/testing/testing.go b/database/testing/testing.go
@@ -50,7 +50,7 @@ func TestLockAndUnlock(t *testing.T, d database.Driver) {
 			case <-done:
 				return
 			case <-timeout:
-				errs <- fmt.Errorf("Timeout after 15 seconds. Looks like a deadlock in Lock/UnLock.\n%#v", d)
+				errs <- fmt.Errorf("timeout after 15 seconds. Looks like a deadlock in Lock/UnLock\n%#v", d)
 				return
 			}
 		}
diff --git a/internal/cli/commands.go b/internal/cli/commands.go
@@ -15,9 +15,9 @@ import (
 )
 
 var (
-	errInvalidSequenceWidth     = errors.New("Digits must be positive")
-	errIncompatibleSeqAndFormat = errors.New("The seq and format options are mutually exclusive")
-	errInvalidTimeFormat        = errors.New("Time format may not be empty")
+	errInvalidSequenceWidth     = errors.New("digits must be positive")
+	errIncompatibleSeqAndFormat = errors.New("the seq and format options are mutually exclusive")
+	errInvalidTimeFormat        = errors.New("time format may not be empty")
 )
 
 func nextSeqVersion(matches []string, seqDigits int) (string, error) {
@@ -33,7 +33,7 @@ func nextSeqVersion(matches []string, seqDigits int) (string, error) {
 		idx := strings.Index(matchSeqStr, "_")
 
 		if idx < 1 { // Using 1 instead of 0 since there should be at least 1 digit
-			return "", fmt.Errorf("Malformed migration filename: %s", filename)
+			return "", fmt.Errorf("malformed migration filename: %s", filename)
 		}
 
 		var err error
@@ -50,7 +50,7 @@ func nextSeqVersion(matches []string, seqDigits int) (string, error) {
 	version := fmt.Sprintf("%0[2]*[1]d", nextSeq, seqDigits)
 
 	if len(version) > seqDigits {
-		return "", fmt.Errorf("Next sequence number %s too large. At most %d digits are allowed", version, seqDigits)
+		return "", fmt.Errorf("next sequence number %s too large, at most %d digits are allowed", version, seqDigits)
 	}
 
 	return version, nil
diff --git a/source/gitlab/gitlab.go b/source/gitlab/gitlab.go
@@ -130,7 +130,7 @@ func (g *Gitlab) readDirectory() error {
 		if response.CurrentPage >= response.TotalPages {
 			break
 		}
-		g.listOptions.ListOptions.Page = response.NextPage
+		g.listOptions.Page = response.NextPage
 	}
 
 	for i := range nodes {
diff --git a/testing/docker.go b/testing/docker.go
@@ -69,7 +69,7 @@ type DockerContainer struct {
 
 func (d *DockerContainer) PullImage() (err error) {
 	if d == nil {
-		return errors.New("Cannot pull image on a nil *DockerContainer")
+		return errors.New("cannot pull image on a nil *DockerContainer")
 	}
 	d.t.Logf("Docker: Pull image %v", d.ImageName)
 	r, err := d.client.ImagePull(context.Background(), d.ImageName, dockerimage.PullOptions{})
@@ -98,7 +98,7 @@ func (d *DockerContainer) PullImage() (err error) {
 
 func (d *DockerContainer) Start() error {
 	if d == nil {
-		return errors.New("Cannot start a nil *DockerContainer")
+		return errors.New("cannot start a nil *DockerContainer")
 	}
 
 	containerName := fmt.Sprintf("migrate_test_%s", pseudoRandStr(10))
@@ -146,7 +146,7 @@ func (d *DockerContainer) KeepForDebugging() {
 
 func (d *DockerContainer) Remove() error {
 	if d == nil {
-		return errors.New("Cannot remove a nil *DockerContainer")
+		return errors.New("cannot remove a nil *DockerContainer")
 	}
 
 	if d.keepForDebugging {
@@ -169,7 +169,7 @@ func (d *DockerContainer) Remove() error {
 
 func (d *DockerContainer) Inspect() error {
 	if d == nil {
-		return errors.New("Cannot inspect a nil *DockerContainer")
+		return errors.New("cannot inspect a nil *DockerContainer")
 	}
 
 	if len(d.ContainerId) == 0 {
@@ -187,7 +187,7 @@ func (d *DockerContainer) Inspect() error {
 
 func (d *DockerContainer) Logs() (io.ReadCloser, error) {
 	if d == nil {
-		return nil, errors.New("Cannot view logs for a nil *DockerContainer")
+		return nil, errors.New("cannot view logs for a nil *DockerContainer")
 	}
 	if len(d.ContainerId) == 0 {
 		return nil, errors.New("missing containerId")

Original file line number	Diff line number	Diff line change
`@@ -336,7 +336,7 @@ func parseConsistency(consistencyStr string) (consistency gocql.Consistency, err`
`336`	`336`	`var ok bool`
`337`	`337`	`err, ok = r.(error)`
`338`	`338`	`if !ok {`
`339`		`- err = fmt.Errorf("Failed to parse consistency \"%s\": %v", consistencyStr, r)`
	`339`	`+ err = fmt.Errorf("failed to parse consistency \"%s\": %v", consistencyStr, r)`
`340`	`340`	`}`
`341`	`341`	`}`
`342`	`342`	`}()`
Original file line number	Diff line number	Diff line change
`@@ -307,5 +307,5 @@ func quoteIdentifier(name string) string {`
`307`	`307`	`if end > -1 {`
`308`	`308`	`name = name[:end]`
`309`	`309`	`}`
`310`		- return `"` + strings.Replace(name, `"`, `""`, -1) + `"`
	`310`	+ return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
`311`	`311`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ var (`
`34`	`34`	`ErrNilConfig = fmt.Errorf("no config")`
`35`	`35`	`ErrNoDatabaseName = fmt.Errorf("no database name")`
`36`	`36`	`ErrAppendPEM = fmt.Errorf("failed to append PEM")`
`37`		`- ErrTLSCertKeyConfig = fmt.Errorf("To use TLS client authentication, both x-tls-cert and x-tls-key must not be empty")`
	`37`	`+ ErrTLSCertKeyConfig = fmt.Errorf("to use TLS client authentication, both x-tls-cert and x-tls-key must not be empty")`
`38`	`38`	`)`
`39`	`39`
`40`	`40`	`type Config struct {`
Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {`
`181`	`181`	`if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {`
`182`	`182`	`migrationsTableQuoted, err = strconv.ParseBool(s)`
`183`	`183`	`if err != nil {`
`184`		`- return nil, fmt.Errorf("Unable to parse option x-migrations-table-quoted: %w", err)`
	`184`	`+ return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)`
`185`	`185`	`}`
`186`	`186`	`}`
`187`	`187`	`if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') \|\| (migrationsTable[len(migrationsTable)-1] != '"')) {`
`@@ -212,7 +212,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {`
`212`	`212`	`if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {`
`213`	`213`	`multiStatementEnabled, err = strconv.ParseBool(s)`
`214`	`214`	`if err != nil {`
`215`		`- return nil, fmt.Errorf("Unable to parse option x-multi-statement: %w", err)`
	`215`	`+ return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
`@@ -412,7 +412,7 @@ func (p *Postgres) runStatement(statement []byte) error {`
`412`	`412`
`413`	`413`	`func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {`
`414`	`414`	`// replace crlf with lf`
`415`		`- s = strings.Replace(s, "\r\n", "\n", -1)`
	`415`	`+ s = strings.ReplaceAll(s, "\r\n", "\n")`
`416`	`416`	`// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes`
`417`	`417`	`runes := []rune(s)`
`418`	`418`	`if pos > len(runes) {`
`@@ -613,5 +613,5 @@ func quoteIdentifier(name string) string {`
`613`	`613`	`if end > -1 {`
`614`	`614`	`name = name[:end]`
`615`	`615`	`}`
`616`		- return `"` + strings.Replace(name, `"`, `""`, -1) + `"`
	`616`	+ return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
`617`	`617`	`}`
Original file line number	Diff line number	Diff line change
`@@ -755,10 +755,10 @@ func Test_computeLineFromPos(t *testing.T) {`
`755`	`755`	`t.Run(name, func(t *testing.T) {`
`756`	`756`	`input := tc.input`
`757`	`757`	`if crlf {`
`758`		`- input = strings.Replace(input, "\n", "\r\n", -1)`
	`758`	`+ input = strings.ReplaceAll(input, "\n", "\r\n")`
`759`	`759`	`}`
`760`	`760`	`if nonASCII {`
`761`		`- input = strings.Replace(input, "FROM", "FRÖM", -1)`
	`761`	`+ input = strings.ReplaceAll(input, "FROM", "FRÖM")`
`762`	`762`	`}`
`763`	`763`	`gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)`
`764`	`764`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {`
`157`	`157`	`if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {`
`158`	`158`	`migrationsTableQuoted, err = strconv.ParseBool(s)`
`159`	`159`	`if err != nil {`
`160`		`- return nil, fmt.Errorf("Unable to parse option x-migrations-table-quoted: %w", err)`
	`160`	`+ return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') \|\| (migrationsTable[len(migrationsTable)-1] != '"')) {`
`@@ -188,7 +188,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {`
`188`	`188`	`if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {`
`189`	`189`	`multiStatementEnabled, err = strconv.ParseBool(s)`
`190`	`190`	`if err != nil {`
`191`		`- return nil, fmt.Errorf("Unable to parse option x-multi-statement: %w", err)`
	`191`	`+ return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`
`@@ -303,7 +303,7 @@ func (p *Postgres) runStatement(statement []byte) error {`
`303`	`303`
`304`	`304`	`func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {`
`305`	`305`	`// replace crlf with lf`
`306`		`- s = strings.Replace(s, "\r\n", "\n", -1)`
	`306`	`+ s = strings.ReplaceAll(s, "\r\n", "\n")`
`307`	`307`	`// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes`
`308`	`308`	`runes := []rune(s)`
`309`	`309`	`if pos > len(runes) {`
`@@ -476,5 +476,5 @@ func quoteIdentifier(name string) string {`
`476`	`476`	`if end > -1 {`
`477`	`477`	`name = name[:end]`
`478`	`478`	`}`
`479`		- return `"` + strings.Replace(name, `"`, `""`, -1) + `"`
	`479`	+ return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
`480`	`480`	`}`
Original file line number	Diff line number	Diff line change
`@@ -730,10 +730,10 @@ func Test_computeLineFromPos(t *testing.T) {`
`730`	`730`	`t.Run(name, func(t *testing.T) {`
`731`	`731`	`input := tc.input`
`732`	`732`	`if crlf {`
`733`		`- input = strings.Replace(input, "\n", "\r\n", -1)`
	`733`	`+ input = strings.ReplaceAll(input, "\n", "\r\n")`
`734`	`734`	`}`
`735`	`735`	`if nonASCII {`
`736`		`- input = strings.Replace(input, "FROM", "FRÖM", -1)`
	`736`	`+ input = strings.ReplaceAll(input, "FROM", "FRÖM")`
`737`	`737`	`}`
`738`	`738`	`gotLine, gotCol, gotOK := computeLineFromPos(input, tc.pos)`
`739`	`739`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {`
`165`	`165`	`if s := purl.Query().Get("x-migrations-table-quoted"); len(s) > 0 {`
`166`	`166`	`migrationsTableQuoted, err = strconv.ParseBool(s)`
`167`	`167`	`if err != nil {`
`168`		`- return nil, fmt.Errorf("Unable to parse option x-migrations-table-quoted: %w", err)`
	`168`	`+ return nil, fmt.Errorf("unable to parse option x-migrations-table-quoted: %w", err)`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`	`if (len(migrationsTable) > 0) && (migrationsTableQuoted) && ((migrationsTable[0] != '"') \|\| (migrationsTable[len(migrationsTable)-1] != '"')) {`
`@@ -196,7 +196,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) {`
`196`	`196`	`if s := purl.Query().Get("x-multi-statement"); len(s) > 0 {`
`197`	`197`	`multiStatementEnabled, err = strconv.ParseBool(s)`
`198`	`198`	`if err != nil {`
`199`		`- return nil, fmt.Errorf("Unable to parse option x-multi-statement: %w", err)`
	`199`	`+ return nil, fmt.Errorf("unable to parse option x-multi-statement: %w", err)`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`
`@@ -319,7 +319,7 @@ func (p *Postgres) runStatement(statement []byte) error {`
`319`	`319`
`320`	`320`	`func computeLineFromPos(s string, pos int) (line uint, col uint, ok bool) {`
`321`	`321`	`// replace crlf with lf`
`322`		`- s = strings.Replace(s, "\r\n", "\n", -1)`
	`322`	`+ s = strings.ReplaceAll(s, "\r\n", "\n")`
`323`	`323`	`// pg docs: pos uses index 1 for the first character, and positions are measured in characters not bytes`
`324`	`324`	`runes := []rune(s)`
`325`	`325`	`if pos > len(runes) {`