From 0390322dfe44595f570dad9f74f2bef62956583a Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Tue, 9 Dec 2025 18:27:45 -0800
Subject: [PATCH 01/10] feat(impl.stripPaths): handle quoted paths

---
 impl.go      | 17 ++++++++++++++++-
 impl_test.go | 15 ++++++++++-----
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/impl.go b/impl.go
index 9746cfe..2f7e207 100644
--- a/impl.go
+++ b/impl.go
@@ -85,6 +85,11 @@ func stripPaths(in string) string {
 	out := make([]rune, 0, len(runes))
 	for len(runes) > 0 {
 		// Find extent of path-like segment
+		isQuotedPath := false
+		if runes[0] == '"' {
+			runes = runes[1:]
+			isQuotedPath = true
+		}
 		n := slices.IndexFunc(runes, isNonPathRune)
 		seg := runes
 		if n >= 0 {
@@ -98,6 +103,9 @@ func stripPaths(in string) string {
 			break
 		}
 		runes = runes[n:]
+		if isQuotedPath && len(runes) > 0 {
+			runes = runes[1:]
+		}
 
 		// Copy non-path runes verbatim
 		n = slices.IndexFunc(runes, isPathRune)
@@ -105,6 +113,12 @@ func stripPaths(in string) string {
 		if n >= 0 {
 			seg = seg[:n]
 		}
+		if n > 0 && seg[0] == '"' {
+			seg = seg[1:]
+		}
+		if n > 1 && seg[len(seg)-1] == '"' {
+			seg = seg[:len(seg)-1]
+		}
 		out = append(out, seg...)
 		if n == -1 {
 			break
@@ -127,7 +141,8 @@ func lastIndex[S ~[]E, E comparable](s S, v E) int {
 // isPathRune reports whether r can appear in an import path.
 // See https://go.dev/ref/spec#Import_declarations.
 func isPathRune(r rune) bool {
-	return unicode.IsPrint(r) && !strings.ContainsRune(" \uFFFD!\"#$%&'()*,:;<=>?[\\]^`{|}", r)
+	return unicode.IsPrint(r) &&
+		!strings.ContainsRune(" \uFFFD!\"#$%&'()*,:;<=>?[\\]^`{|}", r)
 }
 
 func isNonPathRune(r rune) bool {
diff --git a/impl_test.go b/impl_test.go
index 81d4f9e..15844c4 100644
--- a/impl_test.go
+++ b/impl_test.go
@@ -693,35 +693,35 @@ func TestStubGenerationForImplemented(t *testing.T) {
 		want    string
 	}{
 		{
-			desc:    "without implemeted methods",
+			desc:    "without implemented methods",
 			iface:   "github.com/josharian/impl/testdata.Interface3",
 			recv:    "r *Implemented",
 			recvPkg: "testdata",
 			want:    testdata.Interface4Output,
 		},
 		{
-			desc:    "without implemeted methods with trailing space",
+			desc:    "without implemented methods with trailing space",
 			iface:   "github.com/josharian/impl/testdata.Interface3",
 			recv:    "r *Implemented ",
 			recvPkg: "testdata",
 			want:    testdata.Interface4Output,
 		},
 		{
-			desc:    "without implemeted methods, with generic receiver",
+			desc:    "without implemented methods, with generic receiver",
 			iface:   "github.com/josharian/impl/testdata.Interface3",
 			recv:    "r *ImplementedGeneric[Type1]",
 			recvPkg: "testdata",
 			want:    testdata.Interface4GenericOutput,
 		},
 		{
-			desc:    "without implemeted methods, with generic receiver with multiple params",
+			desc:    "without implemented methods, with generic receiver with multiple params",
 			iface:   "github.com/josharian/impl/testdata.Interface3",
 			recv:    "r *ImplementedGenericMultipleParams[Type1, Type2]",
 			recvPkg: "testdata",
 			want:    testdata.Interface4GenericMultipleParamsOutput,
 		},
 		{
-			desc:    "without implemeted methods and receiver variable",
+			desc:    "without implemented methods and receiver variable",
 			iface:   "github.com/josharian/impl/testdata.Interface3",
 			recv:    "*Implemented",
 			recvPkg: "testdata",
@@ -914,8 +914,13 @@ func TestStripPaths(t *testing.T) {
 	}{
 		{desc: "no path", input: "Iface", want: "Iface"},
 		{desc: "simple path", input: "a/b.T", want: "b.T"},
+		{desc: "simple quoted path", input: "\"a/b\".T", want: "b.T"},
 		{desc: "deep path", input: "github.com/foo/bar.T", want: "bar.T"},
+		{desc: "deep quoted path", input: "\"github.com/foo/bar\".T", want: "bar.T"},
 		{desc: "generic with path param", input: "Iface[github.com/foo/bar.T]", want: "Iface[bar.T]"},
+		{desc: "generic and interface with path param", input: "github.com/foo.Iface[github.com/foo/bar.T]", want: "foo.Iface[bar.T]"},
+		{desc: "generic and interface with quoted path param", input: "\"github.com/foo\".Iface[\"github.com/foo/bar\".T]", want: "foo.Iface[bar.T]"},
+		{desc: "generic with quoted path param", input: "Iface[\"github.com/foo/bar\".T]", want: "Iface[bar.T]"},
 		{desc: "multiple path params", input: "Iface[a/b.T, c/d.U]", want: "Iface[b.T, d.U]"},
 		{desc: "nested generic with paths", input: "Iface[a/b.Other[c/d.T]]", want: "Iface[b.Other[d.T]]"},
 		{desc: "pointer to path type", input: "Iface[*a/b.T]", want: "Iface[*b.T]"},

From 11942c56f90ff00ac24407d2bb20f512e2e78bb1 Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Tue, 9 Dec 2025 18:28:10 -0800
Subject: [PATCH 02/10] feat(impl.findInterface): handle quoted paths

---
 impl.go      | 2 +-
 impl_test.go | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/impl.go b/impl.go
index 2f7e207..b3eecfd 100644
--- a/impl.go
+++ b/impl.go
@@ -190,7 +190,7 @@ func findInterface(input string, srcDir string) (path string, iface Type, err er
 		if dot <= slash {
 			return "", Type{}, fmt.Errorf("invalid interface name: %s", input)
 		}
-		path = baseInput[:dot]
+		path = strings.Trim(baseInput[:dot], "\"")
 		id := stripPaths(input[dot+1:])
 		iface, err = parseType(id)
 		if err != nil {
diff --git a/impl_test.go b/impl_test.go
index 15844c4..358b14e 100644
--- a/impl_test.go
+++ b/impl_test.go
@@ -34,6 +34,7 @@ func TestFindInterface(t *testing.T) {
 		{input: "a/b/c/pkg", wantErr: true},
 		{input: "a/b/c/pkg.", wantErr: true},
 		{input: "a/b/c/pkg.Typ", path: "a/b/c/pkg", typ: Type{Name: "Typ"}},
+		{input: "\"a/b/c/pkg\".Typ", path: "a/b/c/pkg", typ: Type{Name: "Typ"}},
 		{input: "gopkg.in/yaml.v2.Unmarshaler", path: "gopkg.in/yaml.v2", typ: Type{Name: "Unmarshaler"}},
 		{input: "github.com/josharian/impl/testdata.GenericInterface1[string]", path: "github.com/josharian/impl/testdata", typ: Type{Name: "GenericInterface1", Params: []string{"string"}}},
 		{input: "github.com/josharian/impl/testdata.GenericInterface1[*string]", path: "github.com/josharian/impl/testdata", typ: Type{Name: "GenericInterface1", Params: []string{"*string"}}},

From 7325163fe3c2e54545afd0fb3ebb755fbe90ea1f Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Wed, 10 Dec 2025 08:20:54 -0800
Subject: [PATCH 03/10] Revert misc formatting change in isPathRune

---
 impl.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/impl.go b/impl.go
index b3eecfd..aab9947 100644
--- a/impl.go
+++ b/impl.go
@@ -141,8 +141,7 @@ func lastIndex[S ~[]E, E comparable](s S, v E) int {
 // isPathRune reports whether r can appear in an import path.
 // See https://go.dev/ref/spec#Import_declarations.
 func isPathRune(r rune) bool {
-	return unicode.IsPrint(r) &&
-		!strings.ContainsRune(" \uFFFD!\"#$%&'()*,:;<=>?[\\]^`{|}", r)
+	return unicode.IsPrint(r) && !strings.ContainsRune(" \uFFFD!\"#$%&'()*,:;<=>?[\\]^`{|}", r)
 }
 
 func isNonPathRune(r rune) bool {

From 86ebc9bb4f5a87f47e746cc155bf599af89f6b67 Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Wed, 10 Dec 2025 08:21:23 -0800
Subject: [PATCH 04/10] feat: add trimPathPrefix and trimPathSuffix functions

---
 impl.go | 32 ++++++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/impl.go b/impl.go
index aab9947..2375ec7 100644
--- a/impl.go
+++ b/impl.go
@@ -113,12 +113,8 @@ func stripPaths(in string) string {
 		if n >= 0 {
 			seg = seg[:n]
 		}
-		if n > 0 && seg[0] == '"' {
-			seg = seg[1:]
-		}
-		if n > 1 && seg[len(seg)-1] == '"' {
-			seg = seg[:len(seg)-1]
-		}
+		seg = trimPathPrefix(seg)
+		seg = trimPathSuffix(seg)
 		out = append(out, seg...)
 		if n == -1 {
 			break
@@ -128,6 +124,30 @@ func stripPaths(in string) string {
 	return string(out)
 }
 
+func trimPathSuffix(p []rune) []rune {
+	if len(p) == 0 {
+		return p
+	}
+
+	if p[len(p)-1] != '"' {
+		return p
+	}
+
+	return p[:len(p)-1]
+}
+
+func trimPathPrefix(p []rune) []rune {
+	if len(p) == 0 {
+		return p
+	}
+
+	if p[0] != '"' {
+		return p
+	}
+
+	return p[1:]
+}
+
 // lastIndex returns the index of the last occurrence of v in s, or -1 if not present.
 func lastIndex[S ~[]E, E comparable](s S, v E) int {
 	for i := len(s) - 1; i >= 0; i-- {

From 51198bec285d3edb3cf92c369f4ae015fbe760a4 Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Wed, 10 Dec 2025 08:23:53 -0800
Subject: [PATCH 05/10] refactor: replace tests containing \" with ``

---
 impl_test.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/impl_test.go b/impl_test.go
index 358b14e..13b49d5 100644
--- a/impl_test.go
+++ b/impl_test.go
@@ -34,7 +34,7 @@ func TestFindInterface(t *testing.T) {
 		{input: "a/b/c/pkg", wantErr: true},
 		{input: "a/b/c/pkg.", wantErr: true},
 		{input: "a/b/c/pkg.Typ", path: "a/b/c/pkg", typ: Type{Name: "Typ"}},
-		{input: "\"a/b/c/pkg\".Typ", path: "a/b/c/pkg", typ: Type{Name: "Typ"}},
+		{input: `"a/b/c/pkg".Typ`, path: "a/b/c/pkg", typ: Type{Name: "Typ"}},
 		{input: "gopkg.in/yaml.v2.Unmarshaler", path: "gopkg.in/yaml.v2", typ: Type{Name: "Unmarshaler"}},
 		{input: "github.com/josharian/impl/testdata.GenericInterface1[string]", path: "github.com/josharian/impl/testdata", typ: Type{Name: "GenericInterface1", Params: []string{"string"}}},
 		{input: "github.com/josharian/impl/testdata.GenericInterface1[*string]", path: "github.com/josharian/impl/testdata", typ: Type{Name: "GenericInterface1", Params: []string{"*string"}}},
@@ -915,13 +915,13 @@ func TestStripPaths(t *testing.T) {
 	}{
 		{desc: "no path", input: "Iface", want: "Iface"},
 		{desc: "simple path", input: "a/b.T", want: "b.T"},
-		{desc: "simple quoted path", input: "\"a/b\".T", want: "b.T"},
+		{desc: "simple quoted path", input: `"a/b".T`, want: "b.T"},
 		{desc: "deep path", input: "github.com/foo/bar.T", want: "bar.T"},
-		{desc: "deep quoted path", input: "\"github.com/foo/bar\".T", want: "bar.T"},
+		{desc: "deep quoted path", input: `"github.com/foo/bar".T`, want: "bar.T"},
 		{desc: "generic with path param", input: "Iface[github.com/foo/bar.T]", want: "Iface[bar.T]"},
 		{desc: "generic and interface with path param", input: "github.com/foo.Iface[github.com/foo/bar.T]", want: "foo.Iface[bar.T]"},
-		{desc: "generic and interface with quoted path param", input: "\"github.com/foo\".Iface[\"github.com/foo/bar\".T]", want: "foo.Iface[bar.T]"},
-		{desc: "generic with quoted path param", input: "Iface[\"github.com/foo/bar\".T]", want: "Iface[bar.T]"},
+		{desc: "generic and interface with quoted path param", input: `"github.com/foo".Iface["github.com/foo/bar".T]`, want: "foo.Iface[bar.T]"},
+		{desc: "generic with quoted path param", input: `Iface["github.com/foo/bar".T]`, want: "Iface[bar.T]"},
 		{desc: "multiple path params", input: "Iface[a/b.T, c/d.U]", want: "Iface[b.T, d.U]"},
 		{desc: "nested generic with paths", input: "Iface[a/b.Other[c/d.T]]", want: "Iface[b.Other[d.T]]"},
 		{desc: "pointer to path type", input: "Iface[*a/b.T]", want: "Iface[*b.T]"},

From 3b11bc0db46f69118bdfb4c8a336daff7d0273fb Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Thu, 11 Dec 2025 20:56:32 -0800
Subject: [PATCH 06/10] feat: add in unbalanced and double quoted path tests

---
 impl_test.go | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/impl_test.go b/impl_test.go
index 13b49d5..58c0b0c 100644
--- a/impl_test.go
+++ b/impl_test.go
@@ -56,6 +56,12 @@ func TestFindInterface(t *testing.T) {
 		{input: "github.com/josharian/impl/testdata.GenericInterface1[*github.com/josharian/impl/testdata.Struct5]", path: "github.com/josharian/impl/testdata", typ: Type{Name: "GenericInterface1", Params: []string{"*testdata.Struct5"}}},
 		// Hyphenated package path (hyphens in path segments, not in final package name)
 		{input: "github.com/go-chi/chi.Router[github.com/some-org/pkg.SomeType]", path: "github.com/go-chi/chi", typ: Type{Name: "Router", Params: []string{"pkg.SomeType"}}},
+		// Quoted path edge cases - unbalanced quotes
+		{input: `"a/b/c/pkg.Typ`, wantErr: true},              // missing closing quote
+		{input: `a/b/c/pkg".Typ`, wantErr: true},              // missing opening quote
+		{input: `"a/b/c/pkg.Typ"`, wantErr: true},             // quote after type name
+		{input: `""a/b/c/pkg"".Typ`, wantErr: true},           // double quotes
+		{input: `"github.com/josharian/impl/testdata".Interface1`, path: "github.com/josharian/impl/testdata", typ: Type{Name: "Interface1"}},
 	}
 
 	for _, tt := range cases {
@@ -912,10 +918,16 @@ func TestStripPaths(t *testing.T) {
 		desc  string
 		input string
 		want  string
+		wantErr bool
 	}{
 		{desc: "no path", input: "Iface", want: "Iface"},
 		{desc: "simple path", input: "a/b.T", want: "b.T"},
 		{desc: "simple quoted path", input: `"a/b".T`, want: "b.T"},
+		{desc: "simple unbalacned quote path", input: "\"a/b.T", wantErr: true},
+		{desc: "simple unbalacned quote path 2", input: "a/b\".T", wantErr: true},
+		{desc: "simple double quote path", input: "\"\"a/b\"\".T", wantErr: true},
+		{desc: "simple unbalanced double quote path", input: "a/b\"\".T", wantErr: true},
+		{desc: "simple unbalanced double quote path 2", input: "\"\"a/b.T", wantErr: true},
 		{desc: "deep path", input: "github.com/foo/bar.T", want: "bar.T"},
 		{desc: "deep quoted path", input: `"github.com/foo/bar".T`, want: "bar.T"},
 		{desc: "generic with path param", input: "Iface[github.com/foo/bar.T]", want: "Iface[bar.T]"},
@@ -968,7 +980,13 @@ func TestStripPaths(t *testing.T) {
 	for _, tt := range cases {
 		t.Run(tt.desc, func(t *testing.T) {
 			t.Parallel()
-			got := stripPaths(tt.input)
+			got, err := stripPaths(tt.input)
+			if err == nil && tt.wantErr {
+				t.Errorf("stripPaths(%q) = %q, want error", tt.input, got)
+			}
+			if err != nil && !tt.wantErr {
+				t.Errorf("stripPaths(%q) = got error %v, want %q", tt.input, err, tt.want)
+			}
 			if got != tt.want {
 				t.Errorf("stripPaths(%q) = %q, want %q", tt.input, got, tt.want)
 			}

From 41929ca5599fffda9ac8215ae8e13d91935d3d27 Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Thu, 11 Dec 2025 20:58:04 -0800
Subject: [PATCH 07/10] feat(stripPaths): error check unbalanced and double
 quoted paths

---
 impl.go | 53 ++++++++++++++++++++++++++++-------------------------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/impl.go b/impl.go
index 2375ec7..54be24b 100644
--- a/impl.go
+++ b/impl.go
@@ -80,16 +80,12 @@ func parseType(in string) (Type, error) {
 //	"Iface[a/b.T, c/d.U]" -> "Iface[b.T, d.U]"
 //	"Iface[a/b.Other[c/d.T]]" -> "Iface[b.Other[d.T]]"
 //	"Iface[*a/b.T]" -> "Iface[*b.T]"
-func stripPaths(in string) string {
+func stripPaths(in string) (string, error) {
 	runes := []rune(in)
 	out := make([]rune, 0, len(runes))
+	quotesRemoved := 0
 	for len(runes) > 0 {
 		// Find extent of path-like segment
-		isQuotedPath := false
-		if runes[0] == '"' {
-			runes = runes[1:]
-			isQuotedPath = true
-		}
 		n := slices.IndexFunc(runes, isNonPathRune)
 		seg := runes
 		if n >= 0 {
@@ -103,9 +99,6 @@ func stripPaths(in string) string {
 			break
 		}
 		runes = runes[n:]
-		if isQuotedPath && len(runes) > 0 {
-			runes = runes[1:]
-		}
 
 		// Copy non-path runes verbatim
 		n = slices.IndexFunc(runes, isPathRune)
@@ -113,39 +106,46 @@ func stripPaths(in string) string {
 		if n >= 0 {
 			seg = seg[:n]
 		}
-		seg = trimPathPrefix(seg)
-		seg = trimPathSuffix(seg)
+		lenPreTrim := len(seg)
+		seg = trimPathSeg(seg)
+		quotesRemoved += lenPreTrim - len(seg)
+		if checkForQuote(seg) {
+			return "", fmt.Errorf("double quotes")
+		}
+
 		out = append(out, seg...)
 		if n == -1 {
 			break
 		}
 		runes = runes[n:]
 	}
-	return string(out)
+	if quotesRemoved % 2 != 0 {
+		return "", fmt.Errorf("unbalanced quotes")
+	}
+	return string(out), nil
 }
 
-func trimPathSuffix(p []rune) []rune {
+func checkForQuote(p []rune) bool {
 	if len(p) == 0 {
-		return p
-	}
-
-	if p[len(p)-1] != '"' {
-		return p
+		return false
 	}
-
-	return p[:len(p)-1]
+	return p[0] == '"' || p[len(p)-1] == '"'
 }
 
-func trimPathPrefix(p []rune) []rune {
+func trimPathSeg(p []rune) []rune {
 	if len(p) == 0 {
 		return p
 	}
 
-	if p[0] != '"' {
-		return p
+	if p[0] == '"' {
+		return p[1:]
+	}
+
+	if p[len(p)-1] == '"' {
+		return p[:len(p)-1]
 	}
 
-	return p[1:]
+	return p
 }
 
 // lastIndex returns the index of the last occurrence of v in s, or -1 if not present.
@@ -210,7 +210,10 @@ func findInterface(input string, srcDir string) (path string, iface Type, err er
 			return "", Type{}, fmt.Errorf("invalid interface name: %s", input)
 		}
 		path = strings.Trim(baseInput[:dot], "\"")
-		id := stripPaths(input[dot+1:])
+		id, err := stripPaths(input[dot+1:])
+		if err != nil {
+			return "", Type{}, err
+		}
 		iface, err = parseType(id)
 		if err != nil {
 			return "", Type{}, err

From c8ed998baf126ec01273f4e385dc132ae68e423f Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Thu, 11 Dec 2025 21:49:20 -0800
Subject: [PATCH 08/10] test(findInterface): remove unsupported test cases

---
 impl_test.go | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/impl_test.go b/impl_test.go
index 58c0b0c..3d16e3c 100644
--- a/impl_test.go
+++ b/impl_test.go
@@ -56,12 +56,17 @@ func TestFindInterface(t *testing.T) {
 		{input: "github.com/josharian/impl/testdata.GenericInterface1[*github.com/josharian/impl/testdata.Struct5]", path: "github.com/josharian/impl/testdata", typ: Type{Name: "GenericInterface1", Params: []string{"*testdata.Struct5"}}},
 		// Hyphenated package path (hyphens in path segments, not in final package name)
 		{input: "github.com/go-chi/chi.Router[github.com/some-org/pkg.SomeType]", path: "github.com/go-chi/chi", typ: Type{Name: "Router", Params: []string{"pkg.SomeType"}}},
-		// Quoted path edge cases - unbalanced quotes
-		{input: `"a/b/c/pkg.Typ`, wantErr: true},              // missing closing quote
-		{input: `a/b/c/pkg".Typ`, wantErr: true},              // missing opening quote
-		{input: `"a/b/c/pkg.Typ"`, wantErr: true},             // quote after type name
-		{input: `""a/b/c/pkg"".Typ`, wantErr: true},           // double quotes
-		{input: `"github.com/josharian/impl/testdata".Interface1`, path: "github.com/josharian/impl/testdata", typ: Type{Name: "Interface1"}},
+
+		// Quoted path edge cases - unbalanced/double quotes
+		//// missing closing quote
+		//{input: `"a/b/c/pkg.Typ`, wantErr: true},
+		//// missing opening quote
+		//{input: `a/b/c/pkg".Typ`, wantErr: true},
+		//// quote after type name
+		//{input: `"a/b/c/pkg.Typ"`, wantErr: true},
+		//// double quotes
+		//{input: `""a/b/c/pkg"".Typ`, wantErr: true},
+		//{input: `"github.com/josharian/impl/testdata".Interface1`, path: "github.com/josharian/impl/testdata", typ: Type{Name: "Interface1"}},
 	}
 
 	for _, tt := range cases {

From 75420820c460183942134dec4e823426dc76abc0 Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Thu, 11 Dec 2025 21:49:49 -0800
Subject: [PATCH 09/10] refactor(stripPaths): clean up and document stripPaths

---
 impl.go | 97 +++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 74 insertions(+), 23 deletions(-)

diff --git a/impl.go b/impl.go
index 54be24b..9592d8f 100644
--- a/impl.go
+++ b/impl.go
@@ -80,51 +80,102 @@ func parseType(in string) (Type, error) {
 //	"Iface[a/b.T, c/d.U]" -> "Iface[b.T, d.U]"
 //	"Iface[a/b.Other[c/d.T]]" -> "Iface[b.Other[d.T]]"
 //	"Iface[*a/b.T]" -> "Iface[*b.T]"
+// For more examples, see the tests in impl_test.go
+//
+// Because of the staggered parsing, the handling of quoted paths is done in
+// a way that supports seeing the start and end quote in separate loop
+// iterations.
+//
+// Algorithm Example:
+// Given: "github.com/foo".Iface
+//
+// 1. First iteration
+//   a. Grab all path characters (none, because " is first)
+//   b. Grab all non-path characters (")
+//   c. Strip quotes (remove only the one)
+// 2. Second iteration
+//   a. Grab all path characters (github.com/foo)
+//   b. Grab all non-path characters (")
+//   c. Strip second quote
+// 3. etc
 func stripPaths(in string) (string, error) {
 	runes := []rune(in)
 	out := make([]rune, 0, len(runes))
 	quotesRemoved := 0
+
 	for len(runes) > 0 {
-		// Find extent of path-like segment
-		n := slices.IndexFunc(runes, isNonPathRune)
-		seg := runes
-		if n >= 0 {
-			seg = seg[:n]
-		}
-		if slash := lastIndex(seg, '/'); slash >= 0 {
-			seg = seg[slash+1:]
-		}
+		var seg []rune
+		var more bool
+
+		seg, runes, more = getPathSeg(runes)
 		out = append(out, seg...)
-		if n == -1 {
+		if !more {
 			break
 		}
-		runes = runes[n:]
 
-		// Copy non-path runes verbatim
-		n = slices.IndexFunc(runes, isPathRune)
-		seg = runes
-		if n >= 0 {
-			seg = seg[:n]
-		}
-		lenPreTrim := len(seg)
-		seg = trimPathSeg(seg)
-		quotesRemoved += lenPreTrim - len(seg)
+		seg, runes, more = getNonPathSeg(runes, &quotesRemoved)
+		// Check for remaining quote in segment. This is to handle
+		// double quotes
 		if checkForQuote(seg) {
 			return "", fmt.Errorf("double quotes")
 		}
-
 		out = append(out, seg...)
-		if n == -1 {
+		if !more {
 			break
 		}
-		runes = runes[n:]
 	}
+
+	// We want balanced quotes for our paths
 	if quotesRemoved % 2 != 0 {
 		return "", fmt.Errorf("unbalanced quotes")
 	}
+
 	return string(out), nil
 }
 
+func getNonPathSeg(runes []rune, quotesRemoved *int) (seg []rune, remain []rune, more bool) {
+	// Get index of next path character
+	n := slices.IndexFunc(runes, isPathRune)
+	// Copy all characters before the path character
+	seg = runes
+	if n >= 0 {
+		seg = seg[:n]
+	}
+	// Trim a quote from the segment
+	lenPreTrim := len(seg)
+	seg = trimPathSeg(seg)
+	// If a quote was removed, increment the number of quotes removed
+	// This is for checking that the quotations are balanced
+	*quotesRemoved += lenPreTrim - len(seg)
+	// If there are no path like characters, we are done
+	if n == -1 {
+		return seg, []rune{}, false
+	}
+	remain = runes[n:]
+	return seg, remain, true
+}
+
+func getPathSeg(runes []rune) (seg []rune, remain []rune, more bool) {
+	// Find first index of a non-path character
+	n := slices.IndexFunc(runes, isNonPathRune)
+	// Get characters up to the non-path character
+	seg = runes
+	if n >= 0 {
+		seg = seg[:n]
+	}
+	// If there is a path separator, get the segment at
+	// the end of the path
+	if slash := lastIndex(seg, '/'); slash >= 0 {
+		seg = seg[slash+1:]
+	}
+	// if there is no non-path like characters, we are done
+	if n == -1 {
+		return seg, []rune{}, false
+	}
+	remain = runes[n:]
+	return seg, remain, true
+}
+
 func checkForQuote(p []rune) bool {
 	if len(p) == 0 {
 		return false

From 02eeb5f4c7d7e097def0ad0dc08f1cb46234f0df Mon Sep 17 00:00:00 2001
From: EliSauder <24995216+EliSauder@users.noreply.github.com>
Date: Thu, 11 Dec 2025 22:38:11 -0800
Subject: [PATCH 10/10] refactor(stripPaths): rename runes to remain for
 clarity

---
 impl.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/impl.go b/impl.go
index 9592d8f..fef12da 100644
--- a/impl.go
+++ b/impl.go
@@ -99,21 +99,21 @@ func parseType(in string) (Type, error) {
 //   c. Strip second quote
 // 3. etc
 func stripPaths(in string) (string, error) {
-	runes := []rune(in)
-	out := make([]rune, 0, len(runes))
+	remain := []rune(in)
+	out := make([]rune, 0, len(remain))
 	quotesRemoved := 0
 
-	for len(runes) > 0 {
+	for len(remain) > 0 {
 		var seg []rune
 		var more bool
 
-		seg, runes, more = getPathSeg(runes)
+		seg, remain, more = getPathSeg(remain)
 		out = append(out, seg...)
 		if !more {
 			break
 		}
 
-		seg, runes, more = getNonPathSeg(runes, &quotesRemoved)
+		seg, remain, more = getNonPathSeg(remain, &quotesRemoved)
 		// Check for remaining quote in segment. This is to handle
 		// double quotes
 		if checkForQuote(seg) {