The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

cmd/internal/migrations/v3/logger_generics.go (3)

21-26: Infer logger type across the package, not just per-file (avoid falling back to any in split files)

Today you infer loggerType only from the same file. In real projects, Logger() may live in logger.go while usages are elsewhere, causing those files to default to any unnecessarily. Consider a pre-pass to scan the tree once and compute a package-wide fallback type, then use the per-file type when present.

I can wire a light-weight pre-scan helper (no AST needed) and use it when the per-file inference yields "any". Want me to push a patch?

---

14-20: Handle parenthesized or named return types in Logger() signatures

Your current reLoggerType misses valid forms like:

• func (c *L) Logger() (*zap.Logger) { ... }
• func (c *L) Logger() (l *zap.Logger) { ... }

Add a second regex (as in the diff above) to capture parenthesized/named returns before the function body.

---

21-73: Note on comment/string literals

Regex replacement runs on the entire source including comments/strings, so occurrences like "// use fiberlog.DefaultLogger()" will be rewritten. Low risk, but noisy diffs. If this becomes a problem, we can parse tokens and skip comments/strings or strip them before replacement.

If you want, I can provide a token-scan that ignores comments and string literals with go/scanner to keep changes minimal and safe.

cmd/internal/migrations/v3/logger_generics_test.go (1)

49-86: Great coverage for zap-specific inference; add idempotency and alias-scope tests

• Idempotency: run the migration twice and assert the second pass emits no "Migrating logger generics" and makes no further changes.
• Alias scope: include another import that exposes DefaultLogger() (non-fiber) and assert it is not rewritten once alias filtering is added.

Here are test stubs you can add after adopting alias filtering:

@@
 func Test_MigrateLoggerGenerics_Zap(t *testing.T) {
@@
 }
 
+func Test_MigrateLoggerGenerics_Idempotent(t *testing.T) {
+	t.Parallel()
+	dir, err := os.MkdirTemp("", "mloggenericstestidemp")
+	require.NoError(t, err)
+	defer func() { require.NoError(t, os.RemoveAll(dir)) }()
+
+	file := writeTempFile(t, dir, `package main
+import fiberlog "github.com/gofiber/fiber/v2/log"
+type customLogger struct{}
+func (c *customLogger) Logger() *customLogger { return nil }
+var _ fiberlog.AllLogger = (*customLogger)(nil)
+func main() { _ = fiberlog.DefaultLogger().Logger() }`)
+
+	var buf1 bytes.Buffer
+	cmd1 := newCmd(&buf1)
+	require.NoError(t, v3.MigrateLoggerGenerics(cmd1, dir, nil, nil))
+	content1 := readFile(t, file)
+	assert.Contains(t, content1, "DefaultLogger[")
+	assert.Contains(t, buf1.String(), "Migrating logger generics")
+
+	var buf2 bytes.Buffer
+	cmd2 := newCmd(&buf2)
+	require.NoError(t, v3.MigrateLoggerGenerics(cmd2, dir, nil, nil))
+	assert.NotContains(t, buf2.String(), "Migrating logger generics")
+	content2 := readFile(t, file)
+	assert.Equal(t, content1, content2)
+}
+
+func Test_MigrateLoggerGenerics_OnlyFiberLogAlias(t *testing.T) {
+	t.Parallel()
+	dir, err := os.MkdirTemp("", "mloggenericstestalias")
+	require.NoError(t, err)
+	defer func() { require.NoError(t, os.RemoveAll(dir)) }()
+
+	file := writeTempFile(t, dir, `package main
+import (
+    fiberlog "github.com/gofiber/fiber/v2/log"
+    other "github.com/some/otherpkg"
+)
+func main() {
+    _ = fiberlog.DefaultLogger()
+    _ = other.DefaultLogger() // must not be rewritten
+}`)
+	var buf bytes.Buffer
+	cmd := newCmd(&buf)
+	require.NoError(t, v3.MigrateLoggerGenerics(cmd, dir, nil, nil))
+	content := readFile(t, file)
+	assert.Contains(t, content, "fiberlog.DefaultLogger[")
+	assert.Contains(t, content, "other.DefaultLogger()") // unchanged
+}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

cmd/internal/migrations/v3/logger_generics.go (2)

62-96: DRY up repetitive ReplaceAll blocks with a small loop.

The five near-identical ReplaceAllStringFunc blocks increase maintenance surface. Collapse them into a table-driven loop. This mirrors a previously suggested refactor.

