fork of https://github.com/sourcegraph/zoekt
Export regexp optimisations (#392)
Export regexp optimisations for use by Sourcegraph and Searcher
author
James Cotter
committer
GitHub
date
(Jul 4, 2022, 2:59 PM +0100)
commit
a6988a1c
a6988a1c75bcd82354599ccca8812dfb9412312f
parent
ec21826d
ec21826d3553ba8aa95f68670877763349d058a1
+14
-14
+7
-7
query/parse.go
+7
-7
query/parse.go
···
137
137
case tokBranch:
138
138
expr = &Branch{Pattern: text}
139
139
case tokText, tokRegex:
140
-
q, err := regexpQuery(text, false, false)
140
+
q, err := RegexpQuery(text, false, false)
141
141
if err != nil {
142
142
return nil, 0, err
143
143
}
144
144
expr = q
145
145
case tokFile:
146
-
q, err := regexpQuery(text, false, true)
146
+
q, err := RegexpQuery(text, false, true)
147
147
if err != nil {
148
148
return nil, 0, err
149
149
}
150
150
expr = q
151
151
152
152
case tokContent:
153
-
q, err := regexpQuery(text, true, false)
153
+
q, err := RegexpQuery(text, true, false)
154
154
if err != nil {
155
155
return nil, 0, err
156
156
}
···
168
168
return nil, 0, fmt.Errorf("the sym: atom must have an argument")
169
169
}
170
170
171
-
q, err := regexpQuery(text, false, false)
171
+
q, err := RegexpQuery(text, false, false)
172
172
if err != nil {
173
173
return nil, 0, err
174
174
}
···
230
230
231
231
const regexpFlags syntax.Flags = syntax.ClassNL | syntax.PerlX | syntax.UnicodeGroups
232
232
233
-
// regexpQuery parses an atom into either a regular expression, or a
233
+
// RegexpQuery parses an atom into either a regular expression, or a
234
234
// simple substring atom.
235
-
func regexpQuery(text string, content, file bool) (Q, error) {
235
+
func RegexpQuery(text string, content, file bool) (Q, error) {
236
236
var expr Q
237
237
238
238
r, err := syntax.Parse(text, regexpFlags)
···
240
240
return nil, err
241
241
}
242
242
243
-
r = optimizeRegexp(r)
243
+
r = OptimizeRegexp(r, regexpFlags)
244
244
245
245
if r.Op == syntax.OpLiteral {
246
246
expr = &Substring{
+6
-6
query/regexp.go
+6
-6
query/regexp.go
···
43
43
return &newRE
44
44
}
45
45
46
-
// optimizeRegexp converts capturing groups to non-capturing groups.
46
+
// OptimizeRegexp converts capturing groups to non-capturing groups.
47
47
// Returns original input if an error is encountered
48
-
func optimizeRegexp(re *syntax.Regexp) *syntax.Regexp {
49
-
r := convertCapture(re)
48
+
func OptimizeRegexp(re *syntax.Regexp, flags syntax.Flags) *syntax.Regexp {
49
+
r := convertCapture(re, flags)
50
50
return r.Simplify()
51
51
}
52
52
53
-
func convertCapture(re *syntax.Regexp) *syntax.Regexp {
53
+
func convertCapture(re *syntax.Regexp, flags syntax.Flags) *syntax.Regexp {
54
54
if !hasCapture(re) {
55
55
return re
56
56
}
57
57
58
58
// Make a copy so in unlikely event of an error the original can be used as a fallback
59
-
r, err := syntax.Parse(re.String(), regexpFlags)
59
+
r, err := syntax.Parse(re.String(), flags)
60
60
if err != nil {
61
61
log.Printf("failed to copy regexp `%s`: %v", re, err)
62
62
return re
···
65
65
r = uncapture(r)
66
66
67
67
// Parse again for new structure to take effect
68
-
r, err = syntax.Parse(r.String(), regexpFlags)
68
+
r, err = syntax.Parse(r.String(), flags)
69
69
if err != nil {
70
70
log.Printf("failed to parse regexp after uncapture `%s`: %v", r, err)
71
71
return re
+1
-1
query/regexp_test.go
+1
-1
query/regexp_test.go
···
86
86
simplifiedWant := mustParseRE(tt.want).Simplify()
87
87
88
88
in := mustParseRE(tt.in)
89
-
got := optimizeRegexp(in)
89
+
got := OptimizeRegexp(in, regexpFlags)
90
90
91
91
// String comparison as the same Regexp string can have different ASTs
92
92
// e.g. optimize of `ba(na){1,2}` == `bana(?:na)?`