-		content = reAllLogger.ReplaceAllStringFunc(content, func(m string) string {
-			sub := reAllLogger.FindStringSubmatch(m)
-			if len(sub) != 3 {
-				return m
-			}
-			return fmt.Sprintf("%s.AllLogger[%s]%s", sub[1], loggerType, sub[2])
-		})
-		content = reConfigurableLogger.ReplaceAllStringFunc(content, func(m string) string {
-			sub := reConfigurableLogger.FindStringSubmatch(m)
-			if len(sub) != 3 {
-				return m
-			}
-			return fmt.Sprintf("%s.ConfigurableLogger[%s]%s", sub[1], loggerType, sub[2])
-		})
-		content = reDefaultLogger.ReplaceAllStringFunc(content, func(m string) string {
-			sub := reDefaultLogger.FindStringSubmatch(m)
-			if len(sub) != 2 {
-				return m
-			}
-			return fmt.Sprintf("%s.DefaultLogger[%s]()", sub[1], loggerType)
-		})
-		content = reSetLogger.ReplaceAllStringFunc(content, func(m string) string {
-			sub := reSetLogger.FindStringSubmatch(m)
-			if len(sub) != 2 {
-				return m
-			}
-			return fmt.Sprintf("%s.SetLogger[%s](", sub[1], loggerType)
-		})
-		content = reLoggerToWriter.ReplaceAllStringFunc(content, func(m string) string {
-			sub := reLoggerToWriter.FindStringSubmatch(m)
-			if len(sub) != 2 {
-				return m
-			}
-			return fmt.Sprintf("%s.LoggerToWriter[%s](", sub[1], loggerType)
-		})
+		type replacement struct {
+			re               *regexp.Regexp
+			format           string
+			expectedSubmatch int
+		}
+		replacements := []replacement{
+			{re: reAllLogger, format: "%s.AllLogger[%s]%s", expectedSubmatch: 3},
+			{re: reConfigurableLogger, format: "%s.ConfigurableLogger[%s]%s", expectedSubmatch: 3},
+			{re: reDefaultLogger, format: "%s.DefaultLogger[%s]()", expectedSubmatch: 2},
+			{re: reSetLogger, format: "%s.SetLogger[%s](", expectedSubmatch: 2},
+			{re: reLoggerToWriter, format: "%s.LoggerToWriter[%s](", expectedSubmatch: 2},
+		}
+		for _, r := range replacements {
+			content = r.re.ReplaceAllStringFunc(content, func(m string) string {
+				sub := r.re.FindStringSubmatch(m)
+				if len(sub) != r.expectedSubmatch {
+					return m
+				}
+				args := []any{sub[1], loggerType}
+				if len(sub) > 2 {
+					args = append(args, sub[2])
+				}
+				return fmt.Sprintf(r.format, args...)
+			})
+		}

---

18-20: Broaden Logger() return-type detection (parenthesized/named/multiline).

Logger() can legally return types via parenthesized/named returns and across newlines; the current regex misses these. Add a secondary regex to capture func Logger() (*zap.Logger) and func Logger() (l *zap.Logger) forms and fall back to it if the primary doesn’t match.

 func MigrateLoggerGenerics(cmd *cobra.Command, cwd string, _, _ *semver.Version) error {
 	fiberImport := regexp.MustCompile(`^github\.com/gofiber/fiber/v\d+/log$`)
-	reLoggerType := regexp.MustCompile(`(?m)^func\s+(?:\(\w+\s+\*?\w+\)\s+)?Logger\(\)\s*(\*?\w+(?:\.\w+)*)\s*{`)
+	// Matches: func Logger() *zap.Logger { ... } or with receiver
+	reLoggerType := regexp.MustCompile(`(?m)^func\s+(?:\(\w+\s+\*?\w+\)\s+)?Logger\(\)\s*(\*?\w+(?:\.\w+)*)\s*{`)
+	// Matches parenthesized/named returns (also across newlines):
+	//   func Logger() (*zap.Logger) { ... }
+	//   func Logger() (l *zap.Logger) { ... }
+	reLoggerTypeParen := regexp.MustCompile(`(?ms)^func\s+(?:\(\w+\s+\*?\w+\)\s+)?Logger\(\)\s*\(\s*(?:\w+\s+)?(\*?\w+(?:\.\w+)*)\s*\)\s*{`)

-		loggerType := "any"
-		if m := reLoggerType.FindStringSubmatch(content); len(m) == 2 {
-			loggerType = m[1]
-		}
+		loggerType := "any"
+		if m := reLoggerType.FindStringSubmatch(content); len(m) == 2 && m[1] != "" {
+			loggerType = m[1]
+		} else if m := reLoggerTypeParen.FindStringSubmatch(content); len(m) == 2 && m[1] != "" {
+			loggerType = m[1]
+		}

cmd/internal/migrations/v3/logger_generics_test.go (2)

14-47: Solid happy-path coverage; add assertion for interface rewrites.

You already assert for AllLogger[any] and ConfigurableLogger[any]. Consider asserting the rewritten interface assertions too (e.g., var _ log.AllLogger[any] = ...) to prove replacements occur in type positions, not just calls.

---

49-86: Zap case looks good; add a variant for parenthesized/named returns.

To validate the enhanced Logger() return detection, add a test where Logger() returns via parentheses and/or named identifier.

+func Test_MigrateLoggerGenerics_ZapParenAndNamed(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	file := writeTempFile(t, dir, `package main
+import (
+    flog "github.com/gofiber/fiber/v2/log"
+    "go.uber.org/zap"
+)
+type customLogger struct{}
+// parenthesized
+func (c *customLogger) Logger() (*zap.Logger) { return nil }
+var _ flog.AllLogger = (*customLogger)(nil)
+var _ flog.ConfigurableLogger = (*customLogger)(nil)
+func main() {
+    _ = flog.DefaultLogger().Logger()
+}`)
+	var buf bytes.Buffer
+	cmd := newCmd(&buf)
+	require.NoError(t, v3.MigrateLoggerGenerics(cmd, dir, nil, nil))
+	content := readFile(t, file)
+	assert.Contains(t, content, "AllLogger[*zap.Logger]")
+	assert.Contains(t, content, "ConfigurableLogger[*zap.Logger]")
+	assert.Contains(t, content, "DefaultLogger[*zap.Logger]()")
+}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.